Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

Python Discussion :

Tours de Hanoi


Sujet :

Python

  1. #1
    Nouveau Candidat au Club
    Tours de Hanoi
    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 !

  2. #2
    Rédacteur



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

  3. #3
    Expert éminent sénior
    Salut,

    Citation Envoyé par Tudko Voir le message
    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
    Architectures post-modernes.
    Python sur DVP c'est aussi des FAQs, des cours et tutoriels

  4. #4
    Expert éminent sénior
    Bonjour
    Citation Envoyé par Tudko Voir le message
    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.

    Citation Envoyé par Tudko Voir le message
    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é.

    Citation Envoyé par Tudko Voir le message
    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
    Mon Tutoriel sur la programmation «Shell»
    Sinon il y en a pleins d'autres. N'oubliez pas non plus les différentes faq disponibles sur ce site

  5. #5
    Nouveau Candidat au Club
    Merci beaucoup
    C'est vrai que c'était intéressant de m'entraîner à chercher ma propre version

  6. #6
    Nouveau Candidat au Club
    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

  7. #7
    Expert éminent sénior
    Citation Envoyé par Tudko Voir le message
    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 ???

    Citation Envoyé par Tudko Voir le message
    [[], [], [], [], [], [], [], []]
    [[], [], [], [], [], [], [], []]
    [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.

    Citation Envoyé par Tudko Voir le message
    Citation Envoyé par Sve@r Voir le message
    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.
    Mon Tutoriel sur la programmation «Shell»
    Sinon il y en a pleins d'autres. N'oubliez pas non plus les différentes faq disponibles sur ce site

  8. #8
    Nouveau Candidat au Club
    Citation Envoyé par Sve@r Voir le message
    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??

  9. #9
    Nouveau Candidat au Club
    Citation Envoyé par Sve@r Voir le message
    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'

  10. #10
    Expert éminent sénior
    Citation Envoyé par Tudko Voir le message
    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.

    Citation Envoyé par Tudko Voir le message
    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)").

    Citation Envoyé par Tudko Voir le message
    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.
    Mon Tutoriel sur la programmation «Shell»
    Sinon il y en a pleins d'autres. N'oubliez pas non plus les différentes faq disponibles sur ce site

  11. #11
    Nouveau Candidat au Club
    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

  12. #12
    Nouveau Candidat au Club
    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?

  13. #13
    Expert éminent sénior
    Citation Envoyé par Tudko Voir le message
    D'ailleurs pourquoi précédemment l'algo déplace DEUX disques par étape?
    Je n'en sais absolument rien. Peut-être parce que ton algo n'a pas de commentaire et que j'y pige que dalle (déjà toi est-ce que tu t'en sors ???). Pourquoi par exemple tester si "i" est pair ???. Peut-être parce que les lignes 10 et 13 sont les mêmes bien que l'une soit dans le "if" et l'autre dans le "else" (si j'ai ceci alors faire cela, sinon faire cela !!! ). Ou alors peut-être parce que les lignes 16 et 18 sont là aussi les mêmes (sans compter la ligne 17 où je ne sais pas trop si "j" représente le nb de pions ou les tours de départ et d'arrivée mais où, dans tous les cas, ne peut pas être utilisé 2 fois ..)

    Bref pour résumer, parce que ton code bien qu'il "ressemble" à un algo de Hanoi, ne reproduit absolument pas l'algo de base qui est (déjà dit)
    Déplacer n disques de la tour 1 à la tour , c'est
    • 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
    Mon Tutoriel sur la programmation «Shell»
    Sinon il y en a pleins d'autres. N'oubliez pas non plus les différentes faq disponibles sur ce site