Discussion :

[Flo963]

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

Code :

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

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

-Sans crochets :

Code :

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

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

[Sve@r]

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

Code :

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

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

-Sans crochets :

Code :

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

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"

...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).

[wiztricks]

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é.

[Flo963]

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

[mont29]

Il y a d'ailleurs une remarque dans le même sens faite 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”*!

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] ).

[Flo963]

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 :

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

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

[Flo963]

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

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
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é

[fred1599]

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

ouais mais c'est tellement moins sexy

[Flo963]

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