Torre Hanoi

Nuestro primer algoritmo en Ciencias de la Computación. Resolver la torre de Hanoi.

1. Seleccionar disco

1 def seleccione_disco(NUM_DIS,paso):
2 # Para cada disco en orden inverso
3 for disco in range(NUM_DIS,-1,-1):
4 # Calculamos masa
5 masa = 2 ** disco
6 # Si el paso deja mover la masa, retorne ese disco
7 if paso % masa == 0:
8 return disco
9
10 # Prueba
11 # se espera que en el paso 4 se seleccione el disco 2
12 assert(seleccione_disco(3, 4) == 2)

2. Ubicar desde

1 def disco_en_barra(NUM_DIS, masa_barra,disco):

2
3 masa_barra_binario=format(masa_barra, '#0' +str(NUM_DIS+1)+'b')
4 masa_barra_binario_rev =masa_barra_binario [:-(NUM_DIS)-1:-1]
5 return int(masa_barra_binario_rev[disco])
6
7
 1 def ubique_disco(NUM_DIS,masa_barras, disco):
2 # Por cada barra
3 for barra in [0,1,2]:
4 # Convierta en binario para saber la ubicacion de cada disco
5
6 # Si el disco es encontrado retorne esa barra
7 if disco_en_barra(NUM_DIS,masa_barras[barra],disco):
8 return barra
9
10
11 # Prueba:
12 # Cuando las masas estan repartidas como [1,4,2] el disco 1 se encuentra en la
13 # barra 2
14

3. Ubicar hacia donde

1 def ubique_hacia_donde(NUM_DIS,masa_barras, disco, desde):

2 hacia_der = (desde + 1) % 3
3 hacia_izq = (desde - 1) % 3
4 masa_disco = 2**disco
5
6 # Para todos los disco que estan debajo:
7 for disco in range(disco):
8 # Si aquel disco esta en la barra derecha
9 if disco_en_barra(NUM_DIS,masa_barras[hacia_der],disco):
10 #Entonces; muevase mejor hacia la izquierda
11 return hacia_izq
12
13 return hacia_der
14
15 # Prueba
16 # Si la masa de las barras es [0,4,3] y quiero mover el disco 0 que se encuentra
17 # en la barra 2, se espera que se mueva a la barra 0
18
19 # Prueba Jeisson:
20 # Para 4 discos, si la msa de las barras es [11,4,0] y quiero mover
21 # el disco 1 que se encuentra en la barra 2, se espera que se mueva a la barra 1
22
23
24

4. Mover disco

1 def muevase(masa_barras, disco, desde, hacia):

2 masa_disco = 2**disco
3 for barra in [0,1,2]:
 4 if barra == desde:
5 masa_barras[barra] -= masa_disco
6 if barra == hacia:
7 masa_barras[barra] += masa_disco
8
9 return masa_barras
10
11 # Prueba
12 # Cuando las masa de las barras es [1,4,2] y se mueve el disco 1 desde
13 # la barra 2 hacia la barra 1, se espera que la nueva masa sea [1,6,0]
14

ALGORITMO

1 print("Digite los discos que va a usar: ")

2 NUM_DIS=int(input())
3 masa_inicial = 2**NUM_DIS - 1
4 masa_barras_inicial = [masa_inicial,0,0]
5 masa_barras = masa_barras_inicial
6
7 # Para cada paso
8 for paso in range(1, masa_inicial+1):
9 # 1. Seleccionar disco
10 disco = seleccione_disco(NUM_DIS,paso)
11 # 2. Ubique disco
12 barra_desde = ubique_disco(NUM_DIS,masa_barras, disco)
13 # 3. Ubicar hacia donde
14 barra_hacia = ubique_hacia_donde(NUM_DIS,masa_barras, disco, barra_desde)
15 # 4. Mover disco y actualizar masa
16 masa_barras = muevase(masa_barras, disco, barra_desde, barra_hacia)
17 print('paso', paso,
18 'disco:', disco,
19 'desde:', barra_desde,
20 'hacia:', barra_hacia,
21 'masa:', masa_barras)
22

Digite los discos que va a usar:

3
paso 1 disco: 0 desde: 0 hacia: 1 masa: [6, 1, 0]
paso 2 disco: 1 desde: 0 hacia: 2 masa: [4, 1, 2]
paso 3 disco: 0 desde: 1 hacia: 2 masa: [4, 0, 3]
paso 4 disco: 2 desde: 0 hacia: 1 masa: [0, 4, 3]
paso 5 disco: 0 desde: 2 hacia: 0 masa: [1, 4, 2]
paso 6 disco: 1 desde: 2 hacia: 1 masa: [1, 6, 0]
paso 7 disco: 0 desde: 0 hacia: 1 masa: [0, 7, 0]