Comment puis-je générer toutes les combinaisons possibles à partir d'un tableau 1D en PHP, y compris les combinaisons et les permutations ?

Obtenir toutes les combinaisons possibles en PHP : une solution complète

Récupérer toutes les combinaisons possibles à partir d'un tableau 1D peut être une tâche complexe, surtout lorsque en considérant à la fois les combinaisons et les permutations. Bien qu'il existe différentes approches à ce problème, une solution très efficace consiste à implémenter une fonction récursive.

La fonction récursive, deep_picker(), effectue une recherche en profondeur d'abord sur le tableau, explorant toutes les branches et combinant les éléments pour former combinaisons. Il conserve une chaîne temporaire qui est progressivement modifiée avec chaque élément, tandis qu'un tableau de collecte stocke les combinaisons finales. Examinons le fonctionnement de cette fonction :

1. Cas de base : Si la chaîne temporaire est vide, cela signifie qu'un élément autonome est pris en compte. Dans ce cas, il est directement ajouté au tableau de collecte.
2. Exploration récursive : Lorsqu'un élément doit être combiné, la fonction crée une copie du tableau d'origine et supprime l'élément actuel de là. Il appelle ensuite récursivement deep_picker() sur le tableau modifié, en transmettant la chaîne temporaire mise à jour avec l'élément ajouté. S'il y a plus d'éléments à combiner, il continue le processus récursif.
3. Combinaisons et permutations : en parcourant chaque élément et en les combinant de manière récursive, deep_picker() génère efficacement toutes les combinaisons et permutations possibles. sans répétition. Cette approche garantit que les deux variantes de chaînes (« Alpha Beta » et « Beta Alpha ») sont incluses dans le résultat final.
4. Résultat final : lorsque la fonction a exploré toutes les combinaisons, la collecte array contient l'ensemble complet de toutes les combinaisons possibles à partir du tableau d'entrée.

Implémentation et exécution

Pour implémenter cette recherche et cette récupération de combinaisons en profondeur, le code PHP suivant peut être utilisé :

<code class="php"><?php

$array = array('Alpha', 'Beta', 'Gamma', 'Sigma');

function depth_picker($arr, $temp_string, &amp;$collect) {
    if ($temp_string != "")
        $collect []= $temp_string;

    for ($i=0, $iMax = sizeof($arr); $i < $iMax; $i++) {
        $arrcopy = $arr;
        $elem = array_splice($arrcopy, $i, 1); // removes and returns the i'th element
        if (sizeof($arrcopy) > 0) {
            depth_picker($arrcopy, $temp_string ." " . $elem[0], $collect);
        } else {
            $collect []= $temp_string. " " . $elem[0];
        }
    }
}

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

?></code>

Lors de son exécution, ce code génère le tableau suivant de toutes les combinaisons et arrangements possibles :

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
)

Cette approche fournit une solution complète et efficace pour obtenir toutes les combinaisons possibles d'éléments dans un tableau, en garantissant que les combinaisons et les différents arrangements sont inclus dans la sortie.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!