/*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
}
}
}
}
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);
}
}
/*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);
}
}
}
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 (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");
}
}
}
//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);
}
}
}
//==============================================================================
// 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)
{//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 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)
{
Disco aux;
aux = a.pop();
b.push(aux);
}
//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)
{
if(b.isEmpty(){
b[0]=a[a.getSize()-1];
a.pop();
}
else if(a[a.getSize()-1].getValor() < b[b.getSize()-1].getValor(){
b[b.getSize()-1]=a[a.getSize()-1];
a.pop();
}
else{
return 0;
}
}
/*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 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;
}
}
public void registrarMovimiento(Pila a, Pila b)
{
Disco tmp = a.pop();
Console.WriteLine("Se ha movido el disco: " + tmp.Valor);
b.push(tmp);
}
//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);
}
}
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++;
}
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();
}
}
/*TODO: Implementar métodos*/
public void mover_disco(Pila a, Pila b)
{
if (a.Top > b.Top)
{
Disco disco = b.Elementos[b.Size];
b.pop();
a.push(disco);
}
else
{
Disco disco = a.Elementos[a.Size];
a.pop();
b.push(disco);
}
}
/*TODO: Implementar métodos*/
public void mover_disco(Pila a, Pila b)
{
if (a.peek() != 99)//si es 99 la pila esta vacia
{
Disco movido = a.pop();
b.push(movido);
}
else
{
if (b.peek() != 99)//si es 99 la pila esta vacia
{
Disco movido = b.pop();
a.push(movido);
}
}
}//mover_disco
/*TODO: Implementar métodos*/
public void mover_disco(Pila a, Pila b)
{
Disco discoAux = new Disco();
if (pilaFIN.getNumDiscos() != n || pilaAUX.getNumDiscos() != n)
{
if (comprobarMovimiento(a, b).Equals("C"))
{
return;
}
if (comprobarMovimiento(a, b).Equals("A"))
{
discoAux = a.pop();
b.push(discoAux);
numMovimientos++;
}
else
{
discoAux = b.pop();
a.push(discoAux);
numMovimientos++;
}
}
}
static void Main(string[] args)
{
Pila ini = new Pila();
Pila aux = new Pila();
Pila fin = new Pila();
Hanoi juego = new Hanoi();
//Número de discos con los que se va a jugar
int numero = 3;
Console.WriteLine("********************************************************************************");
Console.WriteLine(" ALGORITMO ITERATIVO");
Console.WriteLine("********************************************************************************");
int movimientos = juego.iterativo(numero, ini, fin, aux);
Console.WriteLine("El número de movimientos es: " + movimientos + ".");
if (movimientos == Math.Pow(2, numero) - 1)
{
Console.WriteLine("El juego es correcto.");
}
Console.WriteLine();
//Una vez terminado el algoritmo iterativo, borro los discos introducidos en
//la pila final para volver a reutilizarla antes de empezar el siguiente algoritmo
for (int i = numero; i > 0; i--)
{
fin.pop();
}
Console.WriteLine("********************************************************************************");
Console.WriteLine(" ALGORITMO RECURSIVO");
Console.WriteLine("********************************************************************************");
//Creación e introducción de los discos en la pila inicial
for (int i = numero; i > 0; i--)
{
ini.push(new Disco(i));
}
//Imprimir los elementos del disco
for (int i = 0; i <= ini.Elementos.Count - 1; i++)
{
Console.WriteLine("Valores de los discos en la pila ini[" + i + "]: " + ini.Elementos[i].Valor);
}
Console.WriteLine();
Console.WriteLine("Número de discos en las pilas => INI: " + ini.Size + " AUX: " + aux.Size + " FIN: " + fin.Size);
Console.WriteLine("TOP en las pilas => INI: " + ini.Top + " AUX: " + aux.Top + " FIN: " + fin.Top);
Console.WriteLine();
Console.WriteLine("EMPIEZA EL JUEGO");
int movimientosR = juego.recursivo(numero, ini, fin, aux);
Console.WriteLine("________________________________________________________________________________");
Console.WriteLine("El número de movimientos es: " + movimientosR + ".");
if (movimientosR == Math.Pow(2, numero) - 1)
{
Console.WriteLine("El juego es correcto.");
}
// Keep the console window open in debug mode.
Console.WriteLine("Press any key to exit.");
Console.ReadKey();
}
