//Mueve el top de la primera pila dada a la segunda, si no se puede,
//hace lo contrario: de la segunda a la primera.
public void mover_disco(Pila a, Pila b)
{
if (a.Top > b.Top)
{
if (b.isEmpty())
{
Disco d = a.pop();
b.push(d);
}
else
{
Disco d = b.pop();
a.push(d);
}
}
else if (a.Top < b.Top)
{
if (a.isEmpty())
{
Disco d = b.pop();
a.push(d);
}
else
{
Disco d = a.pop();
b.push(d);
}
}
}
/*TODO: Implementar métodos*/
public void mover_disco(Pila a, Pila b)
{
if (b.isEmpty())
{
Disco discoA = a.pop();
b.push(discoA);
Console.WriteLine("Moviendo de A a B");
}
else if (a.isEmpty())
{
Disco discoB = b.pop();
a.push(discoB);
Console.WriteLine("Moviendo de B a A");
}
else
{
if (a.Top.Valor < b.Top.Valor)
{
Disco discoA = a.pop();
b.push(discoA);
Console.WriteLine("Moviendo de A a B");
}
else if (b.Top.Valor < a.Top.Valor)
{
Disco discoB = b.pop();
a.push(discoB);
Console.WriteLine("Moviendo de B a A");
}
}
}
/*TODO: Implementar métodos*/
public void mover_disco(ref Pila a, ref Pila b)
{
if ((b.Top == 0) || (a.Top == 0))
{
if (b.Top == 0)
{
Disco disco = a.pop();
b.push(disco);
}
else
{
Disco disco = b.pop();
a.push(disco);
}
}
else
{
if (a.Top > b.Top)
{
Disco disco = b.pop();
a.push(disco);
}
else
{
Disco disco = a.pop();
b.push(disco);
}
}
}
int movimientos = 0;//variable que se utiliza para saber los movimientos totales
/*TODO: Implementar métodos*/
public void mover_disco(Pila a, Pila b)
{
if (a.isEmpty() == true)//si a esta vacio
{
Disco enMovimiento = b.pop();
Console.WriteLine("mov si a es vacio");//guardamos b enMovimiento
a.push(enMovimiento);
}
else if (b.isEmpty() == true) //si b esta vacio
{
Disco enMovimiento = a.pop(); //guardamos a enMovimiento
Console.WriteLine("mov si b es vacio");
b.push(enMovimiento);
}
else if (a.elementos[a.elementos.Count - 1].Valor > b.elementos[b.elementos.Count - 1].Valor) //si el elemento a> b
{
Disco enMovimiento = b.pop(); //guardamos b enMovimiento
Console.WriteLine("mov si a > que b ");
a.push(enMovimiento);
}
else
{
Disco enMovimiento = a.pop();//guardamos a enMovimiento
Console.WriteLine("mov si a < que b ");
b.push(enMovimiento);
}
}
public void mover_disco(Pila a, Pila b)
{
if (a.Top == b.Top) // Edge case (both are empty)
{
return;
}
else if (a.Top > b.Top)
{
if (b.isEmpty())
{
b.push(a.pop());
}
else
{
a.push(b.pop());
}
}
else
{
if (a.isEmpty())
{
a.push(b.pop());
}
else
{
b.push(a.pop());
}
}
movements++;
}
/*TODO: Implementar métodos*/
public void mover_disco(Pila a, Pila b)
{
if (a.Top < b.Top) // Comprobamos si a es menor a b
{
if (a.isEmpty()) // Comprobamos si a está vacia
{
a.push(b.pop()); // En caso de que esté vacia significa que a no es menor a b, sino que a es 0
}
else
{
b.push(a.pop()); // Sino a si que es menor a b
}
}
else
{
if (a.Top > b.Top) // Comprobamos si b es menor a a
{
if (b.isEmpty()) // Comprobamos si b está vacia
{
b.push(a.pop()); // En ese caso b no es menor a a
}
else
{
a.push(b.pop()); // Si está llena b es menor a a
}
}
}
}
//==============================================================================
// Mover disco
//==============================================================================
public static void mover_disco(Pila a, Pila b)
{
Disco discoMover = new Disco();
//==============================================================================
// Si las pilas estan vacias
//==============================================================================
if (a.isEmpty() == true)
{
discoMover = b.pop();
Console.WriteLine("Moviendo disco " + discoMover.Valor + " de B a A");
if (discoMover.Valor != 0)
{
a.push(discoMover);
}
return;
}
else if (b.isEmpty() == true)
{
discoMover = a.pop();
Console.WriteLine("Moviendo disco " + discoMover.Valor + " de A a B");
if (discoMover.Valor != 0)
{
b.push(discoMover);
}
return;
}
//==============================================================================
// Mira que elemento superior de las pilas es mayor
//==============================================================================
else if (a.Top > b.Top)
{
discoMover = b.pop();
Console.WriteLine("Moviendo disco " + discoMover.Valor + " de B a A");
if (discoMover.Valor != 0)
{
a.push(discoMover);
}
return;
}
else if (b.Top > a.Top)
{
discoMover = a.pop();
Console.WriteLine("Moviendo disco " + discoMover.Valor + " de A a B");
if (discoMover.Valor != 0)
{
b.push(discoMover);
}
return;
}
}
/*TODO: Implementar métodos*/
public void mover_disco(Pila a, Pila b)
{
Disco mover = new Disco(0); //var donde almacenamos los discos que vamos a mover
//si en la pila a hay discos
if (a.isEmpty().Equals(false))
{
if (b.isEmpty().Equals(true))
{ //si la pila b esta vacia
mover = a.pop(); //get y borrar el ultimo disco de la pila
b.push(mover); //mover a la pila b
}
else // si en la pila b hay discos
{
if (a.Top < b.Top) //si el ultimo disco de a es mas pequenyo que el disco de b.
{
mover = a.pop(); //get y borrar el ultimo disco de la pila
b.push(mover); //mover a la pila b
}
else
{
mover = b.pop(); //get y borrar el ultimo disco de la pila b
a.push(mover); //mover b la pila a
}
}
}
else if (b.isEmpty().Equals(false))
{
if (a.isEmpty().Equals(true))
{
mover = b.pop(); //get y borrar el ultimo disco de la pila
a.push(mover); //mover a la pila a
}
else
{ //si en la pila a hay discos
if (b.Top < a.Top) //comprobamos si podemos mover el disco
{
mover = b.pop(); //get y borrar el ultimo disco de la pila
a.push(mover); //mover b la pila a
}
else
{
mover = a.pop(); //get y borrar el ultimo disco de la pila b
b.push(mover); //mover a la pila b
}
}
}
}
/*TODO: Implementar métodos*/
public void mover_disco(Pila a, Pila b)
{//Mover disco de 'a' a 'b' o de 'b' a 'a'
/* mostrarMovimiento(a);
* mostrarMovimiento(b);
*/
Disco aux = new Disco();
if (a.isEmpty() && b.isEmpty())
{
return;
}
if (a.Top > b.Top)
{// Si el disco top de a es mayor que el de b, entonces solo se podra mover de b hacia a
if (b.isEmpty())
{
aux = a.pop();
b.push(aux);
/* mostrarMovimiento(a);
* mostrarMovimiento(b);
*/ return;
}
aux = b.pop();
a.push(aux);
/* mostrarMovimiento(a);
* mostrarMovimiento(b);
*/}
else
{// sino se movera de 'a' a 'b'
if (a.isEmpty())
{
aux = b.pop();
a.push(aux);
/* mostrarMovimiento(a);
* mostrarMovimiento(b);
*/return;
}
aux = a.pop();
b.push(aux);
/* mostrarMovimiento(a);
* mostrarMovimiento(b);
*/ }
}
/*TODO: Implementar métodos*/
public static void mover_disco(Pila a, Pila b)
{/*
* if (a.isEmpty() && !b.isEmpty())
* {
* // Si una pila esta vacía y la otra no saco un disco y la pongo en la vacía
* a.push(b.pop());
* }
* else if (b.isEmpty() && !a.isEmpty())
* {
* b.push(a.pop());
* }
* else
* {*/
// Si ambas pilas tienen discos muevo el disco mas pequeño
// y lo pongo encima del grande
if (!a.isEmpty() || !b.isEmpty())
{
// Si a tiene un disco mas pequeño que b muevo el disco de a => b
if (a.isMyTopSmaller(b))
{
a.push(b.pop());
}
// Si b tiene un disco mas pequeño que a muevo el disco de b => a
else
{
b.push(a.pop());
}
}
}
public void registrarMovimiento(Pila a, Pila b)
{
Disco tmp = a.pop();
Console.WriteLine("Se ha movido el disco: " + tmp.Valor);
b.push(tmp);
}
public static void mover_disco(Pila a, Pila b)
{
Disco discoMover;
// Compruebo si las dos pilas estan vacias
if (a.isEmpty() && b.isEmpty())
{
return;
}
// Compruebo si b esta vacia o si b tiene un disco de mayor tamaño que a (todas estas condiciones requieren que a no este vacia)
else if (b.isEmpty() || b.Top > a.Top && a.isEmpty() == false)
{
discoMover = a.pop();
Console.WriteLine("Moviendo disco de tamaño " + discoMover.Valor.ToString() + " de " + a.Nombre + " a " + b.Nombre);
if (discoMover.Valor != 0)
{
b.push(discoMover);
}
return;
}
// Compruebo si a esta vacia o si a tiene un disco de mayor tamaño que b (todas estas condiciones requieren que b no este vacia)
else if (a.isEmpty() || a.Top > b.Top && b.isEmpty() == false)
{
discoMover = b.pop();
Console.WriteLine("Moviendo disco de tamaño " + discoMover.Valor.ToString() + " de " + b.Nombre + " a " + a.Nombre);
if (discoMover.Valor != 0)
{
a.push(discoMover);
}
return;
}
}
//implementem el mover_disco()
public void mover_disco(Pila a, Pila b)
{
Disco d;
//si el disco de dalt de la pila a és més xicotet que el de la pila b; o la pila b està buida;
//i si la pila a conté discos:
if (((a.Top < b.Top) || (b.isEmpty() == true)) && (a.isEmpty() == false))
{
//si hi ha disco, que l'agafe de dalt de a i l'afegisca a la pila b.
d = a.pop();
if (d != null)
{
b.push(d);
}
}
//si no: si hi ha, que agafe el disco de dalt de b i l'afegisca a la pila a.
else
{
d = b.pop();
if (d != null)
{
a.push(d);
}
}
}
/*TODO: Implementar métodos*/
public void mover_disco(Pila a, Pila b)
{
Disco aux;
aux = a.pop();
b.push(aux);
}
static void Main(string[] args)
{
Pila INI = new Pila();
Pila AUX = new Pila();
Pila FIN = new Pila();
Console.WriteLine("¿Con cuantos discos deseas jugar?");
int numeroDiscos = Convert.ToInt32(Console.ReadLine());
for (int i = 0; i < numeroDiscos; i++)
{
Disco d = new Disco();
d.Valor = i + 1;
INI.push(d);
INI.Top = d.Valor;
}
Console.WriteLine("Inicio.");
Hanoi hanoi = new Hanoi();
hanoi.iterativo(numeroDiscos, INI, AUX, FIN);
Console.WriteLine("Inicio Algoritmo.");
hanoi.recursivo(numeroDiscos, INI, AUX, FIN);
Console.WriteLine("Presione cualquier tecla para salir.");
Console.ReadKey();
}
static void Main(string[] args)
{
Pila ini = new Pila();
Pila aux = new Pila();
Pila fin = new Pila();
// Keep the console window open in debug mode.
Console.WriteLine("Indique el número de discos que va a utilizar: ");
string key = Console.ReadLine();
int cuantos = 0;
while (!Int32.TryParse(key, out cuantos) || Int32.Parse(key) < 0)
{
Console.WriteLine("Inténtelo de nuevo");
key = Console.ReadLine();
}
for (int i = cuantos; i > 0; i--)
{
Disco disco = new Disco();
disco.Valor = i;
ini.push(disco);
}
int pasos = Hanoi.iterativo(cuantos, ini, fin, aux);
int pasosRecursivo = Hanoi.recursivo(cuantos, ini, aux, fin);
Console.WriteLine("-----------------------------------");
Console.WriteLine("Pasos realizados con iterativo: " + pasos);
Console.WriteLine("Pasos realizados con recursivo: " + pasosRecursivo);
Console.WriteLine("Pasos mínimos: " + (Math.Pow(2, cuantos) - 1));
Console.WriteLine("-----------------------------------");
}
//TODO: Implementar métodos
public void mover_disco(Pila a, Pila b)
{
//si hay algun disco en la pila
if (a.isEmpty().Equals(false)) // si en la a pila hay algun disco
{
if (b.isEmpty().Equals(true)) //se observa tambien si en la pila b hay alguno
{
Disco disco = a.pop(); //lo quitamos de la pila a
b.push(disco); //y a continuacion lo ponemos en b
}
else //si no se da el caso anterior
{
if (a.Top > b.Top) // si el ultimo disco de la pila a > ultimo disco de la pila b
{
Disco disco = b.pop(); //se quita en b
a.push(disco); //se anyade en a
}
else
{
Disco disco = a.pop(); //se quita de a
b.push(disco); //se pone en b
}
}
}
else if (b.isEmpty().Equals(false)) //en la pila b esta llena
{
if (a.isEmpty().Equals(true)) //y en la pila a esta vacia
{
Disco disco = b.pop(); //cambiamos de la pila b a la a el disco
a.push(disco);
}
else//igual que en el caso anterior coprobamos si el disco de mas arriba es mayor al disco de a
{
if (b.Top > a.Top)
{
Disco disco = a.pop();
b.push(disco);
}
else
{
Disco disco = b.pop();
a.push(disco);
}
}
}
}
/*TODO: Implementar métodos*/
public static void mover_disco(Pila a, Pila b)
{
Disco discoMover = new Disco();
if (a.isEmpty())
{
discoMover = b.pop();
Console.WriteLine("Moviendo disco " + discoMover.Valor + " de B a A");
if (discoMover.Valor != 0)
{
a.push(discoMover);
}
return;
}
else if (b.isEmpty())
{
discoMover = a.pop();
Console.WriteLine("Moviendo disco " + discoMover.Valor + " de A a B");
if (discoMover.Valor != 0)
{
b.push(discoMover);
}
return;
}
else if (a.Top > b.Top)
{
discoMover = b.pop();
Console.WriteLine("Moviendo disco " + discoMover.Valor + " de B a A");
if (discoMover.Valor != 0)
{
a.push(discoMover);
}
return;
}
else if (b.Top > a.Top)
{
discoMover = a.pop();
Console.WriteLine("Moviendo disco " + discoMover.Valor + " de A a B");
if (discoMover.Valor != 0)
{
b.push(discoMover);
}
return;
}
}
private void AccColaRecursiva(int delimitador, ref Pila ini, ref Pila fin, ref Pila aux, ref int contador, int iteracio)
{
if (delimitador == iteracio)
{
Disco disco = ini.pop();
fin.push(disco);
contador++;
}
else
{
this.AccColaRecursiva(delimitador, ref ini, ref aux, ref fin, ref contador, iteracio + 1);
Disco disco = ini.pop();
fin.push(disco);
contador++;
this.AccColaRecursiva(delimitador, ref aux, ref fin, ref ini, ref contador, iteracio + 1);
}
}
static void Main(string[] args)
{
//==============================================================================
//Inicializamos las pilas
//==============================================================================
Pila ini = new Pila();
Pila aux = new Pila();
Pila fin = new Pila();
//==============================================================================
//Preguntamos al usuario
//==============================================================================
Console.WriteLine(" Indique el número de discos que va a utilizar: ");
string key = Console.ReadLine();
int cuantos = 0;
while (!Int32.TryParse(key, out cuantos) || Int32.Parse(key) < 0)
{
Console.WriteLine("Inténtelo de nuevo");
key = Console.ReadLine();
}
for (int i = cuantos; i > 0; i--)
{
Disco disco = new Disco(); //Crea un disco vacio
disco.Valor = i; //Le asigna el valor o el tanyo al disco creado
ini.push(disco); //Mete el disco creado en la pila inicial
}
//==============================================================================
//Llamamos a la clase Hanoi y guardamos los movimientos
//==============================================================================
int movimientos = Hanoi.iterativo(cuantos, ini, fin, aux);
int movimientosRecursivo = Hanoi.recursivo(cuantos, ini, fin, aux);
Console.WriteLine(" Movimientos realizados iterativo = " + movimientos);
Console.WriteLine(" Movimientos realizados recursivo = " + movimientosRecursivo);
//==============================================================================
//Calculo de la formula de movimientos minimos
//==============================================================================
Console.WriteLine(" Minimo numero de movimientos = " + (Math.Pow(2, cuantos) - 1));
}
static void Main(string[] args)
{
Disco peque = new Disco(1);
Disco medio = new Disco(2);
Disco grande = new Disco(3);
Pila ini = new Pila();
ini.push(grande);
ini.push(medio);
ini.push(peque);
Pila aux = new Pila();
Pila fin = new Pila();
Hanoi nuevoHanoi = new Hanoi();
//ini-->fin
//ini-->aux
//fin-->aux
//ini-->fin
//aux-->ini
//aux-->fin
//ini-->fin
var res = nuevoHanoi.iterativo(7, ini, aux, fin);
Console.WriteLine(res);
var resultado0 = ini.peek();
Console.WriteLine(resultado0);
var resultado1 = aux.peek();
Console.WriteLine(resultado1);
var resultado2 = fin.peek();
Console.WriteLine(resultado2);
// Keep the console window open in debug mode.
Console.WriteLine("Press any key to exit.");
Console.ReadKey();
}
public void mover_disco(Pila a, Pila b)
{
if (a.Top < b.Top)
{
b.push(a.pop());
}
else if (a.Top > b.Top)
{
a.push(b.pop());
}
}
public int recursivo(int n, Pila ini, Pila fin, Pila aux)
{
int m = 0;
if (n == 1)
{
Disco inter;
inter = ini.pop();
fin.push(inter);
m++;
}
else
{
m += recursivo(n - 1, ini, aux, fin);
Disco inter = ini.pop();
fin.push(inter);
m++;
m += recursivo(n - 1, aux, fin, ini);
}
return(m);
}
public int recursivo(int delimitador, ref Pila ini, ref Pila fin, ref Pila aux)
{
int contador = 0;
if (delimitador == 1)
{
Disco disco = ini.pop();
fin.push(disco);
contador++;
}
else
{
contador = contador + this.recursivo(delimitador - 1, ref ini, ref aux, ref fin);
Disco disco = ini.pop();
fin.push(disco);
contador++;
contador = contador + this.recursivo(delimitador - 1, ref aux, ref fin, ref ini);
}
return(contador);
}
public void mover_disco(Pila a, Pila b)
{
if (a.isEmpty() && !b.isEmpty())
{
// mover de B a A
Disco dB = b.pop(); //quitar de B
a.push(dB); // poner en A
Console.WriteLine("Se mueve: " + dB.Valor + " de " + b.Nombre + " a " + a.Nombre);
}
else if (!a.isEmpty() && b.isEmpty())
{
// mover de A a B
Disco dA = a.pop(); //quitar de A
b.push(dA); // poner en B
Console.WriteLine("Se mueve: " + dA.Valor + " de " + a.Nombre + " a " + b.Nombre);
}
else
{
int topA = a.Top;
int topB = b.Top;
if (topA > topB)
{
// si a tiene una ficha mas grande se tendrá que mover de B a A
// mover de B a A
Disco dB = b.pop(); //quitar de B
a.push(dB); // poner en A
Console.WriteLine("Se mueve: " + dB.Valor + " de " + b.Nombre + " a " + a.Nombre);
}
else
{
// mover de A a B
Disco dA = a.pop(); //quitar de A
b.push(dA); // poner en B
Console.WriteLine("Se mueve: " + dA.Valor + " de " + a.Nombre + " a " + b.Nombre);
}
}
}
/*TODO: Implementar métodos*/
public void mover_disco(Pila a, Pila b)
{
//por si hay una pila vacia
if (a.isEmpty() && b.Top != 0)
{
Disco discoMovido = b.pop();
a.push(discoMovido);
//Console.WriteLine("discoMovido" + discoMovido.Valor);
Console.WriteLine("MOVIMIENTO -->Disco movido con valor --> " + discoMovido.Valor);
}
else if (!a.isEmpty() && b.isEmpty())
{
Disco discoMovido = a.pop();
b.push(discoMovido);
Console.WriteLine("MOVIMIENTO -->Disco movido con valor --> " + discoMovido.Valor);
}
else
{
//por si estan las dos llenas se realiza una comparación
int inicio = a.Top;
int final = b.Top;
if (inicio > final)
{
//de b a a
Disco discoMovido = b.pop();
a.push(discoMovido);
Console.WriteLine("MOVIMIENTO -->Disco movido con valor --> " + discoMovido.Valor);
}
else
{
//de a a b
Disco discoMovido = a.pop();
b.push(discoMovido);
Console.WriteLine("MOVIMIENTO -->Disco movido con valor --> " + discoMovido.Valor);
}
}
}
/*Implementación de metodos*/
public void mover_disco(Pila a, Pila b)
{
if ((a.Top > b.Top || a.Top == 0) && b.Top != 0)
{
a.push(b.pop());
direccion = 1;
}
else if ((b.Top > a.Top || b.Top == 0) && a.Top != 0)
{
b.push(a.pop());
direccion = 2;
}
m++;
}
static void Main(string[] args)
{
Console.WriteLine("Introduzca la cantidad de discos:");
int valorNumerico;
String numeroDiscos = Console.ReadLine().ToString();
while (!Int32.TryParse(numeroDiscos.ToString(), out valorNumerico) || valorNumerico <= 0)
{
Console.WriteLine("Introduzca la cantidad de discos,el número ha de ser mayor a 0:");
numeroDiscos = Console.ReadLine().ToString();
}
Pila ini = new Pila();
Pila aux = new Pila();
Pila fin = new Pila();
for (int i = valorNumerico; i > 0; i--)
{
Disco d = new Disco();
d.Valor = i;
ini.push(d);
}
Hanoi hanoi = new Hanoi();
Console.WriteLine("Seleccione la opcion para resolver la torre\na)Iterativo\nb)Recursivo");
ConsoleKey tecla = Console.ReadKey().Key;
while (tecla != ConsoleKey.A && tecla != ConsoleKey.B)
{
Console.WriteLine("\nSeleccione la opcion para resolver la torre\na)Iterativo\nb)Recursivo");
tecla = Console.ReadKey().Key;
}
if (tecla == ConsoleKey.A)
{
Console.WriteLine("\nIterativo: Movimientos realizados: " + hanoi.iterativo(valorNumerico, ini, fin, aux));
}
else if (tecla == ConsoleKey.B)
{
Console.WriteLine("\nRecursivo: Movimientos realizados: " + hanoi.algoritmoRecursivo(valorNumerico, ini, fin, aux));
}
Console.WriteLine("Mínimo de movimientos: " + (Math.Pow(2, valorNumerico) - 1));
Console.WriteLine("Torre Fin -> " + fin.toString());
Console.WriteLine("Press any key to exit.");
Console.ReadKey();
}
int movimientos = 0; // Variable global movimientos inicializada en 0 que almacena la cantidad de movimientos que se realiza
public void mover_disco(Pila a, Pila b) // Método mover_disco que se le pasan dos pilas que es a las que se va a hacer el movimiento
{
if (a.Top < b.Top) // Si el disco superior de la pila a es menor que el de la b el movimiento se hace de a a b
{
Disco d = a.pop();
b.push(d); // Aquí se hace el movimiento con los métodos push y pop de la clase pila
Console.WriteLine("El disco " + d.valor + " se mueve de la " + a.nombre + " a la " + b.nombre);
}
else // En caso de que el disco superior de b sea menor que el de a, el movimiento se hace de la pila a b la pila a
{
Disco d = b.pop();
a.push(d); // Aquí se hace el movimiento con los métodos push y pop de la clase pila
Console.WriteLine("El disco " + d.valor + " se mueve de la " + b.nombre + " a la " + a.nombre);
}
}
public void mover_disco(Pila a, Pila b)
{
bool mov_a_b;
bool mov_b_a;
if (b.isEmpty() == true)
{
mov_b_a = false;
mov_a_b = true;
Console.WriteLine("Muevo el disco " + a.Top + " desde " + a.Name + " hasta " + b.Name);
}
else if (a.isEmpty() == true)
{
mov_a_b = false;
mov_b_a = true;
Console.WriteLine("Muevo el disco " + b.Top + " desde " + b.Name + " hasta " + a.Name);
}
else if (a.Top < b.Top && b.isEmpty() == false)
{
mov_b_a = false;
mov_a_b = true;
Console.WriteLine("Muevo el disco " + a.Top + " desde " + a.Name + " hasta " + b.Name);
}
else if (a.Top > b.Top && a.isEmpty() == false)
{
mov_a_b = false;
mov_b_a = true;
Console.WriteLine("Muevo el disco " + b.Top + " desde " + b.Name + " hasta " + a.Name);
}
else
{
mov_b_a = false;
mov_a_b = false;
Console.WriteLine("No Puedo mover");
}
if (mov_a_b == true && mov_b_a == false)
{
b.push(a.Elementos[a.Size - 1]);
a.pop();
}
else if (mov_b_a == true && mov_a_b == false)
{
a.push(b.Elementos[b.Size - 1]);
b.pop();
}
}
