Torre de Python problema Hanoi

En primer lugar, el código Torre de Hanoi

= COUNT 0
 DEF Hanoi (n-, la src, DST, MID): # definen cuatro parámetros representan el número de discos, la columna de la fuente, la columna de destino, la transición columna del medio 
    mundial COUNT   # implementado usando variables globales en una palabra reservada mundial 
    SI n - == 1. :
         Imprimir ( " PASO {} {} -> {} " .formato (1, sRC, DST).) # Si sólo un disco, la columna se trasladó al destino directamente desde la fuente a la columna 
        recuento + . 1 = la otra cosa : 
        Hanoi (n- -1, la src, MID, DST) # el n-1 ésima columna del disco de origen para mover la columna intermedia de impresión ( " PASO {}: {} -> {} " .formato (n-, la src, DST)) # la última columna del disco de origen para mover la columna de destino 
        COUNT + =. 1 
        Hanoi (n-
    
        -1, MID, DST, la src) # la n-ésima columna 1 del disco intermedio a una columna de destino 
n- = int (INPUT ()) 
Hanoi (n-, " A " , " C " , " B " )

 

La presentación de los resultados

En segundo lugar, la Torre de Hanoi animación

codificar las referencias https://blog.csdn.net/BeerBread134/article/details/69226991

El código se puede ejecutar hasta 7-fin Torre de Hanoi, sobre todo con la idea de recursividad y la pila, logrado con una tortuga.

la importación de tortugas 
 
clase Pila:
     def  __init__ (self): 
        self.items = []
     def estaVacia (auto):
         volver len (self.items) == 0
     DEF empuje (auto, elemento): 
        self.items.append (punto) 
    def pop (auto):
         retorno self.items.pop ()
     def peek (auto):
         si  no self.isEmpty ():
             retorno self.items [len (self.items) - 1 ]
     def tamaño (auto):
         retorno len ( self.items) 
 
defdrawpole_3 (): # Draw Torre de polos Hanoi 
    T = turtle.Turtle) ( 
    t.hideturtle) ( 
    DEF drawpole_1 (K): 
        t.up () 
        t.pensize ( 10 ) 
        t.speed ( 100 ) 
        T. Goto ( 400 * (. 1-K), 100 ) 
        t.down () 
        T. Goto ( 400 * (. 1-K), -100 ) 
        T. Goto ( 400 * (. 1-K) -20, -100 ) 
        T. GOTO ( 400 * (. 1-K) 20, -100 ) 
    drawpole_1 (0) # dibujar Torre de Hanoi Poles [0] 
    drawpole_1 (. 1) # dibujar Torre de Hanoi Poles [. 1] 
    drawpole_1 (2) #Dibuje Torre de Hanoi Poles [2] 
 
DEF creat_plates (n): # producir N discos 
    Placas = [turtle.Turtle () para I en Rango (n)]
     para I en Rango (n): 
        Placas [I]. uP () 
        Placas [I] .hideturtle () 
        Placas [I] .shape ( " cuadradas " ) 
        Placas [I] .shapesize ( 1,8 I) 
        Placas [I] .goto ( -400, -90 * + 20 es I) 
        Las placas [I] .showturtle () 
    de retorno placas 
 
DEF pole_stack (): # producir polos de la pila 
    polos = [pila () para Ien (. 3 Rango )]
     volver Polacos 
 
DEF moveDisk (placas, postes, FP, TP): # los polos [fp] a las placas de placa superior [MOV] de postes [fp] para mover Poles [TP] 
    MOV = polos [fp] .peek () 
    Placas [MOV] .goto ((FP -1) * 400,150 ) 
    Placas [MOV] .goto ((TP -1) * 400.150 ) 
    L = Poles [TP] .size () # determina el movimiento en la porción de extremo de altura (en la placa de justo por encima del original más superior) 
    placas [MOV] .goto (. (1-TP) * 400, * 20 es -90 + L) 
 
DEF moveTower (placas, postes, altura, fromPole, Topole, withPole): # bandeja de descarga recursiva 
    IF altura> = 1. : 
        moveTower (placas, postes, altura -1, fromPole, withPole, Topole) 
        moveDisk (placas, postes, fromPole, Topole) 
        polos [Topole] .push (polos .pop ([fromPole])) 
        moveTower (placas, postes, altura -1 , withPole, Topole, fromPole) 
 
myscreen = turtle.Screen () 
drawpole_3 () 
n = int (de entrada ( " 请输入汉诺塔的层数并回车: \ n " )) 
placas = creat_plates (n) 
polos = pole_stack ()
 para i en gama (n ): 
    polos [0] .push (i) 
moveTower (placas, postes, n, 0, 2,1 ) 
myscreen.exitonclick ()

Los resultados muestran