Alle möglichen Kombinationen in PHP abrufen: Eine umfassende Lösung

Das Abrufen aller möglichen Kombinationen aus einem 1D-Array kann eine komplexe Aufgabe sein, insbesondere wenn Dabei werden sowohl Kombinationen als auch Permutationen berücksichtigt. Obwohl es verschiedene Ansätze für dieses Problem gibt, besteht eine sehr effektive Lösung darin, eine rekursive Funktion zu implementieren.

Die rekursive Funktion Depth_picker() führt eine Tiefensuche im Array durch, durchsucht alle Zweige und kombiniert Elemente, um sie zu bilden Kombinationen. Es verwaltet eine temporäre Zeichenfolge, die mit jedem Element schrittweise geändert wird, während ein Sammelarray die endgültigen Kombinationen speichert. Sehen wir uns an, wie diese Funktion funktioniert:

1. Basisfall: Wenn die temporäre Zeichenfolge leer ist, bedeutet dies, dass ein eigenständiges Element berücksichtigt wird. In diesem Fall wird es direkt zum Sammelarray hinzugefügt.
2. Rekursive Erkundung: Wenn ein Element kombiniert werden soll, erstellt die Funktion eine Kopie des ursprünglichen Arrays und entfernt das aktuelle Element davon. Anschließend wird Depth_picker() rekursiv für das geänderte Array aufgerufen und die aktualisierte temporäre Zeichenfolge mit dem hinzugefügten Element übergeben. Wenn mehr Elemente kombiniert werden müssen, wird der rekursive Prozess fortgesetzt.
3. Kombinationen und Permutationen: Durch die Iteration durch jedes Element und deren rekursives Kombinieren generiert Depth_picker() effektiv alle möglichen Kombinationen und Permutationen ohne Wiederholung. Dieser Ansatz stellt sicher, dass beide Variationen von Zeichenfolgen („Alpha Beta“ und „Beta Alpha“) in der endgültigen Ausgabe enthalten sind.
4. Endergebnis: Wenn die Funktion alle Kombinationen untersucht hat, erfolgt die Erfassung Array enthält den vollständigen Satz aller möglichen Kombinationen aus dem Eingabearray.

Implementierung und Ausführung

Um diese Tiefensuche und das Abrufen von Kombinationen zu implementieren, kann der folgende PHP-Code verwendet werden:

 0) {
            depth_picker($arrcopy, $temp_string ." " . $elem[0], $collect);
        } else {
            $collect []= $temp_string. " " . $elem[0];
        }
    }
}

$collect = array();
depth_picker($array, "", $collect);
print_r($collect);

?>

Bei der Ausführung gibt dieser Code das folgende Array aller möglichen Kombinationen und Anordnungen aus:

Array
(
    [0] =>  Alpha
    [1] =>  Alpha Beta
    [2] =>  Alpha Beta Gamma
    [3] =>  Alpha Beta Gamma Sigma
    [4] =>  Alpha Beta Sigma
    [5] =>  Alpha Beta Sigma Gamma
    [6] =>  Alpha Gamma
    [7] =>  Alpha Gamma Beta
    [8] =>  Alpha Gamma Beta Sigma
    [9] =>  Alpha Gamma Sigma
    [10] =>  Alpha Gamma Sigma Beta
    [11] =>  Alpha Sigma
    [12] =>  Alpha Sigma Beta
    [13] =>  Alpha Sigma Beta Gamma
    [14] =>  Alpha Sigma Gamma
    [15] =>  Alpha Sigma Gamma Beta
    [16] =>  Beta
    [17] =>  Beta Alpha
    [18] =>  Beta Alpha Gamma
    [19] =>  Beta Alpha Gamma Sigma
    [20] =>  Beta Alpha Sigma
    [21] =>  Beta Alpha Sigma Gamma
    [22] =>  Beta Gamma
    [23] =>  Beta Gamma Alpha
    [24] =>  Beta Gamma Alpha Sigma
    [25] =>  Beta Gamma Sigma
    [26] =>  Beta Gamma Sigma Alpha
    [27] =>  Beta Sigma
    [28] =>  Beta Sigma Alpha
    [29] =>  Beta Sigma Alpha Gamma
    [30] =>  Beta Sigma Gamma
    [31] =>  Beta Sigma Gamma Alpha
    [32] =>  Gamma
    [33] =>  Gamma Alpha
    [34] =>  Gamma Alpha Beta
    [35] =>  Gamma Alpha Beta Sigma
    [36] =>  Gamma Alpha Sigma
    [37] =>  Gamma Alpha Sigma Beta
    [38] =>  Gamma Beta
    [39] =>  Gamma Beta Alpha
    [40] =>  Gamma Beta Alpha Sigma
    [41] =>  Gamma Beta Sigma
    [42] =>  Gamma Beta Sigma Alpha
    [43] =>  Gamma Sigma
    [44] =>  Gamma Sigma Alpha
    [45] =>  Gamma Sigma Alpha Beta
    [46] =>  Gamma Sigma Beta
    [47] =>  Gamma Sigma Beta Alpha
    [48] =>  Sigma
    [49] =>  Sigma Alpha
    [50] =>  Sigma Alpha Beta
    [51] =>  Sigma Alpha Beta Gamma
    [52] =>  Sigma Alpha Gamma
    [53] =>  Sigma Alpha Gamma Beta
    [54] =>  Sigma Beta
    [55] =>  Sigma Beta Alpha
    [56] =>  Sigma Beta Alpha Gamma
    [57] =>  Sigma Beta Gamma
    [58] =>  Sigma Beta Gamma Alpha
    [59] =>  Sigma Gamma
    [60] =>  Sigma Gamma Alpha
    [61] =>  Sigma Gamma Alpha Beta
    [62] =>  Sigma Gamma Beta
    [63] =>  Sigma Gamma Beta Alpha
)

Dieser Ansatz bietet eine umfassende und effiziente Lösung zum Erhalten aller möglichen Kombinationen von Elementen in einem Array und stellt sicher, dass sowohl Kombinationen als auch unterschiedliche Anordnungen in der Ausgabe enthalten sind.