Je cherche un code pour sortir les factorielle(n) combinaisons issues de n chiffres distincts. (n<10)
Par exemple pour 1,2,3  ça donne :  
 
123
132
213
231
312
321
 
Voila .. j'ai déja pas mal réfléchi, et j'ai eu très mal à la tête
 
merci

Voici du pseudo-code pour l'algorithme dont le principe est d'avoir une boucle par colonne :

OK, merci
le principe est pas mal, mais dans le cas de n colonnes, il faudrait utiliser qqch de récursif ... je ne vois pas comment m'y prendre...

Voici un algorithme récursif

Merci de ta réponse rapide, cependant j'ai un peu de mal à tout comprendre, tu pourrais mettre quelques commentaires ?
dsl je débute ...

Je l'ai en python si jamais ca peut t'aider :

def perms(nums):
    if len(nums)==1:
        return [nums]
    else:
        all = []
        for line in perms(nums[:-1]):
            for i in range(len(nums)):
                all += [line[:i] + nums[-1:] + line[i:]]
        return all

désolé je ne comprends pas ce language

bon je l'explique rapidement en langage humain :
 
Si on te demande les permutations d'une ensemble a un seul élément :
   C'est évident, y'a qu'une seule combinaison possible
Sinon :
   Tu demande les permutations de ton ensemble moins le dernier élément
   tu prends chaque permutation, et tu la duplique plusieurs fois, en rajoutant le dernier élement à toutes les positions possibles
 
 
Voila c'est tout,
 
en gros quand on te demande les permutations de (1,2,3) :
  Tu demande les permutation de (1,2):
     Tu demande les permutations de (1): c'est {(1)}
     Tu duplique ca 2 fois, en insérant le dernier élément aux diverses positions possibles : {(2,1),(1,2)}
  Tu duplique ca 3 fois, en insérant le dernier élément aux diverses positions possibles : {(3,2,1),(2,3,1),(2,1,3),(3,1,2),(1,3,2),(1,2,3)}

merci !

cybertom87.j'aimerai savoir si tu a reussi avec les explication et code que t'a donner 0x90.moi j n'y comprend rien.merci

J'avoue ne plus me souvenir du contexte dans lequel j'ai eu besoin de ça ... ni si j'ai réussi ou non à l'implémenter...

salut 0x90.
je suis debutant en language python.
j'aimerai savoir si python est capable donner l'ensemble des resultats possible.un par un.
    5
  A       =
     18
si oui kel est le code.merci

Salut Olivthil, ton algorithme est bon mais si tu veux bien m'expliquer comment le rendre capable de générer les combinaisons possibles d'un tableau donné (pas forcément 1,2,3,..., ou a,b,c), car moi j'ai écrit un algorithme mais il y a un petit problème (En Delphi mais l'algorithme est simple à comprendre) :
 
// Le tableau commence par l'indice 0.
// N est le plus grand indice donc Taille - 1.
// L'appel se fait par Combinaison(0).
 
procedure Combinaison(Niveau : integer);
var I : integer;
begin
 if Niveau = N + 1 then
  begin
   Inc(P);
   Permuter(Niveau - 1, Niveau - 2);
   AfficherVecteur
  end
 else
  for I := Niveau to N do
   begin
    if P = 2 then
     begin
      P := 0;
      if ???????????????? then ////// c'est la condition à mettre pour que l'algorithme fonctionne bien
       Permuter(0, 1)
      else
       Permuter(Niveau, I)
     end;
    Combinaison(Niveau + 1);
   end;
end;

Salut
 
déja t'appèle ta procédure dans cette meme procédure, çà va couinner: Combinaison(Niveau + 1); à la fin
 
après il manque quelques ";" mais ça tu l'a vu...
 
je suis pas tout ton code mais ce que propose 0X90 est plutôt pas mal
 
pour faire sur un tableau il te suffit d'utiliser tableau[i] avec:
 
tableau[1]:=1 (ou a ou ce que tu veut);
tableau[2]:=2;
tableau[3]:=3;
 
vers le début du fait inc(P) alors qu'il n'est pas initialisé  

oups double poste désolé

Salut flagad'aware,
1) Oui j'appelle cette procédure dans elle même c'est la récursivité.
2) Il ne manque pas de ';' j'en ai mis trop (les ';' avant le 'end' sont facultatives) :
 
procedure Combinaison(Niveau : integer);
var I : integer;
begin
 if Niveau = N + 1 then
  begin
   Inc(P);
   Permuter(Niveau - 1, Niveau - 2);
   AfficherVecteur
  end
 else
  for I := Niveau to N do
   begin
    if P = 2 then
     begin
      P := 0;
      if ???????????????? then //////
       Permuter(0, 1)
      else
       Permuter(Niveau, I)
     end;
    Combinaison(Niveau + 1)
   end
end;  
 
3) Ce que propose 0X90 c'est du Python et sa syntaxe est conçue pour ce type de manipulations mais dans mon cas il ne me conviens pas.
 
4) Pour initialiser les tableaux je sais faire et ce n'est pas ce que je demande.
 
5) Pour P elle est initialisée à 0 j'ai pas mis mais si quelqu'un qui connait en programmation lit le code il comprendra car elle  joue ici un rôle de compteur à 2 pour la transposition.
 
6) Enfin pourquoi avoir écrit ce commentaire pour ne rien apporter de nouveau.
 
Merci.

Salut,

Je veux pas etre méchant, mais je panne quasi que dalle à ton code et pourtant je pense largement pouvoir me classer dans la catégorie des "quelqu'un qui connait en programmation".

Déjà, tu dis qu'il y a un problème, mais tu ne dis pas quel est ce problème. Ta méthode marche-t-elle partiellement? Pas du tout?
Ensuite, vu que tu n'expliques pas ce que ta méthode est censée faire, ca va etre dur de trouver ce qui ne va pas. Ce que je veux dire, c'est que l'exemple en Python (et en algo) de Olivthil renvoie une liste de toutes les combinaisons, alors que ce que tu as l'air de vouloir faire, c'est afficher les combinaisons au fur et à mesure qu'elles sont générées. Mais ca, on ne peut pas trop le deviner... J'ai bon?

Ensuite, tu dis que P est initalisée à 0. Donc si ton tableau est de taille, disons 8 pour l'exemple, donc N=7, si t'appelles Combinaison(3) la méthode ne fait... Rien: le premier if est faux donc on passe dans le else, qui ne fera quelque chose que si P=2, or P=0, donc il ne se passe strictement rien et on sort de la méthode sans avoir rien fait. Meme en utilisant ta définiton de P ("Compteur à 2 pour la transposition" ), je comprends pas ce que tu veux faire...

Bref, ton algo est incompréhensible, et je dis vraiment pas ca pour etre méchant, mais si tu n'es pas plus clair sur ce que tu veux obtenir, ce que tu as fait (ou crois avoir fait), et en quoi ce que tu obtiens ne correspond pas à ce que tu veux, je pense que personne ne sera en mesure de t'aider...

Question : où est déclaré la variable N dans Combinaison() Et que fait Permuter() ?

Salut lasnoufle,
C'est toi qui ne comprends rien :
1) On ce qui concerne le problème daigne d'essayer l'algorithme (sur la machine et pas forcément en Delphi) sinon demande moi plus d'explications, si tu connaissais en programmation tu aurais dû comprendre que cet algorithme fait exactement n! appels de lui même : le nombre de permutations possibles pour n éléments.
 
2) "Ensuite, tu dis que P est initialisée à 0. Donc si ton tableau est de taille, disons 8 pour l'exemple, donc N=7, si t'appelles Combinaison(3) la méthode ne fait... Rien", mais de quoi parles-tu ici, qui  a demandé de faire Combinaison(3), le premier appel toujours se fait par Combinaison(0) et c'est mentionné plus haut.
 
3) ": le premier if est faux donc on passe dans le else, qui ne fera quelque chose que si P=2, or P=0, donc il ne se passe strictement rien et on sort de la méthode sans avoir rien fait. Même en utilisant ta définition de P ("Compteur à 2 pour la transposition" ), je comprends pas ce que tu veux faire..." c'est la preuve que tu n'as rien compris pas parce que mon algorithme n'est pas incompréhensible mais car tu n'as pas essayé vraiment de le comprendre.
 
4) "Bref, ton algo est incompréhensible, et je dis vraiment pas ca pour etre méchant, mais si tu n'es pas plus clair sur ce que tu veux obtenir, ce que tu as fait (ou crois avoir fait), et en quoi ce que tu obtiens ne correspond pas à ce que tu veux, je pense que personne ne sera en mesure de t'aider..." je crois que ton jugement est irrationnel vu ce qu'on j'ai dit plus haut.
 
5) Je te conseille de lire un peu sur la récursivité.
 
Merci de ton aide.

Huhuhu. On va reprendre à peu près point par point, meme si tu mélanges plusieurs chose dans chaque:
 
1) Concevoir & programmer j'y passe en ce moment grosso modo la moitié de mon temps au boulot, après des années ou c'était meme 90%, donc je connais. Je te demande plus d'explications dans mon message précédent, mais bizarrement je n'en vois aucune dans ta réponse. Ton algorithme ne fait PAS n! appels de lui-meme, comme je l'ai expliqué dans mon exemple. Tu veux peut-etre qu'il le fasse, c'est peut-etre ton but, mais je peux te certifier que ce n'est pas le cas actuellement.
 
2) Le raisonnement est exactement pareil si tu commences par Combinaison(0), ca ne fera toujours rien, exactement pour les memes raisons.
 
3) Voir 2)
 
4) Bah écoute je dis ca pour t'aider hein... Tu ne dis nulle part ni ce que tu veux faire, ni ce qui ne marche pas. J'vois pas ce qu'on peut faire pour toi dans ces conditions.
 
5) LOL de platine.
 
Bref, amuses toi bien.

Salut lasnoufle,
 N'essaye pas de jouer le cool,  
 
0) Même si tu fais de la programmation au boulot au moins là tu te trempes pour ne pas dire autre chose et tu n'as pas demandé d'explication dans ton message précédent.
 
1) Navré de te décevoir mais mon algorithme fait n! appels de lui même, je veux qu'il le fasse et il le fait correctement. Je ne sais pas comment tu peux affirmer le contraire? moi je l'affirme parce que je l'ai testé :
 
procedure Combinaison(Niveau : integer);
var I : integer;
begin
 if Niveau = N + 1 then
  begin
   // Tout traitement écrit ici est répété Taille! fois,
   // dans l'algorithme N = Taille - 1 et c'est écrit dans mon premier  
   // message.
   AfficherVecteur
  end
 else
  for I := Niveau to N do
   begin
    // Ici même si j'enlève le pré-traitement le nombre d'appels ne
    // change pas.
    Combinaison(Niveau + 1)
   end
end;
 
 Et pourtant c'est visible, c'est le principe fondamental de la récursivité : cas général et cas trivial, même dans l'algorithme écrit en Python on peut voir la même chose.
 
2) Donc il faut toujours commencer par Combinaison(0) pour avoir toutes les permutations possibles.
 
3) Voir ce que tu veux ( ça ressemble à la récursivité).
 
4) Mais aide moi, aidez moi c'est ce que je demande, mais l'aide ne se fait pas de cette façon.
 
5) LOL
 
Merci beaucoup, je m'amuse bien.

Tu n'as donc pas besoin d'aide, CQFD.

Salut lasnoufle, mais j'ai besoin d'aide qui a dit le contraire mais l'aide d'un professionnel.
 Mais si tu veux quand même essayer je serais ravi.
 Merci.

Mais t'es un troll ou quoi? Si tu veux de l'aide, comme je l'ai déjà dit, commence par expliquer ce qui ne marche pas.

LOL,
 Ok, je vais le faire.

Tiens, voici un exemple en perl, histoire de te donner une idée de l'algorithme.

A+,

Merci gilou, grâce à toutes les contributions de cette discussion et la solution de lasnoufle :
 
procedure afficherCombinaisons(var tableauOriginal : TList, var combinaison: TList; const niveau: integer)
var
 indexAInserer: integer;
begin
 if tableauOriginal.count = 0 then begin
  // On est arrivé au bout - on affiche la combinaison!
  afficherListe(combinaison)
 end
 else begin
  // on parcourt tous les éléments pas encore insérés
  for indexAInserer := 0 to tableauOriginal.count - 1  do begin
   // on insère l'élément dans la combinaison
   combinaison[niveau] := tableauOriginal[indexAInserer];
 
 
  // on retire l'élément de la liste d'origine
   tableauOriginal.Delete(indexAInserer);
 
 
  // on fait l'appel récursif
   afficherCombinaisons(tableauOriginal, combinaison, niveau + 1);
 
 
  // on rétablit l'élément dans la liste d'origine
   tableauOriginal.Insert(indexAInserer,combinaison[niveau])
  end
 end
end;
 
voici le résultat après modification pour qu'elle marche pour les tableaux :
 
procedure Combinaisons(var Vecteur, Combinaison : Tab; Niveau: integer);
var I : integer;
begin
 if Length(Vecteur) = 0 then
  AfficherVecteur(Combinaison)
 else
  for I := 0 to High(Vecteur) do
   begin
    Combinaison[Niveau] := Vecteur[I];
    Supprimer(Vecteur, I);
    Combinaisons(Vecteur, Combinaison, Niveau + 1);
    Inserer(Vecteur, I, Combinaison[Niveau])
   end
end;
 
Et voici mon algorithme modifié qui marche :
 
procedure Combinaisons(var Vecteur : Tab; Niveau: integer);
var I : integer;
begin
 if Niveau = Length(Vecteur) then
  AfficherVecteur(Vecteur)
 else
  for I := Niveau to High(Vecteur) do
   begin
    Permuter(Vecteur, Niveau, I);
    Combinaisons(Vecteur, Niveau + 1);
    Permuter(Vecteur, Niveau, I)
   end
end;  
 
Merci à tous.