Das Array mit dem größten "Gewicht" finden

cottton

Moin,
ich hoffe es wird nicht zu kompliziert.
Was will: ein Multidimensionales durchlaufen, und dabei das Unter-Array mit dem größten "Gewicht" finden.

Was für ein Gewicht?

PHP

// bsp 1
array(
    array( // dieses array "gewinnt", da es den größten wert besitzt
        'a' => 1 
    ),
    array(
        'a' => 0
    )
)
// bsp 2
array(
    array(
        'a' => 0
        'b' => 1
    ),
    array( // dieses array "gewinnt", da es den größten wert besitzt
        'a' => 1
        'b' => 1
    )
)

Alles anzeigen

Per mitgegebenen Keys soll noch festgelegt werden können, welche Keys geprüft werden.
Die Reihenfolge der mitgegebenen Keys soll außerdem das "Gewicht" dieser Keys festlegen.

Zwischenfrage:
kennt jemand einen Algo / Funktion, die genau das o.ä. macht?

Was ich momentan hab und funktioniert:

PHP

<?php







$from = 0;
$upto = 1;
$i = 0;




$source = array(
    'key' . ++$i => array(
        'a' => mt_rand($from, $upto),
        'b' => mt_rand($from, $upto),
        'c' => mt_rand($from, $upto),
    ),
    'key' . ++$i => array(
        'a' => mt_rand($from, $upto),
        'b' => mt_rand($from, $upto),
        'c' => mt_rand($from, $upto),
    ),
    'key' . ++$i => array(
        'a' => mt_rand($from, $upto),
        'b' => mt_rand($from, $upto),
        'c' => mt_rand($from, $upto),
    ),
);




echo '<pre>';
$r = array_weigth($source, array('c', 'b', 'a'));
echo '<pre>source:<br>';
print_r($source);
echo '<hr>result:<br>';
echo 'compare_keys: array(\'c\', \'b\', \'a\')<br>';
print_r($r);
echo '<br>';
print_r($source[$r]);




function array_weigth(array $source, array $compare_keys=array()){
    if(!function_exists('array_weigth_')){
        function array_weigth_(array &$source, $source_key, $target_source_key, array &$compare_keys, $compare_key, $greater_before){
            $current_source_val = $source[$source_key][$compare_keys[$compare_key]];
            $current_target_val = $source[$target_source_key][$compare_keys[$compare_key]];
            $greater            = ($current_source_val > $current_target_val);
            $greater_equal      = ($current_source_val >= $current_target_val);
            if(
                ($greater_equal === true or $greater_before === true)
                and (
                    !isset($compare_keys[++$compare_key])
                    or array_weigth_(
                        $source, $source_key, $target_source_key, $compare_keys, $compare_key, $greater
                    ) === true
                )
            ){
                return true;
            }
            return false;
        }
    }
    if(count($compare_keys) === 0){
        foreach($source as $array){
            if(!is_array($array)){
                return false;
            }
            $compare_keys = array_unique(array_merge($compare_keys, array_keys($array)));
        }
        if(count($compare_keys) === 0){
            return false;
        }
    }
    reset($source);
    $target_source_key = key($source);
    foreach(array_keys($source) as $source_key){
        $target_source_key = (
            array_weigth_($source, $source_key, $target_source_key, $compare_keys, 0, null) === true
        ) ? $source_key : $target_source_key;
    }
    return $target_source_key;
}







?>

Alles anzeigen

Bsp-Ausgabe:

Code

source:
Array
(
    [key1] => Array
        (
            [a] => 0
            [b] => 1
            [code=c] => 1
        )




    [key2] => Array
        (
            [a] => 0
            [b] => 1
            [code=c] => 0
        )




    [key3] => Array
        (
            [a] => 1
            [b] => 1
            [code=c] => 1
        )




)
result:
compare_keys: array('c', 'b', 'a')
key3
Array
(
    [a] => 1
    [b] => 1
    [code=c] => 1
)

Alles anzeigen

Ergebnis: ok.
key3 gewählt, da alle Felder 1 sind --was mehr als bei allen anderen ist.

Bsü-Ausgabe 2:

Code

source:
Array
(
    [key1] => Array
        (
            [a] => 0
            [b] => 0
            [code=c] => 1
        )




    [key2] => Array
        (
            [a] => 0
            [b] => 1
            [code=c] => 1
        )




    [key3] => Array
        (
            [a] => 1
            [b] => 0
            [code=c] => 1
        )




)
result:
compare_keys: array('c', 'b', 'a')
key2
Array
(
    [a] => 0
    [b] => 1
    [code=c] => 1
)

Alles anzeigen

Ergebnis: ok.
key2 gewählt, da:
keys angegeben in Reihenfolge: c, b, a (c hat das größte Gewicht, dann b, dann a) -- also wird auch erst c, dann b, dann a gecheckt
Bei allen ist c = 1, also kommen erstmal alle in Frage.
b ist aber nur bei key2 auf 1 gesetzt.
Auch wenn a bei key3 größer ist, "gewinnt" hier key2, da b mehr Gewicht hat als a.
(hoffe man versteht mich )

Frage:
Was mach ich bei Values die > 1 sind. Also zB 0-10?
Ist das folgende Ergebnis "gefühlt" in Ordnung, oder eher nicht?

Code

source:
Array
(
    [key1] => Array
        (
            [a] => 8
            [b] => 4
            [code=c] => 9
        )




    [key2] => Array
        (
            [a] => 1
            [b] => 7
            [code=c] => 7
        )




    [key3] => Array
        (
            [a] => 2
            [b] => 9
            [code=c] => 3
        )




)
result:
compare_keys: array('c', 'b', 'a')
key1
Array
(
    [a] => 8
    [b] => 4
    [code=c] => 9
)

Alles anzeigen

Test script hier (refresh für random values -- klar) Test Script

Nitamud

Erinnert mich jetzt spontan an Medaillien bei einer Weltmeisterschaft , deren Werte auf einmal geändert werden

Ich muss nochmal kurz nachfragen ob ich das richtig verstanden habe:

PHP

//Wertigkeit c,b,a
array(
    array(
        'a' => 0
        'b' => 0
        'c' => 1
    ),
    array( // dieses array "verliert", richtig?
        'a' => 1
        'b' => 1
        'c' => 0
    )
)

Alles anzeigen

Zweitens würde es mich interessieren ob es eine beliebige oder eine statische Anzahl an Keys gibt, bzw ob es beispielsweise nur die Buchstaben von a-z geben soll oder auch Kreationen wie 'Geld' , 'kg' etc. gültig sind. Zudem noch eine Frage: Haben alle verglichenen Arrays immer exakt die gleichen Keys oder kann es vorkommen das ein Array die Keys a,b besitzt und das Vergleichsarray nur a besitzt?

Zitat

Frage:
Was mach ich bei Values die > 1 sind. Also zB 0-10?
Ist das folgende Ergebnis "gefühlt" in Ordnung, oder eher nicht?

Fühlt sich meiner Meinung nach richtig an

cottton

Ja, hast Du richtig verstanden.
Anzahl der Keys ist beliebig. Die Keys (Typ und Form) sind auch beliebig.
Wenn ein Array einen angegebenen Key nicht hat, dann würde das Script momentan noch in einen Fehler rennen.
Aber solange die angegebenen Keys existieren sollte alles laufen:
Source:

PHP

$source = array(
    'Eins' => array(
        'wasAnderes'    => array(1, 2, 3),
        'rot'           => 0,
        'blau'          => 0,
        111             => new stdClass(),
        'gelb'          => 1,
        '#1'            => null,
    ),
    'Drei' => array(
        'blau'  => 0,
        'rot'   => 1,
        '&&' => '...',
        'gelb'  => 1,
    ),
    'Zwei' => array(
        111     => new stdClass(),
        'rot'   => false, // plötzlich bool statt numeric
        'gelb'  => true, // plötzlich bool statt numeric
        'blau'  => null, // plötzlich bool statt numeric
        0       => '',
    ),
);

Alles anzeigen

Code

source:
Array
(
    [Eins] => Array
        (
            [wasAnderes] => Array
                (
                    [0] => 1
                    [1] => 2
                    [2] => 3
                )




            [rot] => 0
            [blau] => 0
            [111] => stdClass Object
                (
                )




            [gelb] => 1
            [#1] => 
        )




    [Drei] => Array
        (
            [blau] => 0
            [rot] => 1
            [&&] => ...
            [gelb] => 1
        )




    [Zwei] => Array
        (
            [111] => stdClass Object
                (
                )




            [rot] => 
            [gelb] => 1
            [blau] => 
            [0] => 
        )




)
result:
compare_keys: array('rot', 'gelb', 'blau')
Drei
Array
(
    [blau] => 0
    [rot] => 1
    [&&] => ...
    [gelb] => 1
)

Alles anzeigen

Zitat

Fühlt sich meiner Meinung nach richtig an

Gut, dann sehe ich es mal als (fast) fertig an =)
Nur noch Das mit den evtl fehlenden Key (Zwecks undefined index ...).

Nitamud

Habe das ganze auch nochmal selber umgesetzt-> möchte euch die Klasse dafür nicht vorenthalten:

PHP

class SortByWeight {

    private $weightList = [];
    private $objList    = [];

    public function __construct(array $weightList,array $obj) {

    $this->weightList = (array) $weightList;
    $this->objList    = (array) $obj;


}

    public function weightSort()

{   


    $sortObj = $this->objList; 
    uasort($sortObj,array($this,'multiple_order'));


   return $sortObj;
}




private function multiple_order($a, $b)
{
  $list = $this->weightList;

  foreach ($list as $current)
  {
    if (!isset($a[$current]) && !isset($b[$current])) return 0;
    if (!isset($a[$current])) return 1;
    if (!isset($b[$current])) return -1;

    return $a[$current] > $b[$current] ? -1 : 1;
   }




 
}




}

Alles anzeigen

Beispiel:

PHP

$test = ['key1' =>  ['bla' => 4, 'blu' => 50],
         'key2' => ['bla' => 14, 'blu' => 40],
         'key3' => ['x' => 0]
        ];




$weightList = ['blu','bla'];







$Instanz = new SortByWeight($weightList,$test);
print_r($Instanz->weightSort());

Alles anzeigen

Kommentare folgen dann noch später, habe gerade keine Zeit mehr dazu

Jetzt mitmachen!