Maison >développement back-end >tutoriel php >Comment puis-je générer toutes les combinaisons possibles d'éléments à partir d'un tableau 1D, en tenant compte à la fois de l'ordre et des doublons ?

Comment puis-je générer toutes les combinaisons possibles d'éléments à partir d'un tableau 1D, en tenant compte à la fois de l'ordre et des doublons ?

Linda Hamilton
Linda Hamiltonoriginal
2024-10-31 20:47:021062parcourir

How can I generate all possible combinations of elements from a 1D array, considering both order and duplicates?

Génération de combinaisons à partir d'un tableau 1D

Introduction

Les combinaisons d'éléments d'un tableau donné trouvent des applications dans divers domaines tels que que la combinatoire et l'optimisation.

Énoncé du problème

Étant donné un tableau 1D, l'objectif est de déterminer toutes les combinaisons possibles des éléments, en garantissant que l'ordre et les doublons sont pris en compte .

Solution

Pour générer toutes les combinaisons en prenant en compte l'ordre et les doublons, une approche systématique est nécessaire. Une de ces approches consiste à utiliser la récursivité ainsi que la manipulation de tableaux :

<code class="php"><?php

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

function depth_picker($arr, $temp_string, &$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>

Explication

  1. La fonction deep_picker parcourt récursivement le tableau et construit des combinaisons en fonction de l'ordre d'éléments.
  2. Chaque appel récursif opère sur une copie du tableau, supprimant un élément à la fois.
  3. Si la copie du tableau n'est pas vide, la récursion continue avec le tableau modifié et le chaîne actuelle avec l'élément supprimé ajouté.
  4. Si la copie du tableau est vide, la chaîne actuelle avec le dernier élément ajouté est ajoutée au tableau de collecte.
  5. La fonction print_r affiche les combinaisons collectées.

Sortie

À l'aide du tableau fourni, le code génère les combinaisons suivantes :

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 sortie contient toutes les combinaisons possibles et arrangements, répondant aux exigences spécifiées du problème.

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!

Déclaration:
Le contenu de cet article est volontairement contribué par les internautes et les droits d'auteur appartiennent à l'auteur original. Ce site n'assume aucune responsabilité légale correspondante. Si vous trouvez un contenu suspecté de plagiat ou de contrefaçon, veuillez contacter admin@php.cn