# Tours de Hanoi

n = 3 # nombre de disques
depart = [ n-i for i in range(n)]
intermediaire = []
arrivee = []
tours = [depart, intermediaire, arrivee]

def deplacer(depart, arrivee) :
    sommet_depart = 0
    sommet_arrivee = 0
    if len(tours[depart]) > 0 :
        sommet_depart = tours[depart][len(tours[depart]) - 1]

    if sommet_depart > sommet_arrivee and sommet_arrivee != 0 :
        print("erreur : sommet", depart, " > sommet", arrivee) # règles du Jeu
    else:
        tours[depart].pop(len(tours[depart]) - 1)
        tours[arrivee].append(sommet_depart)
        print(tours) 

def Hanoi(n, depart = 0, intermediaire = 1, arrivee = 2):
    if n > 0 :
        Hanoi(n - 1, depart, arrivee, intermediaire)
        deplacer(depart, arrivee)
        Hanoi(n - 1, intermediaire, depart, arrivee)
Hanoi(n)

# Résulat :
[[3, 2], [], [1]]
[[3], [2], [1]]
[[3], [2, 1], []]
[[], [2, 1], [3]]
[[1], [2], [3]]
[[1], [], [3, 2]]
[[], [], [3, 2, 1]]

Espace_des_etats_explorés =  [ [[3, 2], [], [1]] ,
[[3], [2], [1]] ,
[[3], [2, 1], []] ,
[[], [2, 1], [3]] ,
[[1], [2], [3]] ,
[[1], [], [3, 2]] ,
[[], [], [3, 2, 1]] ]

space = []
temp = [[] for i in range(4)]
j = -1

print(j)
temp[j] = []
print(temp[j]) 
space.append(temp[j])
print(space) ; print()
j += 1

print(j) 
temp[j] = [0]
print(temp[j]) 
space.append(temp[j])
print(space) ; print()
j += 1

print(j) 
temp[j] = [1]
print(temp[j]) 
space.append(temp[j])
print(space) ; print()
j += 1

print(j) 
temp[j] = [2]
print(temp[j]) 
space.append(temp[j])
print(space) 

#sortie:
-1
[]
[[]]

0
[0]
[[], [0]]

1
[1]
[[], [0], [1]]

2
[2]
[[], [0], [1], [2]]

n = 3
Depart = [ n - i for i in range(n)]
Intermediaire = []
Arrivee = []
Tours = [ Depart, Intermediaire, Arrivee]

Space = [ [[ n - i for i in range(n)], [], []] ]
Temp = [ [] for i in range(n**3)]
j = 0
def move(Depart, Arrivee):
    sommet_D = 0
    sommet_A = 0
    if len(Tours[Depart]) > 0 :
        sommet_D = Tours[Depart][len(Tours[Depart]) - 1]
    if len(Tours[Arrivee]) > 0 :
        sommet_A = Tours[Arrivee][len(Tours[Arrivee]) - 1]
    if sommet_D > sommet_A and sommet_A != 0 :
        print("Error")
    else :
        global j    #on oublie pas le global

        Tours[Depart].pop(len(Tours[Depart]) - 1)
        Tours[Arrivee].append(sommet_D)

        print(Tours) # La liste Tours change à chaque fois

        print(j) # Vérification de j bien incrémenté

        Temp[j] = Tours # affectation :

        print(Temp[j]) # On vérifie bien qu'on place Tours

        # (à chaque fois une liste différente) à une variable incrémentée également 
        # différente à chaque fois (j ième élément de la liste globale Temp)

        Space.append(Temp[j]) # La liste est donc censée se remplir au fur et 
        # à mesure avec des listes Tours différentes (comme dans le code test plus haut)

        print(Space) 
        # MAIS on se retrouve avec j +1 fois la même liste Tours (à 
        # l'état/étape correspondant/e du jeu) à chaque 
        # incrémentation de j

        j += 1 # compteur j incrémenté pour la phase suivante....

def hanoi(n, Depart = 0, Intermediaire = 1, Arrivee = 2):
    if n > 0 :
        hanoi(n - 1, Depart, Arrivee, Intermediaire)
        move(Depart, Arrivee)
        hanoi(n - 1, Intermediaire, Depart, Arrivee)
hanoi(n)

Out :

[[3, 2], [], [1]] #Première étape du jeu (liste Tours)

0                 # vérification du compteur j

[[3, 2], [], [1]] # vérification de la variable Temp[j] ainsi différente à chaque phase, contenant alors Tours 

# Space :

[[[3, 2, 1], [], []], [[3, 2], [], [1]]] # jusqu'ici tout va bien avec .append( Temp[0])

[[3], [2], [1]] # état (étape) suivant(e) du jeu des tours de Hanoi, liste différente de la précédente

1               # idem compteur vérifié

[[3], [2], [1]] # idem la NOUVELLE variable Temp[j = 1] contient le NOUVEL état du jeu (liste Tours actualisée),c'est vérifié

# print(Space.append(Temp[1] = Tours) ):

[[[3, 2, 1], [], []], [[3], [2], [1]], [[3], [2], [1]]] #??

# pas logique, 

# 2 fois la même liste Tours ajoutée à l'étape 3

# (ensuite ce sera 6 fois la même liste à l'étape finale 7 juste à la suite de l'élément initial)

# On devrait à mon sens obtenir:

[[[3, 2, 1], [], []], [[3, 2], [], [1]], [[3], [2], [1]]] # Des listes différentes comme prévu (?)

... puis même observation

... rien ne va plus pour toute la suite et fin, même problème !