Python Torre de problema Hanoi

Primeiro, o código Torre de Hanói

= COUNT 0
 DEF Hanói (n-, o src, DST, MID): # definir quatro parâmetros representam o número de discos, a coluna de origem, a coluna de destino, a transição coluna do meio 
    global de COUNT   # implementada utilizando variáveis globais em uma palavra reservada mundial 
    IF n - == 1. :
         Imprimir ( " STEP {}: {} -> {} " .format (1, o src, DST).) # Se apenas um disco, a coluna foi transferida para o destino diretamente da fonte para a coluna 
        contagem + . 1 = o mais : 
        Hanoi (n- -1, o src, MID, DST) # o n-1 ésima coluna a partir do disco de origem para mover a coluna intermédia impressão ( " PASSO {}: {} -> {} " .format (n-, o src, DST)) # a última coluna do disco de origem para mover a coluna de destino 
        COUNT + =. 1 
        Hanoi (n-
    
        -1, MID, DST, o src) # a n-ésima coluna 1 do disco intermédio de uma coluna de destino 
n- = int (ENTRADA ()) 
Hanoi (n-, " A " , " C " , " B " )

 

A apresentação dos resultados

Em segundo lugar, a Torre de animação Hanoi

referências de código https://blog.csdn.net/BeerBread134/article/details/69226991

O código pode ser executado até 7 de ordem Torre de Hanói, principalmente com a idéia de recursão e pilha, conseguido com uma tartaruga.

importação tartaruga 
 
classe Stack:
     def  __init__ (self): 
        self.items = []
     def isEmpty (self):
         voltar len (self.items) == 0
     def push (self, item): 
        self.items.append (item) 
    def pop (self):
         return self.items.pop ()
     def espiada (self):
         se  não self.isEmpty ():
             retorno self.items [len (self.items) - 1 ]
     def tamanho (self):
         return len ( self.items) 
 
defdrawpole_3 (): # desenhar Torre de pólos 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) # desenhar Torre de Hanoi pólos [0] 
    drawpole_1 (. 1) # desenhar Torre de Hanoi pólos [. 1] 
    drawpole_1 (2) #Desenhe Torre de Hanói poloneses [2] 
 
DEF creat_plates (n): # produzindo n discos 
    placas = [turtle.Turtle () para I em Range (n)]
     para I em Range (n): 
        Placas [i]. cima () 
        placas [I] .hideturtle () 
        placas [I] .shape ( " Quadrado " ) 
        placas [I] .shapesize ( 1,8 I) 
        as placas [I] .goto ( -400, -90 * + 20 está I) 
        As placas [I] .showturtle () 
    retorno placas 
 
DEF pole_stack (): # produzindo pólos pilha 
    pólos = [pilha () para Iem (. 3 Faixa )]
     retornar Poloneses 
 
DEF moveDisk (placas, pólos, FP, TP): # os pólos [fp] para as chapas de placa de topo [mov] a partir pólos [fp] para mover pólos [TP] 
    MOV = pólos [fp] .peek () 
    placas [MOV] .goto ((FP -1) * 400,150 ) 
    placas [MOV] .goto ((TP -1) * 400150 ) 
    L = pólos [TP] .size () # determina o movimento na porção de extremidade altura (na placa apenas acima do original superior) 
    placas MOV [] .goto (. (1-TP) * 400, * 20 é -90 + L) 
 
DEF moveTower (placas, postes, altura, fromPole, Topole, withPole): # tabuleiro de descarga de recursiva 
    SE altura> = 1. : 
        moveTower (placas, postes, altura -1, fromPole, withPole, Topole) 
        moveDisk (placas, postes, fromPole, Topole) 
        pólos [Topole] .push (pólos [fromPole] .pop ()) 
        moveTower (placas, postes, altura -1 , withPole, Topole, fromPole) 
 
MyScreen = turtle.Screen () 
drawpole_3 () 
n = int (entrada ( " 请输入汉诺塔的层数并回车: \ n " )) 
chapas = creat_plates (n) 
pólos = pole_stack ()
 para i na gama (n ): 
    pólos [0] .push (i) 
moveTower (placas, postes, n, 0, 2,1 ) 
myscreen.exitonclick ()

Os resultados mostram