Générer les anagrammes d'un mot

Pourtant en faisant un test avec 'abc', j'obtiens les mêmes résultats :
-Avec crochets :

Code:

---

1 2	>>> a {'bac', 'abc', 'cab', 'acb', 'cba', 'bca'}

---

-Sans crochets :

Code:

---

1 2	>>> a {'cab', 'abc', 'acb', 'cba', 'bac', 'bca'}

---

Citation:

---

Envoyé par Flo963

Pourtant en faisant un test avec 'abc', j'obtiens les mêmes résultats :
-Avec crochets :

Code:

---

1 2	>>> a {'bac', 'abc', 'cab', 'acb', 'cba', 'bca'}

---

-Sans crochets :

Code:

---

1 2	>>> a {'cab', 'abc', 'acb', 'cba', 'bac', 'bca'}

---

---

Oui, le comportement est le même mais il s'agit d'un hasard.
Lorsque la fonction permuter arrive au plus bas niveau et qu'elle est appelée avec un paramètre "c", elle renvoie alors l'élément ["c"] (ou "c" dans ton cas) qui n'a alors qu'un seul caractère.
Or, le comportement de for x in "c" ou for x in ["c"] est le même mais uniquement parce qu'il n'y a ici qu'un seul caractère.
Parce qu'avec for x in "abc": print x, len(x) ou for x in ["abc"]: print x, len(x) ce ne serait plus du tout pareil.

Donc vaut mieux (selon moi) rester dans un code fonctionnel et "correct" que se contenter d'un code purement "fonctionnel".

Il y a d'ailleurs une remarque dans le même sens faite par "mont29"

Citation:

---

Envoyé par mont29

...au passage, remarquons le subtile p[:i]+items[0:1]+p[i:] au lieu de p[:i]+items[0]+p[i:], qui permet d’utiliser ce code avec n’importe quel type “séquence”*! :ccool:

---

Mettre items[0] fonctionnerait chez toi avec "abc" mais apparemment mettre items[0:1] est mieux (bien que je n'ai pas compris pourquoi mais je pense que c'est une raison analogue).

Citation:

---

Envoyé par Flo963

Ce n'est pas très important mais si je ne me trompe pas, pour le cas de base, inutile d'écrire 'return [items]', 'return items' suffit.

---

Soit on dit "permuter" retourne la /liste/ des permutations des éléments d'items ... et cela s'applique aussi au cas ou len(items)<=1 soit on dit "autre chose".
Ce qui conduit a exposer une autre interface cohérente, facile a réaliser et a tester.
- W
Note: et la réalisation de bonnes interfaces est plus compliquée que la récursivité.

Ok ok...Merci à tous les deux en tout cas.

Citation:

---

Envoyé par Sve@r

Il y a d'ailleurs une remarque dans le même sens faite par "mont29"

Citation:

---

...au passage, remarquons le subtile p[:i]+items[0:1]+p[i:] au lieu de p[:i]+items[0]+p[i:], qui permet d’utiliser ce code avec n’importe quel type “séquence”*!

---

Mettre items[0] fonctionnerait chez toi avec "abc" mais apparemment mettre items[0:1] est mieux (bien que je n'ai pas compris pourquoi mais je pense que c'est une raison analogue).

---

Ce n’est pas nécessaire si l’on s’en tient aux str, car "string"[2] renvoie "r", qui est aussi un str, donc “l’addition” fonctionne… Mais ce ne sera pas le cas avec une liste ou un tuple ([1, 2, 3, 4][2] renvoie 3, alors que [1, 2, 3, 4][2:3] renvoie [3] ;) ).

J'ai repris le premier code posté par mont29 et je l'ai réécris sans récursivité (fichue récursivité ;)). Comme quoi ça fonctionne bien aussi:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

def anagrammes(chaine):   liste=[chaine]   i=0 while i < len(chaine)-1:   for mot in list(liste):   for s in range(i, -1, -1):   mot = mot[:s]+mot[s+1]+mot[s]+mot[s+2:] liste.append(mot) i+=1 return liste

---

L'algorithme de wiztricks s'écrit aussi simplement avec des itérations:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

def permuter(chaine):   liste=[chaine[0]]   n=2 l=1   while n <=len(chaine):   for mot in list(liste):   for i in range(n):   liste.append(mot[:i]+chaine[l]+mot[i:])   n+=1 l+=1     return [r for r in liste if len(r)==len(chaine)]

---

Comme quoi y a des solutions même lorsque l'on est faché avec la récursivité ;)

Citation:

---

L'algorithme de wiztricks s'écrit aussi simplement avec des itérations

---

ouais mais c'est tellement moins sexy :roll:

C'est vrai, mais comme il n'ya toujours que des solutions récursives proposées à ce problème, ça change ;)