public static int iterativo(int n, Pila ini, Pila fin, Pila aux)
{
int m = 0; //M es igual al numero de movimientos realizados
//==============================================================================
// Si n no es par
//==============================================================================
if (n % 2 != 0)
{
while (fin.Size != n)
{
mover_disco(ini, fin);
m++;
if (fin.Size == n)
{
break;
}
mover_disco(ini, aux);
m++;
if (fin.Size == n)
{
break;
}
mover_disco(aux, fin);
m++;
if (fin.Size == n)
{
break;
}
}
}
//==============================================================================
// Si n es par
//==============================================================================
else
{
while (fin.Size != n)
{
mover_disco(ini, aux);
m++;
if (fin.Size == n)
{
break;
}
mover_disco(ini, fin);
m++;
if (fin.Size == n)
{
break;
}
mover_disco(aux, fin);
m++;
if (fin.Size == n)
{
break;
}
}
}
return(m);
}
public int iterativo(int n, Pila ini, Pila fin, Pila aux)
{
return(0);
}
static TestHanoi()
{
Hanoi hanoi = new Hanoi();
/*---------------------------------------------*/
/* TESTING:
* de pila_A (plena) a Pila_B (buida)
* amb move_disco(pila_A, pila_B ) */
/*---------------------------------------------*/
Console.WriteLine(" =================================================================================================");
Console.WriteLine(" de pila_A (plena) a Pila_B (buida) amb move_disco(pila_A, pila_B )");
Pila pila_A = new Pila();
Pila pila_B = new Pila();
Disco disco_1 = new Disco();
disco_1.ValorInt = 1;
Disco disco_2 = new Disco();
disco_2.ValorInt = 2;
Disco disco_3 = new Disco();
disco_3.ValorInt = 3;
pila_A.push(disco_3);
pila_A.push(disco_2);
pila_A.push(disco_1);
int loop = pila_A.Size;
for (int i = 0; i < loop; i++)
{
Console.WriteLine("");
Console.Write("Abans de menejar ");
Console.Write(" Top Pila_A: " + pila_A.Top.ToString());
Console.WriteLine(" Top Pila_B: " + pila_B.Top.ToString());
foreach (Disco element in pila_A.Elementos)
{
Console.WriteLine(" En Pila A " + element.ValorInt.ToString());
}
Console.WriteLine("...........");
foreach (Disco element in pila_B.Elementos)
{
Console.WriteLine(" En Pila B " + element.ValorInt.ToString());
}
Console.WriteLine(" "); Console.WriteLine(" ");
hanoi.mover_disco(ref pila_A, ref pila_B);
Console.Write("Despres de menejar ");
Console.Write(" Top Pila_A: " + pila_A.Top.ToString());
Console.WriteLine(" Top Pila_B: " + pila_B.Top.ToString());
foreach (Disco element in pila_A.Elementos)
{
Console.WriteLine(" En Pila A " + element.ValorInt.ToString());
}
Console.WriteLine("...........");
foreach (Disco element in pila_B.Elementos)
{
Console.WriteLine(" En Pila B " + element.ValorInt.ToString());
}
Console.WriteLine(" "); Console.WriteLine(" ");
Console.WriteLine("Següent iteració");
}
Console.WriteLine();
Console.WriteLine("XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX");
Console.WriteLine("····························································");
Console.WriteLine("XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX");
Console.WriteLine(" "); Console.WriteLine(" ");
/*---------------------------------------------*/
/* TESTING:
* de pila_A (plena) a Pila_B (buida)
* amb move_disco(pila_B, pila_A ) */
/*---------------------------------------------*/
Console.WriteLine(" =================================================================================================");
Console.WriteLine(" de pila_A (plena) a Pila_B (buida) amb move_disco(pila_B, pila_A )");
for (int i = 0; i < loop; i++)
{
Console.WriteLine("");
Console.Write("Abans de menejar ");
Console.Write(" Top Pila_A: " + pila_A.Top.ToString());
Console.WriteLine(" Top Pila_B: " + pila_B.Top.ToString());
foreach (Disco element in pila_A.Elementos)
{
Console.WriteLine(" En Pila A " + element.ValorInt.ToString());
}
Console.WriteLine("...........");
foreach (Disco element in pila_B.Elementos)
{
Console.WriteLine(" En Pila B " + element.ValorInt.ToString());
}
hanoi.mover_disco(ref pila_B, ref pila_A);
Console.Write("Despres de menejar ");
Console.Write(" Top Pila_A: " + pila_A.Top.ToString());
Console.WriteLine(" Top Pila_B: " + pila_B.Top.ToString());
foreach (Disco element in pila_A.Elementos)
{
Console.WriteLine(" En Pila A " + element.ValorInt.ToString());
}
Console.WriteLine("...........");
foreach (Disco element in pila_B.Elementos)
{
Console.WriteLine(" En Pila B " + element.ValorInt.ToString());
}
Console.WriteLine(" "); Console.WriteLine(" ");
Console.WriteLine("Següent iteració");
}
Console.WriteLine();
Console.WriteLine("XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX");
Console.WriteLine("····························································");
Console.WriteLine("XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX");
Console.WriteLine(" "); Console.WriteLine(" ");
/*---------------------------------------------*/
/* TESTING:
* iterativo(int n, Pila ini, Pila fin, Pila aux) amb n = 3 */
/*---------------------------------------------*/
Console.WriteLine(" =================================================================================================");
Console.WriteLine(" iterativo(int n, Pila ini, Pila fin, Pila aux) amb n = 3");
Pila pila_C = new Pila();
int passos;
Console.WriteLine("Abans d'executarXXXXXXXXXXXXXXXXXXXXXXXX");
Console.WriteLine("........................ ");
Console.WriteLine("Elements en la pila ini");
foreach (Disco Element in pila_A.Elementos)
{
Console.WriteLine(" " + Element.ValorInt.ToString());
}
Console.WriteLine("........................ ");
Console.WriteLine("Elements en la pila aux");
foreach (Disco Element in pila_B.Elementos)
{
Console.WriteLine(" " + Element.ValorInt.ToString());
}
Console.WriteLine("........................ ");
Console.WriteLine("Elements en la pila fin");
foreach (Disco Element in pila_C.Elementos)
{
Console.WriteLine(" " + Element.ValorInt.ToString());
}
Console.WriteLine(" "); Console.WriteLine(" ");
passos = hanoi.iterativo(pila_A.Size, ref pila_A, ref pila_C, ref pila_B);
Console.WriteLine("Despprés d'executar XXXXXXXXXXXXXXXXXXXXXXXX");
Console.WriteLine("........................ ");
Console.WriteLine("Elements en la pila ini");
foreach (Disco Element in pila_A.Elementos)
{
Console.WriteLine(" " + Element.ValorInt.ToString());
}
Console.WriteLine("........................ ");
Console.WriteLine("Elements en la pila aux");
foreach (Disco Element in pila_B.Elementos)
{
Console.WriteLine(" " + Element.ValorInt.ToString());
}
Console.WriteLine("........................ ");
Console.WriteLine("Elements en la pila fin");
foreach (Disco Element in pila_C.Elementos)
{
Console.WriteLine(" " + Element.ValorInt.ToString());
}
Console.WriteLine(" "); Console.WriteLine(" ");
Console.WriteLine(" El número de passos calculat per iteració son: " + passos.ToString());
Console.WriteLine("XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX");
Console.WriteLine("····························································");
Console.WriteLine("XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX");
Console.WriteLine(" "); Console.WriteLine(" ");
/*---------------------------------------------*/
/* TESTING:
* iterativo(int n, Pila ini, Pila fin, Pila aux) amb n = 4 */
/*---------------------------------------------*/
Console.WriteLine(" =================================================================================================");
Console.WriteLine(" iterativo(int n, Pila ini, Pila fin, Pila aux) amb n = 4");
Pila pila_ini = new Pila();
Pila pila_fin = new Pila();
Pila pila_aux = new Pila();
Disco disco_10 = new Disco();
disco_10.ValorInt = 1;
Disco disco_20 = new Disco();
disco_20.ValorInt = 2;
Disco disco_30 = new Disco();
disco_30.ValorInt = 3;
Disco disco_40 = new Disco();
disco_40.ValorInt = 4;
pila_ini.push(disco_40);
pila_ini.push(disco_30);
pila_ini.push(disco_20);
pila_ini.push(disco_10);
Console.WriteLine("Abans d'executarXXXXXXXXXXXXXXXXXXXXXXXX");
Console.WriteLine("........................ ");
Console.WriteLine("Elements en la pila ini");
foreach (Disco Element in pila_ini.Elementos)
{
Console.WriteLine(" " + Element.ValorInt.ToString());
}
Console.WriteLine("........................ ");
Console.WriteLine("Elements en la pila aux");
foreach (Disco Element in pila_aux.Elementos)
{
Console.WriteLine(" " + Element.ValorInt.ToString());
}
Console.WriteLine("........................ ");
Console.WriteLine("Elements en la pila fin");
foreach (Disco Element in pila_fin.Elementos)
{
Console.WriteLine(" " + Element.ValorInt.ToString());
}
Console.WriteLine(" "); Console.WriteLine(" ");
passos = hanoi.iterativo(pila_ini.Size, ref pila_ini, ref pila_fin, ref pila_aux);
Console.WriteLine("Despprés d'executar XXXXXXXXXXXXXXXXXXXXXXXX");
Console.WriteLine("........................ ");
Console.WriteLine("Elements en la pila ini");
foreach (Disco Element in pila_ini.Elementos)
{
Console.WriteLine(" " + Element.ValorInt.ToString());
}
Console.WriteLine("........................ ");
Console.WriteLine("Elements en la pila aux");
foreach (Disco Element in pila_aux.Elementos)
{
Console.WriteLine(" " + Element.ValorInt.ToString());
}
Console.WriteLine("........................ ");
Console.WriteLine("Elements en la pila fin");
foreach (Disco Element in pila_fin.Elementos)
{
Console.WriteLine(" " + Element.ValorInt.ToString());
}
Console.WriteLine(" "); Console.WriteLine(" ");
Console.WriteLine(" El número de passos calculat per iteració son: " + passos.ToString());
Console.WriteLine("XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX");
Console.WriteLine("····························································");
Console.WriteLine("XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX");
Console.WriteLine(" "); Console.WriteLine(" ");
/*---------------------------------------------*/
/* TESTING:
* recursivo(int n, Pila ini, Pila fin, Pila aux) amb n = 4 */
/*---------------------------------------------*/
Console.WriteLine(" =================================================================================================");
Console.WriteLine(" recursivo(int n, Pila ini, Pila fin, Pila aux) amb n = 4");
Pila ini = new Pila();
Pila fin = new Pila();
Pila aux = new Pila();
ini.push(disco_40);
ini.push(disco_30);
ini.push(disco_20);
ini.push(disco_10);
Console.WriteLine("Abans d'executarXXXXXXXXXXXXXXXXXXXXXXXX");
Console.WriteLine("........................ ");
Console.WriteLine("Elements en la pila ini");
foreach (Disco Element in ini.Elementos)
{
Console.WriteLine(" " + Element.ValorInt.ToString());
}
Console.WriteLine("........................ ");
Console.WriteLine("Elements en la pila aux");
foreach (Disco Element in aux.Elementos)
{
Console.WriteLine(" " + Element.ValorInt.ToString());
}
Console.WriteLine("........................ ");
Console.WriteLine("Elements en la pila fin");
foreach (Disco Element in fin.Elementos)
{
Console.WriteLine(" " + Element.ValorInt.ToString());
}
Console.WriteLine(" "); Console.WriteLine(" ");
passos = hanoi.recursivo(ini.Size, ref ini, ref fin, ref aux);
Console.WriteLine("Despprés d'executar XXXXXXXXXXXXXXXXXXXXXXXX");
Console.WriteLine("........................ ");
Console.WriteLine("Elements en la pila ini");
foreach (Disco Element in ini.Elementos)
{
Console.WriteLine(" " + Element.ValorInt.ToString());
}
Console.WriteLine("........................ ");
Console.WriteLine("Elements en la pila aux");
foreach (Disco Element in aux.Elementos)
{
Console.WriteLine(" " + Element.ValorInt.ToString());
}
Console.WriteLine("........................ ");
Console.WriteLine("Elements en la pila fin");
foreach (Disco Element in fin.Elementos)
{
Console.WriteLine(" " + Element.ValorInt.ToString());
}
Console.WriteLine(" "); Console.WriteLine(" ");
Console.WriteLine(" El número de passos calculat per recursivitat son: " + passos.ToString());
Console.WriteLine("XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX");
Console.WriteLine("····························································");
Console.WriteLine("XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX");
Console.WriteLine(" "); Console.WriteLine(" ");
/*---------------------------------------------*/
/* TESTING:
* colaRecursiva(int n, Pila ini, Pila fin, Pila aux) amb n = 4 */
/*---------------------------------------------*/
Console.WriteLine(" =================================================================================================");
Console.WriteLine(" colaRecursivo(int n, Pila ini, Pila fin, Pila aux) amb n = 4");
Pila ini_1 = new Pila();
Pila fin_1 = new Pila();
Pila aux_1 = new Pila();
ini_1.push(disco_40);
ini_1.push(disco_30);
ini_1.push(disco_20);
ini_1.push(disco_10);
Console.WriteLine("Abans d'executarXXXXXXXXXXXXXXXXXXXXXXXX");
Console.WriteLine("........................ ");
Console.WriteLine("Elements en la pila ini_1");
foreach (Disco Element in ini_1.Elementos)
{
Console.WriteLine(" " + Element.ValorInt.ToString());
}
Console.WriteLine("........................ ");
Console.WriteLine("Elements en la pila aux_1");
foreach (Disco Element in aux_1.Elementos)
{
Console.WriteLine(" " + Element.ValorInt.ToString());
}
Console.WriteLine("........................ ");
Console.WriteLine("Elements en la pila fin_1");
foreach (Disco Element in fin_1.Elementos)
{
Console.WriteLine(" " + Element.ValorInt.ToString());
}
Console.WriteLine(" "); Console.WriteLine(" ");
passos = hanoi.colaRecursiva(ini_1.Size, ref ini_1, ref fin_1, ref aux_1);
Console.WriteLine("Despprés d'executar XXXXXXXXXXXXXXXXXXXXXXXX");
Console.WriteLine("........................ ");
Console.WriteLine("Elements en la pila ini_1");
foreach (Disco Element in ini_1.Elementos)
{
Console.WriteLine(" " + Element.ValorInt.ToString());
}
Console.WriteLine("........................ ");
Console.WriteLine("Elements en la pila aux_1");
foreach (Disco Element in aux_1.Elementos)
{
Console.WriteLine(" " + Element.ValorInt.ToString());
}
Console.WriteLine("........................ ");
Console.WriteLine("Elements en la pila fin_1");
foreach (Disco Element in fin_1.Elementos)
{
Console.WriteLine(" " + Element.ValorInt.ToString());
}
Console.WriteLine(" "); Console.WriteLine(" ");
Console.WriteLine(" El número de passos calculat per cola recursivitat son: " + passos.ToString());
Console.WriteLine("XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX");
Console.WriteLine("····························································");
Console.WriteLine("XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX");
Console.WriteLine(" "); Console.WriteLine(" ");
}
public ColaRecursiva(int n)
{
Hanoi hanoi = new Hanoi();
Pila ini = new Pila();
Pila fin = new Pila();
Pila aux = new Pila();
for (int i = n; i != 0; i--)
{
Disco disco = new Disco();
disco.ValorInt = i;
ini.push(disco);
}
Console.Write("Discos en pila ini: ");
foreach (Disco Elemento in ini.Elementos)
{
Console.Write(Elemento.ValorInt.ToString() + "; ");
}
Console.WriteLine("");
Console.Write("Discos en pila fin: ");
foreach (Disco Elemento in fin.Elementos)
{
Console.Write(Elemento.ValorInt.ToString() + "; ");
}
Console.WriteLine("");
Console.Write("Discos en pila aux: ");
foreach (Disco Elemento in aux.Elementos)
{
Console.Write(Elemento.ValorInt.ToString() + "; ");
}
Console.WriteLine("");
int movimientos = hanoi.colaRecursiva(n, ref ini, ref fin, ref aux);
Console.WriteLine("");
Console.WriteLine("Despues del cálculo las pilas quedan como:");
Console.WriteLine("");
Console.Write("Discos en pila ini: ");
foreach (Disco Elemento in ini.Elementos)
{
Console.Write(Elemento.ValorInt.ToString() + "; ");
}
Console.WriteLine("");
Console.Write("Discos en pila fin: ");
foreach (Disco Elemento in fin.Elementos)
{
Console.Write(Elemento.ValorInt.ToString() + "; ");
}
Console.WriteLine("");
Console.Write("Discos en pila aux: ");
foreach (Disco Elemento in aux.Elementos)
{
Console.Write(Elemento.ValorInt.ToString() + "; ");
}
Console.WriteLine(" ");
Console.WriteLine(" ");
Console.WriteLine("Utilizando recursividad por cola sale que la solución esta");
Console.WriteLine("Realizado con " + movimientos.ToString() + " movimientos.");
}
static void Main(string[] args)
{
/*
*
* Disco disco5 = new Disco(5);//inicializamos disco con valor 3
* Disco disco4 = new Disco(4);//inicializamos disco con valor 3
* Disco disco3 = new Disco(3);//inicializamos disco con valor 3
* Disco disco2 = new Disco(2);//inicializamos disco con valor 2
* Disco disco1 = new Disco(1);//inicializamos disco con valor 1
*
* //------------------------------------------------------------------------------------
* Pila ini = new Pila();//inicilizamos pila ini
* ini.nombre = "INI";//le ponemos un nombre a la pila
*
* Pila aux = new Pila();//inicializamos la pila aux
* aux.nombre = "AUX";//le ponemos un nombre a la pila
*
* Pila fin = new Pila();//inicializamos la pila fin
* fin.nombre = "FIN";//le ponemos un nombre a la pila
* //-------------------------------------------------------------------------------------
* ini.push(disco5);
* ini.push(disco4);
* ini.push(disco3);
* ini.push(disco2);
* ini.push(disco1);
* //-------------------------------------------------------------------------------------
* //NUMERO DE DISCOS
* int discos = 5;
*
*
* //Hanaoi()
* Hanoi sol = new Hanoi();
* //-------------------------------------------------------------------------------------
* //PRUEVA ITERATIVO
* //-------------------------------------------------------------------------------------
* int solucion = sol.recursivo(discos, ini, fin, aux);
* //-------------------------------------------------------------------------------------
*
* Console.WriteLine("Los movimientos finales son" + solucion);
* Console.WriteLine("la pila final:");
* fin.impr();
* Console.ReadKey();
*
*/
Console.WriteLine("¿Qué algoritmo prefieres utilizar? Pulsa 1 para usar el iterativo o 2 para usar el recursivo?");
int algoritmoUtilizado = Convert.ToInt32(Console.ReadLine());
Console.WriteLine("¿Cuántos discos quieres insertar?");
int numDiscos = Int32.Parse(Console.ReadLine());
List <Disco> discoFinales = new List <Disco>();
if (numDiscos == 0)
{
Console.WriteLine("¿Realmente quisiste escribir 0? Con el numero 0 es imposible de realizar.");
Console.ReadKey();
}
if (numDiscos < 0)
{
Console.WriteLine("¿Realmente quisiste escribir un número negativo? con un numero negativo no se puede, vuelva a intentarlo.");
Console.ReadKey();
}
if (numDiscos > 0)
{
Pila ini = new Pila();
Pila aux = new Pila();
Pila fin = new Pila();
for (int i = numDiscos; i > 0; i--)
{
//discoFinales.Add(new Disco(i));
ini.push(new Disco(i));
}
Hanoi torres_hanoi = new Hanoi();
if (algoritmoUtilizado == 1) // si penemos un 1 en pantalla
{
int sol = torres_hanoi.iterativo(numDiscos, ini, fin, aux); // Llamamos iterativo
Console.WriteLine(sol); // mostramos la sol
}
if (algoritmoUtilizado == 2) // Si la respuesta del usuario al principio es dos
{
int sol = torres_hanoi.recursivo(numDiscos, ini, fin, aux); // Llamamos recursivo
Console.WriteLine(sol); // mostramos la sol
}
if (algoritmoUtilizado > 2)
{
Console.WriteLine("No has introduciddo el numero correcto en el algoritmo");
}
Console.ReadKey();
}
}
public int iterativo(int n, Pila ini, Pila fin, Pila aux)
{
int movimientos = 0; //variable donde almaceno los movimientos hechos
bool solucion = false; //bool para salir del while o no
if (n % 2 == 0)
{ //si es par
while (solucion == false)
{ //mientras que no hay solucion
/*------- Movimientos + aumento contador ---------*/
movimientos++;
mover_disco(ini, aux);
Console.WriteLine("Mover de ini a aux");
movimientos++;
mover_disco(ini, fin);
Console.WriteLine("Mover de ini a fin");
movimientos++;
mover_disco(aux, fin);
Console.WriteLine("Mover de aux a fin");
/*------- FIN -> Movimientos + aumento contador ---------*/
if (fin.Size.Equals(n))
{
solucion = true;
}
}
}
else
{ //si es impar
while (solucion == false)
{
/*------- Movimientos + aumento contador ---------*/
mover_disco(ini, fin); //como es impar hacemos que el primer movimiento sea ini -> fin
Console.WriteLine("Mover de ini a fin");
movimientos++;
if (fin.Size.Equals(n)) //si coincide
{
solucion = true;
break; //salir bucle
}
mover_disco(ini, aux);
Console.WriteLine("Mover de ini a aux");
movimientos++;
mover_disco(aux, fin);
Console.WriteLine("Mover de aux a fin");
movimientos++;
/*------- FIN -> Movimientos + aumento contador ---------*/
if (fin.Size.Equals(n))
{
solucion = true;
}
}
}
return(movimientos);
}
/*
* n = numero de discos
* */
public int iterativo(int n, Pila ini, Pila fin, Pila aux)
{
int movimientos = 0;
bool haySolucion = false;
// si n es impar
if (n % 2 == 1)
{
while (!haySolucion)
{
mover_disco(ini, fin);
movimientos++;
haySolucion = comprobar_victoria(n, fin);
Console.WriteLine(ini.ToString());
Console.WriteLine(aux.ToString());
Console.WriteLine(fin.ToString());
if (haySolucion)
{
break;
}
mover_disco(ini, aux);
movimientos++;
haySolucion = comprobar_victoria(n, fin);
Console.WriteLine(ini.ToString());
Console.WriteLine(aux.ToString());
Console.WriteLine(fin.ToString());
if (haySolucion)
{
break;
}
mover_disco(aux, fin);
movimientos++;
haySolucion = comprobar_victoria(n, fin);
Console.WriteLine(ini.ToString());
Console.WriteLine(aux.ToString());
Console.WriteLine(fin.ToString());
if (haySolucion)
{
break;
}
}
}
// si n es par
else
{
while (!haySolucion)
{
mover_disco(ini, aux);
movimientos++;
haySolucion = comprobar_victoria(n, fin);
Console.WriteLine(ini.ToString());
Console.WriteLine(aux.ToString());
Console.WriteLine(fin.ToString());
if (haySolucion)
{
break;
}
mover_disco(ini, fin);
movimientos++;
haySolucion = comprobar_victoria(n, fin);
Console.WriteLine(ini.ToString());
Console.WriteLine(aux.ToString());
Console.WriteLine(fin.ToString());
if (haySolucion)
{
break;
}
mover_disco(aux, fin);
movimientos++;
haySolucion = comprobar_victoria(n, fin);
Console.WriteLine(ini.ToString());
Console.WriteLine(aux.ToString());
Console.WriteLine(fin.ToString());
if (haySolucion)
{
break;
}
}
}
return(movimientos);
}
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();
}
static void Main(string[] args)
{
bool numeroValido = false;
bool eleccionValida = false;
Console.WriteLine("Buenos días, elija una opción por favor por favor :)");
Console.WriteLine("Pulse 1 para utilizar el algoritmo iterativo");
Console.WriteLine("Pulse 2 para utilizar el algoritmo recursivo");
while (!eleccionValida)
{
try
{
int elección = Int32.Parse(Console.ReadLine());
while (!numeroValido)
{ //Este While comprueba que hayas introducido un número válido
try
{
if (elección == 1)
{
Console.WriteLine("Ingrese el número de discos");
int totalDiscos = Int32.Parse(Console.ReadLine());
int formula = (int)(Math.Pow(2, totalDiscos) - 1);
List <Disco> Elementos = new List <Disco>();
for (int i = totalDiscos; i > 0; i--)
{
Elementos.Add(new Disco(i));
}
Pila pilaIni = new Pila(Elementos);
Pila pilaAux = new Pila();
Pila pilaFin = new Pila();
Hanoi El_problema_de_hanoi = new Hanoi();
int numMovimientos = El_problema_de_hanoi.iterativo(totalDiscos, pilaIni, pilaFin, pilaAux);
Console.WriteLine("El problema con " + totalDiscos + " discos se ha resuelto en " + numMovimientos + " movimientos.");
if (numMovimientos == formula)
{
Console.WriteLine("El problema se ha resuelto bien :)");
}
else
{
Console.WriteLine("El problema se ha resuelto mal :(");
}
numeroValido = true; //Si todo va bien, salimos del while
Console.WriteLine("Pulse cualquier tecla para salir");
Console.ReadKey();
}
else if (elección == 2)
{
Console.WriteLine("Ingrese el número de discos");
int totalDiscos = Int32.Parse(Console.ReadLine());
int formula = (int)(Math.Pow(2, totalDiscos) - 1);
List <Disco> Elementos = new List <Disco>();
for (int i = totalDiscos; i > 0; i--)
{
Elementos.Add(new Disco(i));
}
Pila pilaIni = new Pila(Elementos);
Pila pilaAux = new Pila();
Pila pilaFin = new Pila();
Hanoi El_problema_de_hanoi = new Hanoi();
int numMovimientos = El_problema_de_hanoi.Recursivo(totalDiscos, pilaIni, pilaFin, pilaAux);
Console.WriteLine("El problema con " + totalDiscos + " discos se ha resuelto en " + numMovimientos + " movimientos.");
if (numMovimientos == formula)
{
Console.WriteLine("El problema se ha resuelto bien :)");
}
else
{
Console.WriteLine("El problema se ha resuelto mal :(");
}
numeroValido = true; //Si todo va bien, salimos del while
Console.WriteLine("Pulse cualquier tecla para salir");
Console.ReadKey();
}
else
{
Console.WriteLine("Muy gracioso, ingrese una elección válida");
elección = Int32.Parse(Console.ReadLine());
}
}
catch (Exception ex)
{
Console.WriteLine("Por favor, ingrese un número válido");
//Si ha ingresado un número negativo, o una tecla o cualquier otro símbolo volvemos a empezar
}
}
eleccionValida = true;
}
catch (Exception ex)
{
Console.WriteLine("Muy gracioso, ingrese una elección válida");
}
}
}
public static void rellenarPilaIni(Pila pilaIni, int n)
{
pilaIni.rellenarPila(n);
}
public int iterativo(int n, Pila ini, Pila fin, Pila aux)
{
int numero_movimientos = 0;
bool noSolucionado = true;
if (n % 2 != 0)
{
while (noSolucionado)
{
//Console.WriteLine("Inicio bucle ");
//Console.WriteLine("Size fin--> " +fin.Size);
// Console.WriteLine(noSolucionado);
mover_disco(ini, fin);
numero_movimientos++;
if (fin.Size == n)
{
noSolucionado = false;
break;
}
mover_disco(ini, aux);
numero_movimientos++;
if (fin.Size == n)
{
noSolucionado = false;
break;
}
mover_disco(aux, fin);
numero_movimientos++;
if (fin.Size == n)
{
noSolucionado = false;
break;
}
} //fin mientras
} //fin si
if (n % 2 == 0)
{
while (noSolucionado)
{
mover_disco(ini, aux);
numero_movimientos++;
if (fin.Size == n)
{
noSolucionado = false;
break;
}
mover_disco(ini, fin);
numero_movimientos++;
if (fin.Size == n)
{
noSolucionado = false;
break;
}
mover_disco(aux, fin);
numero_movimientos++;
if (fin.Size == n)
{
noSolucionado = false;
break;
}
} //fin mientras
} //fin si
return(numero_movimientos);
}
/*Iterativo*/
public int iterativo(int n, Pila ini, Pila fin, Pila aux)
{
if (n % 2 == 0)
{
while (fin.Size < n)
{
mover_disco(aux, ini);
/*Se muestra el movimiento por consola*/
if (direccion == 1)
{
Console.WriteLine("Se a movido el disco de ini a aux");
}
else
{
Console.WriteLine("Se a movido el disco de aux a ini");
}
/*---------------------------------------------------------------*/
mover_disco(ini, fin);
/*Se muestra el movimiento por consola*/
if (direccion == 1)
{
Console.WriteLine("Se a movido el disco de fin a ini");
}
else
{
Console.WriteLine("Se a movido el disco de ini a fin");
}
/*---------------------------------------------------------------*/
if (fin.Size == n)
{
return(m);
}
mover_disco(fin, aux);
/*Se muestra el movimiento por consola*/
if (direccion == 1)
{
Console.WriteLine("Se a movido el disco de aux a fin");
}
else
{
Console.WriteLine("Se a movido el disco de fin a aux");
}
/*---------------------------------------------------------------*/
if (fin.Size == n)
{
return(m);
}
}
}
if (n % 2 != 0 || n == 1)
{
while (fin.Size < n)
{
mover_disco(ini, fin);
/*Se muestra el movimiento por consola*/
if (direccion == 1)
{
Console.WriteLine("Se a movido el disco de fin a ini");
}
else
{
Console.WriteLine("Se a movido el disco de ini a fin");
}
/*---------------------------------------------------------------*/
if (fin.Size == n)
{
return(m);
}
mover_disco(ini, aux);
/*Se muestra el movimiento por consola*/
if (direccion == 1)
{
Console.WriteLine("Se a movido el disco de aux a ini");
}
else
{
Console.WriteLine("Se a movido el disco de ini a aux");
}
/*---------------------------------------------------------------*/
mover_disco(aux, fin);
/*Se muestra el movimiento por consola*/
if (direccion == 1)
{
Console.WriteLine("Se a movido el disco de fin a aux");
}
else
{
Console.WriteLine("Se a movido el disco de aux a fin");
}
/*---------------------------------------------------------------*/
if (fin.Size == n)
{
return(m);
}
}
}
return(m);
}
public int iterativo(int n, Pila ini, Pila fin, Pila aux)
{
bool seguirBucle = true;
if (n % 2 != 0)//para si son impares
{
Console.WriteLine(" ES IMPAR");
while (seguirBucle == true)//mientras que no esten todos en la ultima columna haz esto
{
if (fin.Size < n)
{
mover_disco(ini, fin); //movimiento de ini a fin
movimientos = movimientos + 1; //sumamos 1 movimiento
}
if (fin.Size < n)
{
mover_disco(ini, aux); //movimiento de ini a aux
movimientos = movimientos + 1; //sumamos 1 movimiento
}
if (fin.Size < n)
{
mover_disco(aux, fin); //movimiento de aux a fin
movimientos = movimientos + 1; //sumamos 1 movimient
}
if (fin.Size == n)
{
seguirBucle = false;//para para el while ya que seguir bucle es bool
}
}
}
else//el caso para cuando sean pares
{
Console.WriteLine("ES PAR");
while (seguirBucle == true)
{
if (fin.Size < n)
{
mover_disco(ini, aux); //movimiento de ini a aux
movimientos++; //sumamos 1 movimiento
}
if (fin.Size < n)
{
mover_disco(ini, fin); //movimiento de ini a fin
movimientos++; //sumamos 1 movimiento
}
if (fin.Size < n)
{
mover_disco(aux, fin); //movimiento de aux a fin
movimientos++; //sumamos 1 movimiento
}
if (fin.Size == n)
{
seguirBucle = false;
}
}
}
return(movimientos);//devolcemos los movimientos
}
//metodo iterativo
public int iterativo(int x, Pila ini, Pila fin, Pila aux)
{
int cuantos = 0; //movimientos que realizaremos
bool resFin; //variable para saber si se ha acabado
resFin = false; //como esto no esta acabado se inicializa en false
if (x % 2 == 0) //si los discos son pares
{
while (resFin.Equals(false)) //mientras no hay resultado n == numero de discos en fin
{
Console.WriteLine("Movimiento inicio a aux");
mover_disco(ini, aux);
cuantos++;//contamos un movimiento
Console.WriteLine("Movimiento inicio a fin");
mover_disco(ini, fin);
cuantos++;//el siguiente movimiento
Console.WriteLine("Movimiento aux a fin");
mover_disco(aux, fin);
cuantos++; //el tercer movimiento
if (fin.Size.Equals(x)) //al acabar todos los movimientos comprobamos si el tamanyo de fin es el tamanyo de los discos
{
resFin = true;
}
}
}
else//si el numero es impar
{
while (resFin.Equals(false))
{
cuantos++;
Console.WriteLine("Movimiento inicio a fin");
mover_disco(ini, fin);
//comprobamos si ya ha terminado porque es impar, para evitar bucles
if (fin.Size.Equals(x))
{
resFin = true; //si la ultima pila tiene el numero que hemos introducido
return(cuantos);
}
//realizamos el resto de movimientos restantes
cuantos++;
Console.WriteLine("Movimiento inicio a aux");
mover_disco(ini, aux);
cuantos++;
Console.WriteLine("Movimiento aux a fin");
mover_disco(aux, fin);
if (fin.Size.Equals(x))
{
resFin = true;
return(cuantos);
}
//al realizar el tercer movimiento, comprobamos si ya esta el resultado
}
}
return(cuantos); //devolvemos los movimientos realizados
}
public bool isSolved(Pila p, uint n)
{
return(p.Size == n);
}
public int algoritmoRecursivo(int n, Pila ini, Pila fin, Pila aux)
{
discos = n;
movimientos = algoritmoRecursivoReal(n, ini, fin, aux);
return(movimientos);
}
static void Main(string[] args)
{
int t;
Pila ini = new Pila();
Pila aux = new Pila();
Pila fin = new Pila();
Console.WriteLine("bienvenido al juego de las torres de hanoi");
Console.WriteLine("");
Console.WriteLine("Indica el número de discos...");
string key = Console.ReadLine();
while (!Int32.TryParse(key, out t))
{
Console.WriteLine("");
Console.WriteLine("Porfavor introduce un numero valido");
key = Console.ReadLine();
}
while (Int32.Parse(key) <= 0)
{
Console.WriteLine("Acaso crees que poner un numero negativo es buena idea? vengA prueba otra vez");
Console.WriteLine("");
Console.WriteLine("Introduce un número valido...");
key = Console.ReadLine();
}
if (key != "0")
{
Console.WriteLine("");
Console.WriteLine("Has elegido " + key + " discos.");
Pila INI = new Pila(Int32.Parse(key));
ini = INI;
Hanoi hanoi = new Hanoi();
Console.WriteLine("");
Console.WriteLine("Pulsa (I) para Iterativo, pulsa (R) para Recursivo...");
string key2 = Console.ReadLine();
key2 = key2.ToUpper();
while (key2 != "I" && key2 != "R")
{
Console.WriteLine("");
Console.WriteLine("Valor no reconocido, introduce (I) o (R)...");
key2 = Console.ReadLine();
key2 = key2.ToUpper();
}
switch (key2)
{
case "I":
int c = hanoi.iterativo(Int32.Parse(key), ini, fin, aux);
Console.WriteLine("");
Console.WriteLine("Se ha completado en " + c + " movimientos");
break;
case "R":
int d = hanoi.recursivo(Int32.Parse(key), ini, fin, aux);
Console.WriteLine("");
Console.WriteLine("Se ha completado en " + d + " movimientos");
break;
}
}
else
{
Console.WriteLine("No se puede jugar con 0 discos");
}
// Keep the console window open in debug mode.
Console.WriteLine("Press any key to exit.");
Console.ReadKey();
}
static void Main(string[] args)
{
/*Inicializacion de las pilas*/
Pila ini = new Pila();
Pila aux = new Pila();
Pila fin = new Pila();
int numDisc;
Console.WriteLine("Juego de las torres de Hanoi");
Console.WriteLine("");
/*Se introducen los discos*/
Console.WriteLine("Cuantos Discos ?");
string key = Console.ReadLine();
while (!Int32.TryParse(key, out numDisc))
{
Console.WriteLine("Cuantos Discos ?");
key = Console.ReadLine();
}
for (int i = 0; i < numDisc; i++)
{
Disco d = new Disco(numDisc - i);
ini.push(d);
}
Hanoi hanoi = new Hanoi();
/*Se pregunta si Iterativo o Recursivo*/
Console.WriteLine("Iterativo(I) - Recursivo(R)");
string key2 = Console.ReadLine();
key2 = key2.ToUpper();
while (key2 != "I" && key2 != "R")
{
Console.WriteLine("Iterativo(I) - Recursivo(R)");
key2 = Console.ReadLine();
key2 = key2.ToUpper();
}
/*Se resuelve con la opción escogida*/
switch (key2)
{
case "I":
int movs = hanoi.iterativo(numDisc, ini, fin, aux);
Console.WriteLine("Numero de movimientos: " + movs.ToString());
break;
case "R":
int movs2 = hanoi.recursivo(numDisc, ini, fin, aux);
Console.WriteLine("Numero de movimientos: " + movs2.ToString());
break;
}
// Keep the console window open in debug mode.
Console.WriteLine("Press any key to exit.");
Console.ReadKey();
}
public int iterativo(int n, Pila ini, Pila fin, Pila aux)
{
int m = 0;
if (n % 2 != 0)
{
while (fin.Size != n)
{
mover_disco(ini, fin);
m++;
if (fin.Size == n)
{
break;
}
redactar(n, ini, fin, aux, m);
mover_disco(ini, aux);
m++;
if (fin.Size == n)
{
break;
}
redactar(n, ini, fin, aux, m);
mover_disco(aux, fin);
m++;
if (fin.Size == n)
{
break;
}
redactar(n, ini, fin, aux, m);
}
}
if (n % 2 == 0)
{
while (fin.Size != n)
{
mover_disco(ini, aux);
m++;
redactar(n, ini, fin, aux, m);
if (fin.Size == n)
{
break;
}
mover_disco(ini, fin);
m++;
redactar(n, ini, fin, aux, m);
if (fin.Size == n)
{
break;
}
mover_disco(aux, fin);
m++;
redactar(n, ini, fin, aux, m);
if (fin.Size == n)
{
break;
}
}
}
redactar(n, ini, fin, aux, m);
Console.WriteLine("El número total de discos es: " + fin.Size);
Console.WriteLine("El número de total de movimientos es: " + m);
return(m);
}
static void Main(string[] args)
{
/* //prueba de funcionamiento clase pila
* Disco hola = new Disco(1);
* Disco holat = new Disco(2);
* Pila pila = new Pila();
* pila.push(holat);
* pila.push(hola);
* pila.pop();
* Console.WriteLine("coprov si funciona, dime tamanyo "+pila.Size.ToString());
* //----------------------
*
* //prueba funcionamiento pila con la clase hanoi (mover_disco())
* Pila pilas = new Pila();
* Hanoi hanoi = new Hanoi();
* hanoi.mover_disco(pila,pilas);
* Console.WriteLine("tam pila primera"+pila.Size.ToString());
* Console.WriteLine("tam pila segunda"+pilas.Size.ToString());*/
//---------------------------
//prueba de funcionamiento iterativo()
Hanoi iter = new Hanoi(); //definimos el método iterativo
Pila pila1 = new Pila(); // las pilas
Pila pila2 = new Pila();
Pila pila3 = new Pila();
Console.WriteLine("Introduzca el numero de discos para iterativo");
int x = Convert.ToInt32(Console.ReadLine()); //pedimos el numero de discos
while (x <= 0) //comprobamos si hay un numero mayor a 0
{
Console.WriteLine("Introduce un numero mayor a 0");
x = Convert.ToInt32(Console.ReadLine()); //pedimos el numero de discos
}
for (int i = x; i > 0; i--)//introduciomos los discos en la pila ordenandolos del disco más grande al pequenyo en la pila
{
pila1.push(new Disco(i));
}
int res = iter.iterativo(x, pila1, pila2, pila3);
Console.WriteLine(res.ToString());
//--------------------------------------------------------------------------------------------------------------------------------------------------------
// probamos el reiterativo
Hanoi reiter = new Hanoi(); //definimos el método reiterativo
Pila pila4 = new Pila(); // las pilas
Pila pila5 = new Pila();
Pila pila6 = new Pila();
Console.WriteLine("Introduzca el numero de discos para reiterativo");
int y = Convert.ToInt32(Console.ReadLine()); //pedimos el numero de discos
while (y <= 0) //comprobamos si hay un numero mayor a 0
{
Console.WriteLine("Introduce un numero mayor a 0");
y = Convert.ToInt32(Console.ReadLine()); //pedimos el numero de discos
}
for (int i = y; i > 0; i--)//introduciomos los discos en la pila ordenandolos del disco más grande al pequenyo en la pila
{
pila4.push(new Disco(i));
}
int resiter = iter.iterativo(y, pila4, pila5, pila6);
Console.WriteLine(resiter.ToString());
// Keep the console window open in debug mode.
Console.ReadKey();
}
static void Main(string[] args)
{
// Keep the console window open in debug mode.
Console.WriteLine("Introduce I si quieres usar el algoritmo iterativo");
Console.WriteLine("Introduce R si quieres usar el algoritmo recursivo");
string comandoEscrito = Console.ReadLine();
if (comandoEscrito == "I" || comandoEscrito == "R")
{
Console.WriteLine("Introduce el numero de discos : ");
int numDiscos = Convert.ToInt32(Console.ReadLine());
//Torre de Hanoi
Hanoi hanoi = new Hanoi();
//lista de discos
List <Disco> Elementos = new List <Disco>();
//pilas
Pila ini = new Pila();
Pila aux = new Pila();
Pila fin = new Pila();
//rellenar pila ini
for (int i = numDiscos; i > 0; i--)
{
ini.push(new Disco(i));
}
if (comandoEscrito == "I")
{ //interativo
//Aca empieza lo chido
int mov = hanoi.iterativo(numDiscos, ini, fin, aux);
//Formula
double formulaDouble = Math.Pow(2, numDiscos) - 1;
int formulaGucci = Convert.ToInt32(formulaDouble);
//Respuestas
Console.WriteLine("Resultado moviendo discos entre pilas: " + mov);
Console.WriteLine("Resultado calculado con la formula es: " + formulaGucci);
if (mov.Equals(formulaGucci))
{
Console.WriteLine("El resultado es CORRECTO");
}
else
{
Console.WriteLine("El resultado es INCORRECTO");
}
}
else if (comandoEscrito == "R") //recurivo
{
//Aca empieza lo chido
int mov = hanoi.recursivo(numDiscos, ini, fin, aux);
//Formula
double formulaDouble = Math.Pow(2, numDiscos) - 1;
int formulaGucci = Convert.ToInt32(formulaDouble);
//Respuestas
Console.WriteLine("Resultado moviendo discos entre pilas: " + mov);
Console.WriteLine("Resultado calculado con la formula es: " + formulaGucci);
if (mov.Equals(formulaGucci))
{
Console.WriteLine("El resultado es CORRECTO");
}
else
{
Console.WriteLine("El resultado es INCORRECTO");
}
}
}
else
{
Console.WriteLine(" Comando incorrecto , una I o una R");
}
Console.ReadKey();
}
public int iterativo(int n, Pila ini, Pila fin, Pila aux)
{
int movimientos = 0;
bool solucion = false;
if (n % 2 == 0)
{
while (!solucion)
{
/*incrementar movimientos(m) ← mover disco(INI, AUX)
* 6: incrementar movimientos(m) ← mover disco(INI, FIN)
* 7: incrementar movimientos(m) ← mover disco(AUX, FIN)*/
movimientos++;
Console.WriteLine("Movimiento inicio a fin");
mover_disco(ini, aux);
movimientos++;
Console.WriteLine("Movimiento inicio a aux");
mover_disco(ini, fin);
movimientos++;
Console.WriteLine("Movimiento aux a fin");
mover_disco(aux, fin);
if (fin.Size == n)
{
//Si la pila final tiene todos los discos, paramos el programa
Console.WriteLine("Graasia Diego");
solucion = true;
}
}
}
else
{
while (!solucion)
{
/*incrementar movimientos(m) ← mover disco(INI, FIN)
* incrementar movimientos(m) ← mover disco(INI, AUX)
* incrementar movimientos(m) ← mover disco(AUX, FIN)*/
if (fin.Size == n)
{
//Si la pila final tiene todos los discos, paramos el programa
solucion = true;
return(movimientos);
}
movimientos++;
Console.WriteLine("Movimiento inicio a aux");
mover_disco(ini, fin);
if (fin.Size == n)
{
//Si la pila final tiene todos los discos, paramos el programa
solucion = true;
return(movimientos);
}
movimientos++;
Console.WriteLine("Movimiento inicio a fin");
mover_disco(ini, aux);
if (fin.Size == n)
{
//Si la pila final tiene todos los discos, paramos el programa
solucion = true;
return(movimientos);
}
movimientos++;
Console.WriteLine("Movimiento aux a fin");
mover_disco(aux, fin);
if (fin.Size == n)
{
//Si la pila final tiene todos los discos, paramos el programa
solucion = true;
return(movimientos);
}
}
}
return(movimientos);
}
static TestPila()
{
Disco disco_1 = new Disco();
disco_1.ValorInt = 1;
Disco disco_2 = new Disco();
disco_2.ValorInt = 2;
Disco disco_3 = new Disco();
disco_3.ValorInt = 3;
/*---------------------------------------------*/
/* TESTING:
* Creació de pila */
/*---------------------------------------------*/
Console.WriteLine(" =================================================================================================");
Console.WriteLine(" Creació de pila ");
Pila pila_A = new Pila();
Pila pila_B = new Pila();
Pila pila_C = new Pila();
int size_A = pila_A.Size;
bool buida_A = pila_A.isEmpty();
Console.WriteLine("Tamany de pila_A: " + size_A.ToString());
Console.WriteLine("Està buida pila_A: " + buida_A.ToString());
Console.WriteLine();
/*---------------------------------------------*/
/* TESTING:
* Checking top de una pila buida (pila_A) */
/*---------------------------------------------*/
Console.WriteLine(" =================================================================================================");
Console.WriteLine(" Checking top de una pila buida (pila_A) ");
Console.WriteLine("top de pila_A buida: " + pila_A.Top.ToString());
Console.WriteLine();
/*---------------------------------------------*/
/* TESTING:
* Pushing en una pila buida un disco (pila_A, disco_3) */
/*---------------------------------------------*/
Console.WriteLine(" =================================================================================================");
Console.WriteLine(" Pushing en una pila buida un disco (pila_A, disco_3) ");
pila_A.push(disco_3);
Console.WriteLine("disco en top pila (pila_A es Disco 3): " + pila_A.Top.ToString());
Console.WriteLine();
/*---------------------------------------------*/
/* TESTING:
* Elements en una pila buida (pila_B) */
/*---------------------------------------------*/
Console.WriteLine(" =================================================================================================");
Console.WriteLine(" Elements en una pila buida (pila_B) ");
List <Disco> Elements_B = pila_B.Elementos;
int Total_B = 0;
Console.WriteLine("Elements en la pila buida ");
foreach (Disco Element in Elements_B)
{
Console.WriteLine(" " + Element.ValorInt.ToString());
Total_B++;
}
Console.WriteLine("Total: " + Total_B.ToString());
Console.WriteLine();
/*---------------------------------------------*/
/* TESTING:
* Elements en una pila amb un disco (pila_A) */
/*---------------------------------------------*/
Console.WriteLine(" =================================================================================================");
Console.WriteLine(" Elements en una pila amb un disco (pila_A) ");
List <Disco> Elements_A = pila_A.Elementos;
int Total_A = 0;
Console.WriteLine("Elements en la pila ");
foreach (Disco Element in Elements_A)
{
Console.WriteLine(" " + Element.ValorInt.ToString());
Total_A++;
}
Console.WriteLine("Total: " + Total_A.ToString());
Console.WriteLine();
/*---------------------------------------------*/
/* TESTING:
* Elements en una pila amb varis discos disco (pila_C) */
/*---------------------------------------------*/
Console.WriteLine(" =================================================================================================");
Console.WriteLine(" Elements en una pila amb varis discos disco (pila_C) ");
pila_C.push(disco_3);
pila_C.push(disco_2);
pila_C.push(disco_1);
List <Disco> Elements_C = pila_C.Elementos;
int Total_C = 0;
Console.WriteLine("Elements en la pila ");
foreach (Disco Element in Elements_C)
{
Console.WriteLine(" " + Element.ValorInt.ToString());
Total_C++;
}
Console.WriteLine("Total: " + Total_C.ToString());
Console.WriteLine();
/*---------------------------------------------*/
/* TESTING:
* Poping de una pila amb sols un disco (pila_A disco_3) */
/*---------------------------------------------*/
Console.WriteLine(" =================================================================================================");
Console.WriteLine(" Poping de una pila amb sols un disco (pila_A disco_3) ");
Console.WriteLine("Disco extret: " + pila_A.pop().ValorInt.ToString());
Console.WriteLine("La pila queda buida: " + pila_A.isEmpty().ToString());
Console.WriteLine();
/*---------------------------------------------*/
/* TESTING:
* Poping una pila fins a buidar-la (pila_C) */
/*---------------------------------------------*/
Console.WriteLine(" =================================================================================================");
Console.WriteLine(" Poping una pila fins a buidar-la (pila_C) ");
Total_C = 0;
while (!pila_C.isEmpty())
{
Console.WriteLine("Disco extret: " + pila_C.pop().ValorInt.ToString());
Total_C++;
}
Console.WriteLine("Total: " + Total_C.ToString());
Console.WriteLine("La pila queda buida: " + pila_A.isEmpty().ToString());
Console.WriteLine();
}
public int iterativo(int n, Pila ini, Pila fin, Pila aux)
{
int movimientos = 0;
if (n % 2 != 0)
{
while (!comprobar(fin, n))
{
if (ini.Top != 0 && (fin.Top > ini.Top || fin.Top == 0))
{
mover_disco(ini, fin);
Console.WriteLine("Mover disco " + ini.Top + " de la pila " + ini.Name + " a la " + fin.Name);
movimientos++;
}
else if (fin.Top != 0 && (fin.Top < ini.Top || ini.Top == 0))
{
mover_disco(fin, ini);
Console.WriteLine("Mover disco " + fin.Top + " de la pila " + fin.Name + " a la " + ini.Name);
movimientos++;
}
if (!comprobar(fin, n))
{
if (ini.Top != 0 && (aux.Top > ini.Top || aux.Top == 0))
{
mover_disco(ini, aux);
Console.WriteLine("Mover disco " + ini.Top + " de la pila " + ini.Name + " a la " + aux.Name);
movimientos++;
}
else if (aux.Top != 0 && (aux.Top < ini.Top || ini.Top == 0))
{
mover_disco(aux, ini);
Console.WriteLine("Mover disco " + aux.Top + " de la pila " + aux.Name + " a la " + ini.Name);
movimientos++;
}
}
if (!comprobar(fin, n))
{
if (ini.Top != 0 && (fin.Top > aux.Top || fin.Top == 0))
{
mover_disco(aux, fin);
Console.WriteLine("Mover disco " + aux.Top + " de la pila " + aux.Name + " a la " + fin.Name);
movimientos++;
}
else if (aux.Top != 0 && (fin.Top < aux.Top || aux.Top == 0))
{
mover_disco(fin, aux);
Console.WriteLine("Mover disco " + aux.Top + " de la pila " + fin.Name + " a la " + aux.Name);
movimientos++;
}
}
}
}
else
{
while (!comprobar(fin, n))
{
if (ini.Top != 0 && (aux.Top > ini.Top || aux.Top == 0))
{
mover_disco(ini, aux);
Console.WriteLine("Mover disco " + ini.Top + " de la pila " + ini.Name + " a la " + aux.Name);
movimientos++;
}
else if (aux.Top != 0 && (aux.Top < ini.Top || ini.Top == 0))
{
mover_disco(aux, ini);
Console.WriteLine("Mover disco " + aux.Top + " de la pila " + aux.Name + " a la " + ini.Name);
movimientos++;
}
if (!comprobar(fin, n))
{
if (ini.Top != 0 && (fin.Top > ini.Top || fin.Top == 0))
{
mover_disco(ini, fin);
Console.WriteLine("Mover disco " + ini.Top + " de la pila " + ini.Name + " a la " + fin.Name);
movimientos++;
}
else if (fin.Top != 0 && (fin.Top < ini.Top || ini.Top == 0))
{
mover_disco(fin, ini);
Console.WriteLine("Mover disco " + fin.Top + " de la pila " + fin.Name + " a la " + ini.Name);
movimientos++;
}
}
if (!comprobar(fin, n))
{
if (fin.Top != 0 && (fin.Top > aux.Top || fin.Top == 0))
{
mover_disco(aux, fin);
Console.WriteLine("Mover disco " + aux.Top + " de la pila " + aux.Name + " a la " + fin.Name);
movimientos++;
}
else if (aux.Top != 0 && (fin.Top < aux.Top || aux.Top == 0))
{
mover_disco(fin, aux);
Console.WriteLine("Mover disco " + aux.Top + " de la pila " + fin.Name + " a la " + aux.Name);
movimientos++;
}
}
}
}
return(movimientos);
}
static void Main(string[] args)
{
Pila ini = new Pila();
Pila aux = new Pila();
Pila fin = new Pila();
Console.WriteLine("¿Cuantos discos quieres?");
int cantidadDiscos = 0;
int pesoDisco = 1; // El peso del disco en cada momento que pedimos uno.
bool pesoCorrecto = false; // Nos dice si el peso introducido es inferior al anterior
try
{
cantidadDiscos = int.Parse(Console.ReadLine());
if (cantidadDiscos == 0)
{
Console.WriteLine("¿Cuantos discos quieres?");
cantidadDiscos = 0;
cantidadDiscos = int.Parse(Console.ReadLine());
}
}
catch (Exception e)
{
Console.WriteLine("Has puesto un valor no aceptado");
}
for (int i = 1; i <= cantidadDiscos; i++)
{
try
{
// Creamos un While para que pregunte el peso del disco mientras no sea inferior al anterior
while (!pesoCorrecto)
{
// Preguntamos el peso que quiere de disco
Console.WriteLine("¿De que tamaño quieres que sea el disco " + i + "?" + "\n\n\t Como mínimo debería de ser de " + (cantidadDiscos - i + 1));
pesoDisco = int.Parse(Console.ReadLine()); // Añadimos el peso a la variable pesoDisco
// Si un disco tiene peso 0 nos da error a la hora de hacer el hanoi
if (pesoDisco != 0 && pesoDisco > 0 && pesoDisco >= (cantidadDiscos - i + 1))
{
// Comprovamos si la lista ini está vacía
if (ini.isEmpty())
{
// Si está insertamos el disco directamente
ini.push(new Disco(pesoDisco));
pesoCorrecto = true;
}
else // Entramos si la pila ini tiene algún disco
{
// Preguntamos el peso del disco es inferior al que está ya puesto
if (ini.Top > pesoDisco)
{
pesoCorrecto = true; // Ponemos que el peso introducido es correcto
ini.push(new Disco(pesoDisco)); // Creamos un disco y lo insertamos en ini
}
}
}
}
}
catch (Exception e)
{
Console.WriteLine("Has puesto un valor no aceptado");
i--;
}
pesoCorrecto = false;
}
Hanoi hanoi = new Hanoi();
Console.WriteLine("Llamamos a iterativo: ");
int movimientosHechos = hanoi.iterativo(cantidadDiscos, ini, fin, aux);
//Console.WriteLine("Llamamos a recursivo: ");
//int movimientosHechos = hanoi.recursivo(cantidadDiscos, ini, fin, aux);
double movimientoRequeridos = Math.Pow(2, cantidadDiscos) - 1;
Console.WriteLine("Número de discos: " + cantidadDiscos);
Console.WriteLine("Número de movimentos necesarios mínimos: " + movimientoRequeridos);
Console.WriteLine("Número de movimentos hechos: " + movimientosHechos);
// Keep the console window open in debug mode.
Console.WriteLine("Press any key to exit.");
Console.ReadKey();
}
public int iterativo(int n, Pila ini, Pila fin, Pila aux)
{
int m = 0;
//Creación e introducción de los discos en la pila inicial
for (int i = n; 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");
if (n % 2 != 0)
{
while (fin.Size != n)
{
mover_disco(ini, fin); m++;
Console.WriteLine("________________________________________________________________________________");
Console.WriteLine("MOVIMIENTO Nº" + m + " REALIZADO: ");
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);
if (fin.Size == n)
{
break;
}
mover_disco(ini, aux); m++;
Console.WriteLine("________________________________________________________________________________");
Console.WriteLine("MOVIMIENTO Nº" + m + " REALIZADO: ");
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);
if (fin.Size == n)
{
break;
}
mover_disco(aux, fin); m++;
Console.WriteLine("________________________________________________________________________________");
Console.WriteLine("MOVIMIENTO Nº" + m + " REALIZADO: ");
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);
if (fin.Size == n)
{
break;
}
}
}
if (n % 2 == 0)
{
while (fin.Size != n)
{
mover_disco(ini, aux); m++;
Console.WriteLine("________________________________________________________________________________");
Console.WriteLine("MOVIMIENTO Nº" + m + " REALIZADO: ");
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);
if (fin.Size == n)
{
break;
}
mover_disco(ini, fin); m++;
Console.WriteLine("________________________________________________________________________________");
Console.WriteLine("MOVIMIENTO Nº" + m + " REALIZADO: ");
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);
if (fin.Size == n)
{
break;
}
mover_disco(aux, fin); m++;
Console.WriteLine("________________________________________________________________________________");
Console.WriteLine("MOVIMIENTO Nº" + m + " REALIZADO: ");
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);
if (fin.Size == n)
{
break;
}
}
}
Console.WriteLine("________________________________________________________________________________");
return(m);
}
public int iterativo(int n, Pila ini, Pila fin, Pila aux)
{
if (n % 2 == 1 || n == 1)
{
while (fin.Size < n)
{
mover_disco(ini, fin);
if (direccion == 2)
{
Console.WriteLine("Moviendo de inicio a fin");
}
else
{
Console.WriteLine("Moviendo de fin a inicio");
}
if (fin.Size == n)
{
return(m);
}
mover_disco(ini, aux);
if (direccion == 2)
{
Console.WriteLine("Moviendo de inicio a aux");
}
else
{
Console.WriteLine("Moviendo de aux a inicio");
}
mover_disco(aux, fin);
if (direccion == 2)
{
Console.WriteLine("Moviendo de aux a fin");
}
else
{
Console.WriteLine("Moviendo de fin a aux");
}
if (fin.Size == n)
{
return(m);
}
}
}
else
{
while (fin.Size < n)
{
mover_disco(ini, aux);
if (direccion == 2)
{
Console.WriteLine("Moviendo de inicio a aux");
}
else
{
Console.WriteLine("Moviendo de aux a inicio");
}
mover_disco(ini, fin);
if (direccion == 2)
{
Console.WriteLine("Moviendo de inicio a fin");
}
else
{
Console.WriteLine("Moviendo de fin a inicio");
}
if (fin.Size == n)
{
return(m);
}
mover_disco(aux, fin);
if (direccion == 2)
{
Console.WriteLine("Moviendo de aux a fin");
}
else
{
Console.WriteLine("Moviendo de fin a aux");
}
if (fin.Size == n)
{
return(m);
}
}
}
return(0);
}
/*TODO: Implementar métodos*/
public void mover_disco(Pila a, Pila b)
{
}
static void Main(string[] args)
{
int t;
Pila ini = new Pila();
Pila aux = new Pila();
Pila fin = new Pila();
Console.WriteLine("==▒▓ Este es el juego de las Torres de Hanoi ▓▒==");
Console.WriteLine("");
Console.WriteLine(" ┌┐ ╔╗ ┌┐");
Console.WriteLine(" ▓▓▓▓ ║║ ││");
Console.WriteLine(" ▓▓▓▓▓▓ ║║ ││");
Console.WriteLine(" ▓▓▓▓▓▓▓▓ ║║ ││");
Console.WriteLine("██████████ ║║ ││");
Console.WriteLine("────┴┴────────╨╨────────┴┴────");
Console.WriteLine(" INI AUX FIN");
Console.WriteLine("");
Console.WriteLine("Indica el número de discos...");
string key = Console.ReadLine();
while (!Int32.TryParse(key, out t))
{
Console.WriteLine("");
Console.WriteLine("Introduce un número valido...");
key = Console.ReadLine();
}
while (Int32.Parse(key) < 0)
{
Console.WriteLine("No puedes jugar con discos negativos");
Console.WriteLine("");
Console.WriteLine("Introduce un número valido...");
key = Console.ReadLine();
}
if (key != "0")
{
Console.WriteLine("");
Console.WriteLine("Has elegido " + key + " discos.");
Pila INI = new Pila(Int32.Parse(key));
ini = INI;
Hanoi hanoi = new Hanoi();
Console.WriteLine("");
Console.WriteLine("Pulsa (I) para Iterativo, pulsa (R) para Recursivo...");
string key2 = Console.ReadLine();
key2 = key2.ToUpper();
while (key2 != "I" && key2 != "R")
{
Console.WriteLine("");
Console.WriteLine("Valor no reconocido, introduce (I) o (R)...");
key2 = Console.ReadLine();
key2 = key2.ToUpper();
}
switch (key2)
{
case "I":
int c = hanoi.iterativo(Int32.Parse(key), ini, fin, aux);
Console.WriteLine("");
Console.WriteLine("Se ha completado en " + c + " movimientos");
break;
case "R":
int d = hanoi.recursivo(Int32.Parse(key), ini, fin, aux);
Console.WriteLine("");
Console.WriteLine("Se ha completado en " + d + " movimientos");
break;
}
}
else
{
Console.WriteLine("No se puede jugar con 0 discos");
}
Console.WriteLine("Press any key to exit.");
Console.ReadKey();
}
