Comment créer un nombre quelconque de boucles imbriquées?

cela devrait fonctionner; vous entrez la longueur dans l'argument repeat du product tandis que enumerate énumère les mots (à partir de 0 par défaut; vous pouvez ajouter start=1 selon vos besoins):

def number(word):
    return int(word.translate(alpha_to_digits), base=26)

il sort:

alpha_to_digits = str.maketrans(
    "abcdefghijklmnopqrstuvwxyz", "0123456789abcdefghijklmnop")

word = 'bike'

d = word.translate(alpha_to_digits)
print(d, int(d, base=26))
# 18a4 23248

si vous n'êtes intéressé que par ce nombre, vous pouvez traduire le mot en un nombre en base 26 et le convertir en utilisant int :

...
bikb 23245
bikc 23246
bikd 23247
bike 23248

qui traduit le mot bike en sa représentation numérique en base 26 ( 18a4 ) qui peut ensuite être convertie en un entier ( 23248 ).

emballé dans une fonction:

from itertools import product


search = "bike"

for i, item in enumerate(product(a.values(), repeat=len(search))):
     word = "".join(item)
     print(word, i)
     if word == search:
          break

Vous pouvez utiliser itertools.product (pour les boucles for imbriquées) + dict.values (pour boucler directement sur les lettres) + enumerate (à partir de 1 , pour obtenir le compteur):

...
...
...
bika 23245
bikb 23246
bikc 23247
bikd 23248
bike 23249

Production:

from itertools import product

word = 'bike'

for counter, letters in enumerate(product(a.values(), repeat = len(word)), 1):
  string = ''.join(letters)
  print(string, counter)
  if string == word:
      break

Remarque: toutes les fonctions présentées dans cette réponse renvoient 23248 comme réponse pour «vélo», car j'aime compter à partir de 0. Si vous préférez compter à partir de 1 et que vous voulez obtenir la réponse 23249, ajoutez simplement un +1 quelque part dans les fonctions .

Première idée: écrivez votre propre fonction increment_word :

Vous pouvez parcourir les mots en écrivant une fonction qui calcule le mot suivant. Par exemple, le mot suivant après bikd devrait être bike et le mot suivant après cdzz devrait être ceaa .

Les chaînes sont immuables en python, donc pour plus de facilité, nous allons utiliser une liste de caractères au lieu d'une chaîne.

def find_word(w):
  count_attempts = 0
  for i,c in enumerate(w):
    n = ord(c) - ord('a')
    count_attempts += n * 26**(len(w) - i - 1)
  return count_attempts

Notez que cette fonction n'est garantie de fonctionner que si elle est appelée sur un mot contenant au moins une lettre non «z». C'est à l'utilisateur de ne pas demander le mot suivant après 'zzz' .

Maintenant, nous pouvons résoudre votre problème:

def find_word(word):
  return find_word_aux(word, 'a'*len(word), 0)

def find_word_aux(word, candidate, count_attempts):
  if candidate == word:
    return count_attempts
  else:
    i,c = max((i,c) for i,c in enumerate(candidate) if c != 'z')
    return find_word_aux(word, candidate[:i] + chr(ord(c)+1) + 'a'*(len(word)-i-1), count_attempts + 1)

Deuxième idée: utilisez itertools.product

En général, lorsque vous souhaitez parcourir des choses complexes en python, quelqu'un a déjà écrit exactement la construction de boucle dont vous avez besoin et elle se trouve dans le package itertools . Si ce n'est pas le cas, c'est peut-être dans les recettes itertools ou dans more_itertools .

Dans ce cas, vous pouvez utiliser itertools.product :

from string import ascii_lowercase
from itertools import product

def find_word(w):
  for count_attempts, candidate in enumerate(product(*[ascii_lowercase]*len(w))):
    if all(x == y for x,y in zip(w, candidate)):
      return count_attempts

Notez comment nous utilisons string.ascii_lowercase plutôt que de taper tout l'alphabet nous-mêmes. Quelqu'un a eu la gentillesse d'enseigner l'alphabet à python. Inutile d'être trop zélé et de réécrire nous-mêmes l'alphabet (au risque d'oublier une lettre et de tout casser).

Troisième idée: utiliser la récursivité au lieu de l'itération

Tout type de boucle complexe peut être simulé en utilisant la récursivité. Notez que python est un très mauvais langage pour la récursivité - en particulier, les fonctions récursives ont tendance à être assez lentes en python; sans oublier que le programme peut planter si la récursivité est trop profonde, car python n'optimise pas les appels de fin. Mais vous devriez penser à cette option si jamais vous avez besoin d'utiliser un langage autre que python.

def find_word(w):
  candidate = ['a' for _ in w]
  w = list(w)
  count_attempts = 0
  while candidate != w:
    increment_word(candidate)
    count_attempts += 1
  return count_attempts

Notez comment cela finit par être extrêmement similaire à la version increment_word . Malheureusement, avec les paramètres python par défaut sur ma machine, cela ne fonctionne que pour les mots entre aaa et bmg . Pour tout mot après bmh , il plante avec l'exception RecursionError: maximum recursion depth exceeded in comparison . Si vous traduisez ce code dans un langage qui optimise les appels de fin, comme OCaml, Haskell ou C, alors cela fonctionnera pour n'importe quel mot.

Quatrième idée: utilisez la combinatoire pour résoudre votre problème instantanément

Au lieu d'itérer les mots un par un, vous pouvez essayer de compter des lots de mots en utilisant la multiplication. Par exemple, il est facile de voir qu'il y a:

• 26 * 26 * 26 = 26^3 = 17576 mots entre aaaa et azzz ;
• 8 * 26 * 26 = 5408 mots entre baaa et bhzz ;
• 10 * 26 = 260 mots entre biaa et bijz ;
• 5 mots entre bika et bike .

Total: 23249 mots entre aaaa et bike .

Cela nous donne un programme python:

def increment_word(w):
  i = len(w) - 1
  while (w[i] == 'z'):
    w[i] = 'a'
    i = i - 1
  w[i] = chr(ord(w[i]) + 1)

Notez que la boucle for ici est sur les caractères de w plutôt que sur tous les mots possibles; nous répétons donc 4 fois et non 23249 fois. Cette fonction est beaucoup plus rapide que les autres versions.