Bonjour à tous,
 
me voici confronté à un problème, je dois réaliser un code (PHP) afin d'avoir toutes les combinaisons possibles "tirage avec remise sans ordre"
 
Disons que j'ai 3 colonnes qui peuvent prendre une valeur de 0 à 5.
 
le résultat est donc le suivant :
 
0-0-0
0-0-1
0-0-2
0-0-3
...
0-1-1
0-1-2
 
 
Du coup comme l'ordre n'est pas pris en compte, 0-0-1 = 1-0-0 je ne sais pas comment le vérifier avec mon code.

Tu tries tes trois valeurs selon la valeur (1<2<3 etc) et ensuite tu peux comparer si tu as déjà cette combinaison.

Bonjour,
 
Si tu changes ton format de donnée tu n'aura plus le soucis ...
Par exemple, un tableau de 6 cases où tu stockerais le nombre de chiffre dans une chaine
0-0-1 = 1-0-0 = 2-1-0-0-0-0 => Il y deux 0, un 1, zero 2, zero 3, zero 4 et zero 5.
 
0-3-1 = 3-0-1 = 1-1-0-3-0-0 => Il y un 0, un 1, zero 2, un 3, zero 4 et zero 5.
 
edit:   grillé par une solution plus simple

 
Je ne suis pas sûr de comprendre ou alors j'ai du mal m'exprimer.
 
Ce que je souhaite c'est trouver toutes ces valeurs pour les mettre dans un tableaux.
et je dispose de 2 variables.
 
- le nombre de cases > p
- le nombre d'index par case > n
 
Disons p = 4 et n = 10
 
le résultat que je souhaite dans mon tableau sera celui la
 
0-0-0-0
0-0-0-1
0-0-0-2
.....
0-0-0-10
0-0-1-1
0-0-1-2
.....
10-10-10-10

Bonjour,
 
Un petit peu d'observation (3 tirages avec remise, 4 possibilités par tirage) :
 
0 0 0    1 0 0    2 0 0    3 0 0
0 0 1    1 0 1    2 0 1    3 0 1
0 0 2    1 0 2    2 0 2    3 0 2
0 0 3    1 0 3    2 0 3    3 0 3
 
0 1 0    1 1 0    2 1 0    3 1 0
0 1 1    1 1 1    2 1 1    3 1 1
0 1 2    1 1 2    2 1 2    3 1 2
0 1 3    1 1 3    2 1 3    3 1 3
 
0 2 0    1 2 0    2 2 0    3 2 0
0 2 1    1 2 1    2 2 1    3 2 1
0 2 2    1 2 2    2 2 2    3 2 2
0 2 3    1 2 3    2 2 3    3 2 3
 
0 3 0    1 3 0    2 3 0    3 3 0
0 3 1    1 3 1    2 3 1    3 3 1
0 3 2    1 3 2    2 3 2    3 3 2
0 3 3    1 3 3    2 3 3    3 3 3
 
Le mieux étant de ne simplement pas générer les combinaisons en double, la solution devrait être assez simple après observation.  

 
 
On voit bien effectivement, sauf qu'il en manque
 
210, 310 a vu d’œil  

De quoi? Il ne manque rien, regarde mieux. En rouge, les doublons. J'ai quand même mis l'axe de symétrie en évidence...

 
mal compris la réponse. Donc oui il y a toute les combinaisons. Oui il faut éviter de générer les doublons mais comment faire en PHP ?

1- Comment ferais-tu pour générer toutes les combinaisons ?
2- Sur quels paramètres pourrais-tu jouer pour ne pas générer les combinaisons en trop ?
3- D'après les observations, quelle règle peux-tu établir à propos des paramètres afin de ne générer que les combinaisons uniques ?

 
boucle, mais ça j'ai réussi.
 
 

 
j'en suis ici, je ne sais pas comment éviter les doublons étant donné que l'ordre n'a pas d'importance. Et en vrai p peut monter jusqu'à 20 et n vers les 200.
Si je peux éviter de trouver les doublons pour éviter la perte de temps...

Tu ne fais pas qu'une boucle a priori, ou alors j'ai raté quelque chose, je pense que tu en fais plusieurs. Sur une boucle tu n'as que 3 paramètres :
- valeur initiale
- vitesse d'incrémentation
- valeur finale

Dans mon exemple, tu as 3 tirages donc 3 boucles imbriquées (de variables $i, $j et $k). Ces 3 variables peuvent prendre pour valeurs 0, 1, 2 ou 3.
Si tu regardes les tirages que j'ai écrit, on prend la première colonne, soit tous les tirages commençant par 0. On peut donc pour $i = 0, pendre $j et $k entre 0 et 3.
Mais pour $i = 1 il faut commencer à éliminer des valeurs. Toutes celles ayant $k = 0.
Puis pour $i = 2, on remarque qu'il faut éliminer les valeurs pour $k = 0 ou $k = 1, etc.

Par contre je ne sais si p est le nombre de tirages ou le nombre de valeurs possibles. Mais avec p = 20 et n = 200 il va peut-être falloir choisir une autre stratégie que les boucles imbriquées. Déjà parce que ton nombre de boucles est prédéfinie et qu'en plus tu exploses la complexité de ton algorithme.

Que cherches-tu à faire au final ?

j'ai essayé de faire des reset de mes $i, $j. quand j'arrive au max d'une colonne, je le remet à 0 puis je fait la colonne +1
 
je pense que la solution serait de faire une fonction récursif mais je n'ai pas encore trouvé le bon code pour ne pas perdre du temps à calculer les doublons...

Aide pour ne pas générer les doublons : matrice triangulaire supérieure...

Pour mon exemple :

Attention, cela se passe différemment entre un tirage impair et un tirage pair.
Si le nombre de tirages est variable il faut en effet passer par une fonction récursive car tu ne peux pas utiliser des boucles puisqu'elles doivent être écrites à l'avance.
Je te conseille de te faire des exemples comme le mien mais avec 4 tirages et avec 5 tirages pour bien comprendre. Ensuite il faudra transposer en fonction récursive.

Niveau 1 : boucles imbriquées
Niveau 2 : fonction récursive
Niveau 3 : fonction mathématique (pour descendre la complexité de l'algo mais cela dépend de ce que tu veux réellement faire au final)

j'aurais fait

 
Avec  

ça donne :
 
$i=0,$j=0,$k=0->3

 
$i=0,$j=1,$k=0->3

 
 
J'ai trouvé grâce à vos réponses !!!
Enfin déjà en code pas très propre...
 
Maintenant, il faut que je trouve comment faire ça avec une fonction récursive pour que ce soit valable pour n case.

 
Non.
 
J'ai écrit toutes les possibilités plus haut. En tenant compte de l'ordre, on est, dans mon exemple, à 64 combinaisons.
Grâce à la coloration des combinaisons, nous pouvons compter simplement les combinaisons uniques quand on ne prend pas en compte l'ordre soit 6x4 (en rouge) + 4x4 (en noir) = 24 + 16 = 40 combinaisons uniques.
 
Si on fait ce que je proposais, on obtient les 40 combinaisons suivantes :

 
Maintenant si on fait ce que tu proposes on obtient 20 combinaisons :

La combinaison 0-1-0 n'est pas générée par exemple, donc ça ne fonctionne pas.

Comme tu es parti sur ce que proposais art_dupond, je doute que ça fonctionne...

 
Résultat :
 

 
ça fonctionne bien

Ok, c'est moi qui n'est pas compris le problème.  
 
J'étais parti, je ne sais pas pourquoi, sur pas d'ordre gauche/droite et droite/gauche, donc en effet ça fonctionne en réduisant le nombre d'itération sur chaque boucle imbriquée. Et là ça simplifie grandement ton problème.

 
 
plus qu'à adapter ça pour n case. Pour l'instant, toujours pas trouvé

Tu peux faire un truc comme ça.

L'idée c'est de créer un tableau de résultat et d'incrémenter les valeurs pour générer toutes les combinaisons.

Pour l'exemple à N=4 valeurs possibles et C=3 colonnes,
on va initialiser un tableau de resultats : 000

On va incrémenter la valeur la plus à droite jusqu'à atteindre la valeur MAX:
000
001
002
003

Quand celle-ci est atteinte, on incrémente la valeur du rang inférieur:
013

et on réinitialise toutes les valeurs "à droite" avec cette nouvelle valeur:
011

De nouveau, on incrémente jusqu'à atteindre la valeur MAX:
011
012
013

Lorsqu'on doit descendre de rang, on le fait jusqu'à trouver une valeur != MAX

Donc, si la valeur courante est 033, ça donne

1. Mise à jour du rang le plus à droite dont la valeur < MAX
133

2. Réinitialisation des valeurs à droite de cette valeur
111

3. On recommence à incrémenter à droite.

C'est super, merci à tous. Ça fonctionne comme je veux.
 
J'ai plus qu'à adapter à mon code.