Tours de Hanoi

**Tudko** · 23/05/2020, 04h29

Bonjour

Je me suis acheté des tours de Hanoi en bois
Après trois jours de tatillonnage sur plus de vingt pages de brouillon j'ai enfin réussi à retrouver par moi même un morceau de l'algorithme général de récursion déplaçant les huit disques de la tour 1 à la tour 3, sans aide sur internet aucune.

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
21
22
23
24
25
T0 = [ 0, 1, 2, 3, 4, 5, 6, 7 ]
#Disques de diamêtres 0 à 7, empilés du plus petit sur le plus grand
T1 = [ [],[],[],[],  [],[],[],[] ]
T2 = [ [],[],[],[],  [],[],[],[] ]
i=0
j=0
k=0
def move(i, j, k):
  if i == j :
    if k % 2 == 0:
      T0[i] = []
      T2[i] = i
    else:
      T0[i] = []
      T1[i] = i
  else:
    move(0, j-1, k-1)
    move(j, j, k)
    move(0, j-1, k-1)
 
move(0, 7, 2)
#Déplace et empile un par un les cylindres 0 à 7 sur la tour 2
# (jamais un plus grand sur un plus petit)
# en t'aidant de la tour 1
print(T0) ; print(T1) ; print(T2)

Code :

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

1
2
3
[[], [], [], [], [], [], [], []]
[0, [], 2, [], 4, [], 6, []]
[[], 1, [], 3, [], 5, [], 7]

Le résultat imprimé par mon Notebook Jupiter semble indiquer que le travail est encore fait à moitié.
Manuellement je maîtrise maintenant parfaitement les 255 déplacements de disques, ce qui n'est pas encore le cas de mon ordinateur.
Je me suis alors replongé le crayon à la main pour chercher la route récursive manquante mais là honnêtement je sollicite votre aide

Merci !

**danielhagnoul** · 23/05/2020, 11h34

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
21
22
23
24
25
26
27
28
29
30
def tour_hanoi(n, i, j):
    """ Déplace n disques du piquet i au piquet j
        Nombre de disques n
        Trois piquets
        6 = 1 + 2 + 3 (somme des numéros des piquets)
        Nombre de déplacements = 2**n - 1
 
        https://www.codingame.com/playgrounds/17176/recueil-dexercices-pour-apprendre-python-au-lycee/tours-de-hanoi
        https://fr.wikipedia.org/wiki/Tours_de_Hano%C3%AF
        https://deptinfo-ensip.univ-poitiers.fr/ENS/doku/doku.php/tp:python:prog01
    """
    if n > 0:
        tour_hanoi(n - 1, i, 6 - i - j)
        print("Déplacer disque du piquet {} au piquet {}".format(i, j))
        tour_hanoi(n - 1, 6 - i - j, j)
 
 
print('Nb déplacement = {}'.format(2**3 - 1)) # Nb déplacement = 7
 
tour_hanoi(3, 1, 3)
 
"""
Déplacer disque du piquet 1 au piquet 3
Déplacer disque du piquet 1 au piquet 2
Déplacer disque du piquet 3 au piquet 2
Déplacer disque du piquet 1 au piquet 3
Déplacer disque du piquet 2 au piquet 1
Déplacer disque du piquet 2 au piquet 3
Déplacer disque du piquet 1 au piquet 3
"""

**wiztricks** · 23/05/2020, 12h03

Salut,

Envoyé par Tudko

Je me suis alors replongé le crayon à la main pour chercher la route récursive manquante mais là honnêtement je sollicite votre aide

C'est peut être à ce moment là qu'il faut chercher un peu sur Internet pour voir comment l'ont codés d'autres (bien) avant vous...

- W

**Sve@r** · 23/05/2020, 12h44

Bonjour

Envoyé par Tudko

Je me suis acheté des tours de Hanoi en bois

C'est sympa. J'ai déjà vu ça aussi. Me semble que le truc est à 8 disques.

Envoyé par Tudko

Après trois jours de tatillonnage sur plus de vingt pages de brouillon j'ai enfin réussi à retrouver par moi même un morceau de l'algorithme général de récursion déplaçant les huit disques de la tour 1 à la tour 3, sans aide sur internet aucune.

Bel effort. 20 pages ça me parait tout de même exagéré.

Envoyé par Tudko

Je me suis alors replongé le crayon à la main pour chercher la route récursive manquante mais là honnêtement je sollicite votre aide

Pas compliqué: pour déplacer n (n > 1 impérativement ) disques de la tour 1 à la tour 3, il faut

déplacer n-1 disques de la tour 1 à la tour 2
déplacer le dernier disque de la tour 1 à la tour 3
déplacer n-1 disques de la tour 2 à la tour 3

Un exemple se trouve dans mon tutoriel shell (cf signature). Et je viens de le porter en Python

Code python :

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
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
#!/usr/bin/env python3
# coding: utf-8
# Programme de tours de Hanoï
# Usage: prog nb_pions
 
# Fonction récursive qui déplace n pions d'une tour x vers une tour y
def deplace(jeu, dep, arr, nb=1):
	# S'il n'y a plus qu'un seul pion
	if nb == 1:
		# Ici on est en fin de récursivité – Il ne reste plus qu'un seul pion à déplacer
		jeu["tours"][dep-1]-=1		# La tour de départ perd un pion
		jeu["tours"][arr-1]+=1		# La tour d'arrivée gagne un pion
		jeu["cpt"]+=1			# Le compteur de mouvements augmente
 
		# On génère le mouvement et on quitte la fonction
		yield "Mvt: %d - %d => %d: Etat: %s" % (
			jeu["cpt"],
			dep,
			arr,
			", ".join(map(str, jeu["tours"])),
		)
		return
	# if
 
	# Ici, on est dans la partie intermédiaire du jeu – Il y a encore des pions qui gènent
	# Déplacement récursif des pions restants de la tour de départ vers une tour intermédiaire
	yield from deplace(
		jeu,
		dep,
		tuple(map(int, set(range(1, 4)) - set((dep, arr))))[0],
		nb - 1,
	)
 
	# Déplacement du dernier pion de la tour de départ vers la tour d'arrivée
	yield next(deplace(jeu, dep, arr))
 
	# Déplacement récursif des pions restants de la tour intermédiaire vers la tour d'arrivée
	yield from deplace(
		jeu,
		tuple(map(int, set(range(1, 4)) - set((dep, arr))))[0],
		arr,
		nb - 1,
	)
# deplace
 
# Programme principal
if __name__ == "__main__":
	import sys
	import os
 
	# Vérification arguments
	if len(sys.argv) <= 1 or int(sys.argv[1]) < 1:
		print("Usage: %s nb_pions positifs" % os.path.basename(__file__))
		exit(1)
	# if
 
	# Initialisation jeu
	jeu={
		"tours" : [int(sys.argv[1]), 0, 0],
		"cpt" : 0,
	}
 
	# Affichage position de départ
	print("Départ: %s" % ", ".join(map(str, jeu["tours"])))
 
	# Lancement mouvement de la tour 1 vers la tour 3
	print("\n".join(deplace(jeu, 1, 3, int(sys.argv[1]))))
 
	# Affichage position d'arrivée
	print("Arrivée: %s" % ", ".join(map(str, jeu["tours"])))
# if

**Tudko** · 23/05/2020, 15h42

Merci beaucoup

C'est vrai que c'était intéressant de m'entraîner à chercher ma propre version

**Tudko** · 23/05/2020, 21h57

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
21
T0 = [ 0, 1, 2, 3,  4, 5, 6, 7 ]
T1 = [ [],[],[],[], [],[],[],[] ]
T2 = [ [],[],[],[], [],[],[],[] ]
i=0
j=0
k=0
def move(i, j, k):
  if i == j :
    if k % 2 == 0:
      T0[i] = []
      T2[i] = i
    else:
      T0[i] = []
      T1[i] = i
  else:
    move(0, j-1, k)
    move(j, j, k)
    move(0, j-1, k) # et non pas k-1
 
move(0, 7, 2)
print(T0) ; print(T1) ; print(T2)

[[], [], [], [], [], [], [], []]
[[], [], [], [], [], [], [], []]
[0, 1, 2, 3, 4, 5, 6, 7]

BINGO

Mais j'avoue que je n'ai pas saisi mathématiquement pourquoi k [le compteur : déplacer de 1 ou de 2 tours ; déplacer de 3(impair)tours revenant à revenir à la tour 1 et ainsi de suite] au lieu de k-1. En effet, si vous vous êtes renseignés sur le jeu, partir de n=8 disques pour arriver à la tour 2 (k=+2) demande de d'abord faire k-1 =+1 aux n-1=7 premiers tours, afin de laisser au préalable place au disque 8 sur la tour 2 (ici la première tour est la tour 0). Et ainsi de suite. Enfin d'après moi

**Sve@r** · 24/05/2020, 09h27

Envoyé par Tudko

Code :

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

1
2
3
T0 = [ 0, 1, 2, 3,  4, 5, 6, 7 ]
T1 = [ [],[],[],[], [],[],[],[] ]
T2 = [ [],[],[],[], [],[],[],[] ]

Pourquoi la tour 0 contient des disques (des valeurs) et les autres tours contiennent des listes ???

Envoyé par Tudko

[[], [], [], [], [], [], [], []]
[[], [], [], [], [], [], [], []]
[0, 1, 2, 3, 4, 5, 6, 7]

BINGO

Oui enfin on voit jiste l'état final. Ce qui est bien, c'est de voir chaque mouvement.

Envoyé par Tudko

Envoyé par Sve@r

Pas compliqué: pour déplacer n (n > 1 impérativement ) disques de la tour 1 à la tour 3, il faut

déplacer n-1 disques de la tour 1 à la tour 2
déplacer le dernier disque de la tour 1 à la tour 3
déplacer n-1 disques de la tour 2 à la tour 3

En effet, si vous vous êtes renseignés sur le jeu, partir de n=8 disques pour arriver à la tour 2 (k=+2) demande de d'abord faire k-1 =+1 aux n-1=7 premiers tours, afin de laisser au préalable place au disque 8 sur la tour 2 (ici la première tour est la tour 0). Et ainsi de suite. Enfin d'après moi

Oui, c'est aussi ce que j'avais écrit.

**Tudko** · 24/05/2020, 16h42

Envoyé par Sve@r

Pourquoi la tour 0 contient des disques (des valeurs) et les autres tours contiennent des listes ???

Oui enfin on voit jiste l'état final. Ce qui est bien, c'est de voir chaque mouvement.

Oui, c'est aussi ce que j'avais écrit.

La tour 0 contient la valeur 1 pour disque 1, je pense que ça reste manipulable

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
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
 
T0 =[0, 1,  2,  3,  4,  5,  6,  7]
T1 =[[],[],[],[],  [],[],[],[] ]
T2 =[[],[],[],[],  [],[],[],[] ]
i=0
j=0
k=0
def move(i, j, k):
  if i == j :
    if k % 2 == 0:
      T0[i] = []
      T2[i] = i
    else:
      T0[i] = []
      T1[i] = i
  else:
    move(0, j-1, k)
    move(j, j, k)
    move(0, j-1, k)
    print(T0) ; print(T1) ; print(T2)
move(0, 7, 2)
 
[[], [], 2, 3, 4, 5, 6, 7]
[[], [], [], [], [], [], [], []]
[0, 1, [], [], [], [], [], []]
[[], [], [], 3, 4, 5, 6, 7]
[[], [], [], [], [], [], [], []]
[0, 1, 2, [], [], [], [], []]
[[], [], [], 3, 4, 5, 6, 7]
[[], [], [], [], [], [], [], []]
[0, 1, 2, [], [], [], [], []]
[[], [], [], [], 4, 5, 6, 7]
[[], [], [], [], [], [], [], []]
[0, 1, 2, 3, [], [], [], []]
[[], [], [], [], 4, 5, 6, 7]
[[], [], [], [], [], [], [], []]
[0, 1, 2, 3, [], [], [], []]
[[], [], [], [], 4, 5, 6, 7]
[[], [], [], [], [], [], [], []]
…

C'est un peu mieux toujours pas cohérent mathématiquement, franchement les machines..
Est-ce que Python n'est pas le meilleur langage pour faire ça? Il faudrait un langage proprement fonctionnel comme Scheme/Haskell??

**Tudko** · 24/05/2020, 16h46

Envoyé par Sve@r

Bonjour

C'est sympa. J'ai déjà vu ça aussi. Me semble que le truc est à 8 disques.

Bel effort. 20 pages ça me parait tout de même exagéré.

Pas compliqué: pour déplacer n (n > 1 impérativement ) disques de la tour 1 à la tour 3, il faut

déplacer n-1 disques de la tour 1 à la tour 2
déplacer le dernier disque de la tour 1 à la tour 3
déplacer n-1 disques de la tour 2 à la tour 3

Un exemple se trouve dans mon tutoriel shell (cf signature). Et je viens de le porter en Python

Code python :

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
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
#!/usr/bin/env python3
# coding: utf-8
# Programme de tours de Hanoï
# Usage: prog nb_pions
 
# Fonction récursive qui déplace n pions d'une tour x vers une tour y
def deplace(jeu, dep, arr, nb=1):
	# S'il n'y a plus qu'un seul pion
	if nb == 1:
		# Ici on est en fin de récursivité – Il ne reste plus qu'un seul pion à déplacer
		jeu["tours"][dep-1]-=1		# La tour de départ perd un pion
		jeu["tours"][arr-1]+=1		# La tour d'arrivée gagne un pion
		jeu["cpt"]+=1			# Le compteur de mouvements augmente
 
		# On génère le mouvement et on quitte la fonction
		yield "Mvt: %d - %d => %d: Etat: %s" % (
			jeu["cpt"],
			dep,
			arr,
			", ".join(map(str, jeu["tours"])),
		)
		return
	# if
 
	# Ici, on est dans la partie intermédiaire du jeu – Il y a encore des pions qui gènent
	# Déplacement récursif des pions restants de la tour de départ vers une tour intermédiaire
	yield from deplace(
		jeu,
		dep,
		tuple(map(int, set(range(1, 4)) - set((dep, arr))))[0],
		nb - 1,
	)
 
	# Déplacement du dernier pion de la tour de départ vers la tour d'arrivée
	yield next(deplace(jeu, dep, arr))
 
	# Déplacement récursif des pions restants de la tour intermédiaire vers la tour d'arrivée
	yield from deplace(
		jeu,
		tuple(map(int, set(range(1, 4)) - set((dep, arr))))[0],
		arr,
		nb - 1,
	)
# deplace
 
# Programme principal
if __name__ == "__main__":
	import sys
	import os
 
	# Vérification arguments
	if len(sys.argv) <= 1 or int(sys.argv[1]) < 1:
		print("Usage: %s nb_pions positifs" % os.path.basename(__file__))
		exit(1)
	# if
 
	# Initialisation jeu
	jeu={
		"tours" : [int(sys.argv[1]), 0, 0],
		"cpt" : 0,
	}
 
	# Affichage position de départ
	print("Départ: %s" % ", ".join(map(str, jeu["tours"])))
 
	# Lancement mouvement de la tour 1 vers la tour 3
	print("\n".join(deplace(jeu, 1, 3, int(sys.argv[1]))))
 
	# Affichage position d'arrivée
	print("Arrivée: %s" % ", ".join(map(str, jeu["tours"])))
# if

ValueError Traceback (most recent call last)
<ipython-input-8-d605c888f81a> in <module>()
50
51 # Vérification arguments
---> 52 if len(sys.argv) <= 1 or int(sys.argv[1]) < 1:
53 print("Usage: %s nb_pions positifs" % os.path.basename(__file__))
54 exit(1)

ValueError: invalid literal for int() with base 10: '-f'

**Sve@r** · 24/05/2020, 18h00

Envoyé par Tudko

La tour 0 contient la valeur 1 pour disque 1, je pense que ça reste manipulable

Je parlais pas de la tour 0 qui contient les disques (ça j'ai compris), je parlais des autres tours qui contiennent des listes vides ce que je ne comprends pas. Ma question concernait donc ces autres tours, et la partie de ma question qui parle de la tour 0 était juste là pour illustrer le fait que vu qu'elle contient des nombres (les largeurs des disques probablement), c'était pas normal d'avoir les autres tours contenant des listes.

Envoyé par Tudko

Est-ce que Python n'est pas le meilleur langage pour faire ça? Il faudrait un langage proprement fonctionnel comme Scheme/Haskell??

Personne ne t'a obligé à utiliser Python. C'est toi qui est venu ici poser la question. Ce forum n'est pas le lieu pour débattre de quel langage est meilleur que lequel (ce qui d'ailleurs est un faux débat => "Aucun langage de programmation n'est parfait. Il n'existe même pas un langage meilleur que d'autre ; il n'y a que des langages en adéquation ou peu conseillés pour des buts particuliers. (Herbert Mayer)").

Envoyé par Tudko

ValueError Traceback (most recent call last)
<ipython-input-8-d605c888f81a> in <module>()
50
51 # Vérification arguments
---> 52 if len(sys.argv) <= 1 or int(sys.argv[1]) < 1:
53 print("Usage: %s nb_pions positifs" % os.path.basename(__file__))
54 exit(1)

ValueError: invalid literal for int() with base 10: '-f'

Il semble que tu utilises ipython (et probablement basé sur Python2). Mon script est écrit en Python3.
Te faut remplacer les deux yield from deplace(...) (lignes 27 et 39) par for x in deplace(...): yield x (le yield from iterable n'existe pas en P2).

Et j'espère que ce "-f" que je vois c'est pas toi qui l'a invoqué comme option quand tu appelles ce programme.

**Tudko** · 04/06/2020, 14h57

Salut je reviens vers vous

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
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
T= [[0, 1, 2, 3, 4, 5, 6, 7],[],[]]
i = 0
j=0
compteur=0
def move(i, j):
  global compteur
  if j == i:
    j=i
    if compteur %2 == 0:
        del T[compteur][j]
        compteur= compteur +2
        T[compteur].append(j)
 
    else:
        del T[compteur][j]
        compteur= compteur +1
        T[compteur].append(j)
 
  else:
    move(i, j-1)
    move(j, j)
    move(i, j-1)
    print(T); print()#sauter une ligne entre deux étapes affichées
    compteur=compteur%3
move(0, 7)
 
IndexError                                Traceback (most recent call last)
<ipython-input-29-4b0d0af17ac1> in <module>()
     23     print(T); print()#sauter une ligne entre deux étapes affichées
     24     compteur=compteur%3
---> 25 move(0, 7)
 
<ipython-input-29-4b0d0af17ac1> in move(i, j)
     18 
     19   else:
---> 20     move(i, j-1)
     21     move(j, j)
     22     move(i, j-1)
 
<ipython-input-29-4b0d0af17ac1> in move(i, j)
     18 
     19   else:
---> 20     move(i, j-1)
     21     move(j, j)
     22     move(i, j-1)
 
<ipython-input-29-4b0d0af17ac1> in move(i, j)
     18 
     19   else:
---> 20     move(i, j-1)
     21     move(j, j)
     22     move(i, j-1)
 
<ipython-input-29-4b0d0af17ac1> in move(i, j)
     18 
     19   else:
---> 20     move(i, j-1)
     21     move(j, j)
     22     move(i, j-1)
 
<ipython-input-29-4b0d0af17ac1> in move(i, j)
     18 
     19   else:
---> 20     move(i, j-1)
     21     move(j, j)
     22     move(i, j-1)
 
<ipython-input-29-4b0d0af17ac1> in move(i, j)
     18 
     19   else:
---> 20     move(i, j-1)
     21     move(j, j)
     22     move(i, j-1)
 
<ipython-input-29-4b0d0af17ac1> in move(i, j)
     19   else:
     20     move(i, j-1)
---> 21     move(j, j)
     22     move(i, j-1)
     23     print(T); print()#sauter une ligne entre deux étapes affichées
 
<ipython-input-29-4b0d0af17ac1> in move(i, j)
      8     j=i
      9     if compteur %2 == 0:
---> 10         del T[compteur][j]
     11         compteur= compteur +2
     12         T[compteur].append(j)
 
IndexError: list assignment index out of range (?)

J'ai essayé de faire afficher chaque étape du jeu pour avoir et le résultat attendu et le bon raisonnement, ce qui fut un échec précédemment et l'est toujours

**Tudko** · 04/06/2020, 15h02

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
21
22
23
24
25
T0 =[0, 1,  2,  3,  4,  5,  6,  7]
T1 =[[],[],[],[],  [],[],[],[] ]
T2 =[[],[],[],[],  [],[],[],[] ]
i=0
j=0
k=0
def move(i, j, k):
  if i == j :
    if k % 2 == 0:
      T0[i] = []
      T2[i] = i
    else:
      T0[i] = []
      T1[i] = i
  else:
    move(0, j-1, k)
    move(j, j, k)
    move(0, j-1, k)
    print(T0) ; print(T1) ; print(T2)
move(0, 7, 2)
 
[[], [], 2, 3, 4, 5, 6, 7]
[[], [], [], [], [], [], [], []]
[0, 1, [], [], [], [], [], []
…

D'ailleurs pourquoi précédemment l'algo déplace DEUX disques par étape?

**danielhagnoul** · 09/06/2020, 11h01

Je ne comprends pas ce que vous reprochez à la solution du message n° 2, qui n'est pas de moi et qui hors les commentaires tient en 3 lignes !

**tyrtamos** · 09/06/2020, 14h19

Bonjour,

Envoyé par danielhagnoul

Je ne comprends pas ce que vous reprochez à la solution du message n° 2, qui n'est pas de moi et qui hors les commentaires tient en 3 lignes !

Ta solution est bonne et très concise, et conduit bien à afficher tous les déplacements. Mon premier code de mon premier message était du même genre. Mais je trouvais indispensable pour bien comprendre (et contrôler) l'algorithme, d'afficher aussi l'état des 3 tours après chaque déplacement, ce qui est moins facile. Et on n'a pas résisté à l'envie de chercher une solution non récursive...

En tout cas, nos 2 réponses ont le même défaut: on a proposé nos solutions sans aider vraiment le PO à comprendre pourquoi sa solution ne marchait pas (ce qui n'est jamais facile).

**Sve@r** · 09/06/2020, 18h03

Envoyé par danielhagnoul

Je ne comprends pas ce que vous reprochez à la solution du message n° 2, qui n'est pas de moi et qui hors les commentaires tient en 3 lignes !

Personne n'a critiqué ta solution. En plus j'aime bien ta façon de trouver la tour intermédiaire (6 - dep - arr).

On a juste donné ensuite nos façons de faire respectives. Mais c'est vrai que donner à chaque étape l'état des tours est un bon atout pour une solution...

Accessoirement l'algo itératif fonctionne... mais il n'en est qu'à "Mvt 15 683 083 648: 2 => 1: Etat: 39, 7, 18".
Donc (petit calcul), 15 000 000 000 de mouvements en 1 jour, 2 ** 64 - 1 mouvements à faire, il me faudra donc (2 ** 64 - 1) // (15 * 10 ** 9) soit 1 229 782 938 de jours (un peu plus de 3,3 millions d'années)

Bon, je sens que le ctrl-c ne va pas tarder. Mon code n'est pas assez rapide pour amener la fin du monde. Quant aux pauvres moines qui, eux, font ça à la main...

Envoyé par tyrtamos

En tout cas, nos 2 réponses ont le même défaut: on a proposé nos solutions sans aider vraiment le PO à comprendre pourquoi sa solution ne marchait pas (ce qui n'est jamais facile).

Sisi, j'ai tenté de lui expliquer ce qui cafouillait dans ce que j'ai compris de son code. Ensuite bon si le PO veut qu'on continue à s'intéresser à son cas, alors il faudrait qu'il intervienne aussi de son côté. On n'est pas sa maman quoi...