Hello,
 
Imaginons j'ai un tirage de 9 lettres (un peu comme à des chiffres et des lettres)
 
quelle est la meilleure façon selon vous pour trouver toutes les possibilité (9! = 362880 possibilités)
 
Je pensais à du récursif, ou a des bêtes inversions...
 
Le récursif risque d'être très gourmand en mémoire... mais est plus élégant

personne ?
 

 
Faut arrêter de dire que le récursif c'est toujours gourmand en mémoire.
Ici, au maximum tu auras une profondeur d'appel de ta fonction de 9.  
Si tu as disons 5 int entre les paramètres de la fct et les variables membres, ça fera 5*9*4=180 octects de mémoire en plus. C'est vraiment pas la mer à boire.
 
Le seul hic, c'est que tu vas avoir 362880 appels de fonction en plus par rapport à une version itérative qui vont te coûter du temps (et encore, combien ça coute 360 000 appels de fonction avec les ordis de maintenant ?).
 
Au fait, comment tu veux faire avec des "bêtes inversions" ?
T'as déjà un algo ou tu en cherche un   ?
 

Tu pourrais peut-être simuler des appels récursifs en mettant dans une pile à quelle chiffre tu es à chaque position. Je ne suis peut-être pas très clair, exemple :
- au début pile vide : 0
- première position, première possibilité : 1
- on passe à la deuxième position : 1:0
- le 1 est déjà utilisé, on passe à 2 : 1:2
- on passe à la troisième position : 1:2:0
 
- et quand tu as fini une position tu reviens en arrière (on dépile)...
 
En plus tu pourras vérifier en lisant la liste les chiffres que tu ne peux plus tirer.
En espérant que c'est ce que tu cherches (d'ailleurs c'est plutôt une liste en fait)

oui le récursif m'a l'air bien. mais j'avoue pas savoir comment m'y prendre sur ce coup...
 
 

pour être clair, je vais faire un exemple avec 3 lettres (a, b, c)
 
j'aimerais générerer  
abc
acb  
bca  
bac  
cba  
cab  
 
mais aussi :  
 
a,
b,
c,
ab,
ba,
ac,
ca,
bc  
 
Pour 9 lettres...
 
EDIT : non, c'est pas pour faire chauffer mon PC quand j'ai froid aux pieds  

Moi je ferais une procédure qui génère les mots de n lettres, que j'appellerais par une boucle (de 1 à 9 en l'occurrence).
 
Ensuite dans cette procédure, tu alloues un tableau de n lettres (+ 1 0 final en C...) que tu initialises avec la première partout. Puis dans une boucle "sans fin" tu regarde la lettre de droite (n-1), si ce n'est pas la plus grande tu l'incrémentes, si c'est la plus grande tu reportes une retenue sur l'avant-dernière lettre (éventuellement plus loin) et tu réinitialises la/les lettre(s) de gauche à la première. La condition d'arrêt est lorsque tu t'apprêtes à reporter une retenue sur la lettre précédant la première.
 
En gros ca donne:

Reste à adapter les fonctions d'"incrémentation de lettres" à ce que tu désires, ce qui doit être facile.

merci djdie, mais c'est pas tout à fait ça que je veux. je veux "juste" faire les arrangement possible, et pas générer tout les mots comme tu le fais.  
 
 
 

arf désolé, j'avais mal lu...

Tu ne pourrais pas avoir aussi :
aaa
aab
aac
...
abb
bab
... ?
 
Les tirages doivent être uniques ?

je présume qu'il y a pas de remise vu qu'il a dit que ct genre des chiffres et des lettres...

dans le tirage initial, peut-il y avoir des lettres en double ?

Je propose ça:
 
PERMUTATIONS (P, h, T, n)
01  si h=n
02    alors AFFICHER_CONTENU (P)
03  sinon
04    pour i de 1 à n
05      faire si T[i]=faux
06                 alors t[i] <- vrai
07                          EMPILER (P, i)
08                          PERMUTATIONS (P, h+1, T, n)
09                          DÉPILER (P)
10                          T[i] <- faux
 
Au départ, le tableau T passé en paramètre doit avoir chaque case à « faux » et la pile P doit être vide.
Le résultat est contenu dans la pile P au fur et à mesure.
Cet algo travaille sur des nombres, pas sur des caractères mais c'est pas très difficile de mettre en place une correspondance...
 
Exemple pour afficher toutes les permutations possibles de l'ensemble {1,2,3}:
PERMUTATIONS (P, 0, T, 3)
 
 
EDIT: l'idée est d'avoir un arbre où en le parcourant en profondeur on trouve une nouvelle permutation, le tableau T permet de marquer les endroits où on est déjà passé (i.e. éviter les branches déjà faites).

oui