Códigos: Analisis de signos y Torres de hanoi

La semana pasada hablé sobre como mejoré mi nivel de programación y matemática, también hable sobre dos programas que hice con Pascal plasmé mi algoritmo para hacer análisis de signos y con Python enfrenté el gran desafío de resolver las torres de hanoi.

torres de hanoi 

Las torres de hanoi es un problema que consiste tres torres donde en la primera torre hay una cantidad de discos, el objetivo del juego es llevar todos los discos a la tercera torre moviendo un disco por turno a una torre donde no hay discos o hay un disco mayor al que hay que mover. Los discos se numeran según su posición, el primer disco está encima de todos los discos y el último disco esta abajo de todos los discos.

Me agarre de una solución que había hecho hace unos meses de ese problema, básicamente era una propiedad que decía que si el disco era par tenía tres posibles movimientos a hacer según la torre en donde estaba el disco, si era impar los tres movimientos posibles eran otros.

Me costo mucho resolverlo usando esa propiedad porque había tantos casos posibles donde en cada uno la propiedad reacciona diferente, tal vez esa propiedad sirve para nosotros los humanos que podemos manejar bien la ambigüedad pero esa propiedad de las torres de hanoi es complicada de aplicar a un algoritmo.

Otra cosa que me costo de ese programa fue la implementación con dígitos,  ya que requiere implementar una manera de poner un dígito delante a un número, pero por suerte le pregunte a mi profe de RPA(Resolución de Problemas y Algoritmos) que me explico por mail como se hacía. sin mas preámbulo les dejo con el código : 

#!/usr/bin/python3

torres = [1234,0,0]

linea = '\n-------------------------\n'
############### SUBDIVISION #########################
def contar(torre,cantidad=0):
  '''
   Cuenta discos de una torre.
  '''  
  if (torre == 0):
 
    return 0
   
  elif (torre < 10):
      return cantidad+1
  else: 
      return contar(int(torre/10),cantidad+1)


def  primero(torre):
  '''
   Devuelve el primer disco de una torre.
  '''   
  if (torre < 10):
    return torre
  else:
    return primero(int(torre/10))


def invertir(num):

  '''
   Invierte un numero.
  '''
  if (num > 9):
    
     return int(str(num)[::-1])
    
  else:
  
     return num
   
def mover(torre1, torre2):

  '''
   Mueve un disco de una torre a otra torre.
  '''
  torres[torre2] = primero(torres[torre1])*(10**contar(torres[torre2]))+torres[torre2]
 
  torres[torre1] = invertir(int(invertir(int(torres[torre1]))/10))
 
  print(torres)  
##################################################
torres[0] = int(input('Ingrese discos en forma de numero: '))     

print(torres)

print(linea) 

print('hay '+str(contar(torres[0]))+' discos.')
  
print(torres)
############### RESOLUCION DEL PROBLEMA DE HANOI ################
## Ejecuto un pasos de la solucion de hanoi para 4 discos ########## 
mover(0,1)
mover(0,2)
mover(1,2)
mover(0,1)
mover(2,0)
mover(2,1)
mover(0,1)
mover(0,2)
mover(1,2)
mover(1,0)
mover(2,0)
mover(1,2)
mover(0,1)
mover(0,2)
mover(1,2)      
##################################################################  
print(linea)
print(torres)
print('hanoi resuelto')

Analisis de signos

Si leyeron la entrada de la semana pasada podrán saber que hice un algoritmo para hacer el análisis de signos de una expresión algebraica, en base a él hice un programa en pascal que pedía un cero, un valor menor al cero y un valor mayor al cero que valida que toda la información ingresada por el usuario sea correcta. En vez de pedir una expresión el programa viene con una expresión que modifico al cambiarla y valida que el cero ingresado por el usuario haga que la expresión tenga valor cero, también la cambio en los condicionales que revisan si un valor hace positiva o negativa dicha expresión :   

program signo;

var cero, valor_izq, valor_der:integer;

begin
 
// CAMBIA SEGUN LA EXPRESION...
 writeln('Analizare los signos de la expresion -x+1.');
  repeat
    write('Ingrese cero: ');
 
    readln(cero);
  until ((-cero+1) = 0);
//----------------------------------------------------

  repeat
    write('Ingrese un valor a la izquierda del cero: ');
 
    readln(valor_izq)
 
  until (valor_izq < cero);

  repeat
    write('Ingrese un valor a la derecha del cero: ');
 
    readln(valor_der)

  until (valor_der > cero);

// CAMBIA SEGUN LA EXPRESION...
  if ((-valor_der+1) > 0)
    then write('der : + ')
  else  write('der : - ');

  if ((-valor_izq+1) > 0)

    then write('izq : + ')
 
  else write('izq : -');
//----------------------------
 writeln
end.