Discussion :

[ninajams]

Bonjour,

Je cherche a identifier toutes les combinaisons (dans le désordre) en fonction d'un nombre de participant.
Voici le résultat attendu :

Array
(
[0] => Gagnant 1 - Gagnant 2 - Gagnant 3 -Gagnant 4 - Gagnant 5
[1] => Gagnant 1 - Gagnant 2 - Gagnant 3 -Gagnant 4 - Gagnant 6
[2] => Gagnant 1 - Gagnant 2 - Gagnant 3 -Gagnant 5 - Gagnant 6
[3] => Gagnant 1 - Gagnant 2 - Gagnant 4 -Gagnant 5 - Gagnant 6
[4] => Gagnant 1 - Gagnant 3 - Gagnant 4 -Gagnant 5 - Gagnant 6
[5] => Gagnant 2 - Gagnant 3 - Gagnant 4 -Gagnant 5 - Gagnant 6
)

Ci-dessous le code PHP qui me permet d'afficher tous les résultats possible pour 5 gagnants et 6 participants($limite_j).

Mais ce code pose plusieurs problème :

Si je veux passer à 6 gagnants, je dois rajouter une boucle et modifier ma ligne d'affichage.
Si je ne veux que 2 gagnants, je dois retirer 3 boucles et modifier ma ligne d'affichage.

J'ai pensé à une fonction récursive mais après avoir passer quelque jours sur des tutos et de nombreux tests, je m'y suis casser les dents.
Mon objectif est d'avoir une fonction de type : possibilite(Array $gagnant, $nbGagnant, $nbParticipant).

Est-ce possible ?
A ma place comment feriez vous ?
Merci pour votre aide.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
 
$gagnant=["Gagnant 1","Gagnant 2","Gagnant 3","Gagnant 4","Gagnant 5","Gagnant 6","Gagnant 7","Gagnant 8","Gagnant 9","Gagnant 10"];
 
$affichage=[];
$ligne=0;
$limite_j=6;
for($i=0;$i<$limite_j;$i++){
    for($j=$i+1;$j<$limite_j;$j++){
       for($t=$j+1;$t<$limite_j;$t++){
        for($q=$t+1;$q<$limite_j;$q++){
            for($c=$q+1;$c<$limite_j;$c++){
 
 
                $affichage[$ligne]="$gagnant[$i] - $gagnant[$j] - $gagnant[$t] -$gagnant[$q] - $gagnant[$c]";
 
                $ligne++;
 
            }
        }
       }
 
 
    }
}
print'<pre>';
print_r($affichage);
print'</pre>';

[tbc92]

La récursivité est en effet utile ici.

Tu aurais une fonction de ce type :
En entrée, tu aurais les variables : nbSélectionnés, nbRejetés, nbEnAttente, tbSélectionnés, tbRejetés, tbenAttente
Et en sortie, tu aurais un tableau de structures avec ces variables.
Exemple, en entrée , tu as (2,1,3, [a,b],[c],[d,e,f])
Et en sortie, tu dois obtenir :
(2,2,2, [a,b],[c,d],[e,f])
(3,1,2, [a,b,d],[c],[d,e,f])

Au tout début, en entrée, tu as (0,0,6, [],[],[a,b,c,d,e,f])
et après le 1er appel, tu aurais
(1,0,5,[a],[],[b,c,d,e,f])
(0,1,5,[],[a],[b,c,d,e,f])

Il y a des redondances, mais c'est pour clarifier.
On prend le premier élément en attente, et on l'ajoute soit dans la liste des sélectionnés, soit dans la listes des rejetés. A partir d'un scénario, pas très avancé, on obtient 2 scénarios, un petit peu plus avancés.

[WhiteCrow]

Bonjour,

de temps à autre il est toujours bon de rappeler qu'il existe une foultitude de littérature sur ces sujets d'algo. Je ne citerai que le TAOCP de Knuth accessible librement en ligne → Algorithme L : Combinaisons en ordre lexicographique.

[AbsoluteLogic]

/!\ Post à prendre pas trop au 1er degré /!\

Ahhh, depuis l'émergence de ChatGPT, j'attendais une demande sur le forum qui pouvait lui convenir (à la fois assez concis et intéressant), et le voilà

Donc, avis aux amateurs, voici le résultat que j'ai eu avec ChatGPT en faisant un copier coller de la question :



Ah, ça semble pas mal, testons ça.
Ah zut, en fait il retourne tous les résultats dans les différents ordres possibles.
Bon, ben il y a qu'à lui demander de corriger ce malentendu :



Et Jackpot !


DISCLAIMER : C'est intéressant, mais il ne faut prendre ça trop au 1er degré. Déjà, ChatGPT est expert pour donner une réponse qui semble juste mais qui en fait ne l'est pas. Bon, là, c'était le cas avec le 1er résultat, mais ça se teste facilement. Par contre, plus compliqué à tester, c'est de savoir si le résultat est vraiment celui qui amène les meilleurs performances. Par exemple, là, on pourrait peut être éviter le max($gagnants) en passant cette valeur en paramètre. Mais dans ce cas ce n'est pas trop grave puisque ça ne change pas la complexité globale de l'algorithme.

[ninajams]

Bonjour, merci pour cette solution.

Pour ceux qui ne veulent pas recopier les code PHP, je le mets ci-dessous.
On obtient en valeur de retour un tableau multidimensionnel avec toutes les combinaisons non trier (0-1-2 est égale à 1-0-2) donc c'est bon si l'ordre n'est pas important.

Je n'ai pas réussi à personnaliser la fonction pour sortir directement les gagnants qui était passer dans mon tableau $gagnant que j'ai renommé tab car il y avait suffisamment de fois le terme gagnant dans la fonction pour ce perdre.

Afin d'afficher les résultats de $tab je passe par une boucle foreach et j'utilise les résultats de la fonction comme indice de mon tableau.
Cela fonctionne parfaitement.

merci à tous.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
 
 $tab=["Gagnant 1","Gagnant 2","Gagnant 3","Gagnant 4","Gagnant 5","Gagnant 6","Gagnant 7","Gagnant 8","Gagnant 9","Gagnant 10"];
 
 
    function possibilities($gagnants,$nbGagnants,$nbParticipants,&$resultats){
    if(count($gagnants)==$nbGagnants){
        $resultats[]=$gagnants;
        return;
    }
 
    for($i=(empty($gagnants)?0:max($gagnants)+1);$i<$nbParticipants;$i++){
        $gagnants[]=$i;
        possibilities($gagnants,$nbGagnants,$nbParticipants,$resultats);
        array_pop($gagnants);
 
    }
}
 
$resultats=array();
possibilities(array(),2,3,$resultats);
 
// J'utilise une boucle pour récupérer les valeurs de mon tableau
 
foreach($resultats as $key=> $value){
 
    foreach($value as $cle=> $data){
        $value[$cle]=$tab[$data];
    }
    $resultats[$key]=$value;
 
}
// J'affiche le résultat
foreach($resultats as $gagnants){
    echo implode(' - ',$gagnants)."<br>";
}

Résultat :

Gagnant 1 - Gagnant 2
Gagnant 1 - Gagnant 3
Gagnant 2 - Gagnant 3