Esempio n. 1
0
        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("-----------------------------------");
        }
Esempio n. 2
0
        public Disco pop()
        {
            Disco extraido = null;

            if (Size == 0)
            {
                Top = 0;
            }

            else
            {
                extraido = Elementos[Size - 1];
                Elementos.RemoveAt(Size - 1);
                if (Size == 0)
                {
                    Top = 0;
                }
                else
                {
                    Top = Elementos[Size - 1].Valor;
                }
            }

            return(extraido);
        }
Esempio n. 3
0
 public int Push(Disco disco)
 {
     if (!EstaLleno())
     {
         if (!EstaVacio())
         {
             if (pila[contador - 1].GetTamanio() > disco.GetTamanio())
             {
                 pila[contador] = disco;
                 this.Parent.Controls.Add(disco);
                 disco.Location = new System.Drawing.Point(this.Location.X - (disco.Width / 2) + (this.Width / 2), 225 - (20 * (contador + 1)));
                 disco.BringToFront();
                 disco.Refresh();
                 contador++;
                 return(0);
             }
         }
         else
         {
             pila[contador] = disco;
             this.Parent.Controls.Add(disco);
             disco.Location = new System.Drawing.Point(this.Location.X - (disco.Width / 2) + (this.Width / 2), 225 - (20 * (contador + 1)));
             disco.BringToFront();
             disco.Refresh();
             contador++;
             return(0);
         }
     }
     return(1);
 }
Esempio n. 4
0
 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);
     }
 }
Esempio n. 5
0
 /*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");
         }
     }
 }
Esempio n. 6
0
        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();
        }
Esempio n. 7
0
 public void push(Disco d)
 {
     listaDiscos.Add(d);
     Console.WriteLine("Metiendo en: " + nombrePila + "\n");
     ultimoDisco = d.getTamanyo();
     numDiscos++;
 }
Esempio n. 8
0
 public Disco pop()
 {
     if (Size > 0)
     {
         Disco disco = Top;
         Elementos.Remove(Top);
         if (this.isEmpty())
         {
             Top  = new Disco(0);
             Size = 0;
         }
         else
         {
             Top = this.Elementos.Last();
             Size--;
         }
         return(disco);
     }
     else
     {
         //Caso imposible, sacar un disco de una pila vacía
         Console.WriteLine("ERROR: Sacar un disco de una pila Vacía");
         return(new Disco(0));
     }
 }
Esempio n. 9
0
 //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);
         }
     }
 }
Esempio n. 10
0
        public void registrarMovimiento(Pila a, Pila b)
        {
            Disco tmp = a.pop();

            Console.WriteLine("Se ha movido el disco: " + tmp.Valor);
            b.push(tmp);
        }
Esempio n. 11
0
        static TestDisco()
        {
            /*---------------------------------------------*/

            /*  TESTING:
             *  Creació de discos */
            /*---------------------------------------------*/
            Console.WriteLine(" =================================================================================================");
            Console.WriteLine("  Creació de discos ");
            Disco disco_1 = new Disco();

            disco_1.ValorInt = 1;
            int Valor_1 = disco_1.ValorInt;

            Disco disco_2 = new Disco();

            disco_2.ValorInt = 2;
            int Valor_2 = disco_2.ValorInt;

            Disco disco_3 = new Disco();

            disco_3.ValorInt = 3;
            int Valor_3 = disco_3.ValorInt;

            Console.WriteLine("Disco 1 Creat amb valor: " + Valor_1.ToString());
            Console.WriteLine("Disco 2 Creat amb valor: " + Valor_2.ToString());
            Console.WriteLine("Disco 3 Creat amb valor: " + Valor_3.ToString());
            Console.WriteLine();
        }
Esempio n. 12
0
 /*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);
         }
     }
 }
Esempio n. 13
0
        public Disco pop()
        {
            Disco disco = Elementos[Elementos.Count - 1];

            Elementos.RemoveAt(Elementos.Count - 1);
            Size--;
            return(disco);
        }
Esempio n. 14
0
 //Aumenta la cantidad de discos en la pila y el disco que está arriba
 public void push(Disco d)
 {
     if (Size == 0 || d.Valor < Elementos.Last().Valor)
     {
         Elementos.Add(d);
         Size = Elementos.Count;
         Top  = Elementos.Last().Valor;
     }
 }
Esempio n. 15
0
        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));
        }
Esempio n. 16
0
        //que permitirá extraer el disco de la parte superior de la pila
        public Disco pop()
        {
            Disco discoAdevolver = this.Elementos[(this.Elementos.Count - 1)];

            if ((this.Elementos.Count - 2) >= 0)
            {
                this.Top = this.Elementos[(this.Elementos.Count - 2)].Valor;
            }
            this.Elementos.RemoveAt((this.Elementos.Count - 1));
            this.Size--;
            return(discoAdevolver);
        }
        //==============================================================================
        // 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;
            }
        }
Esempio n. 18
0
        public Disco pop()
        {
            if (!isEmpty())
            {
                Disco last = Elementos[--Size];
                Elementos.RemoveAt(Size);
                Top = !isEmpty() ? Elementos[Size - 1].Valor : 0;

                return(last);
            }

            return(null);
        }
Esempio n. 19
0
        public Disco Pop()
        {
            Disco disco = null;

            if (!EstaVacio())
            {
                contador--;
                disco          = pila[contador];
                pila[contador] = null;
                //return pila[contador];
            }
            return(disco);
        }
        public void push(Disco d)
        {
            //Introducimos dos condiciones si tamaño es 0 o
            //el valor introducido es menor al valor mas alto de la pila registrado

            if (Size == 0 || d.Valor < Top)
            {
                Size++;

                Elementos.Add(d);

                Top = d.Valor;
            }
        }
Esempio n. 21
0
        public Pila(uint n)
        {
            Elementos = new List <Disco>();

            Disco iter;

            for (int i = (int)n; i >= 1; --i)
            {
                iter = new Disco(i);
                Elementos.Add(iter);
                Top = iter.Valor;
                Size++;
            }
        }
Esempio n. 22
0
        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();
        }
Esempio n. 23
0
        //Funcion para generar dinamicamente la cantidad de discos
        //que se desee
        public void generarDiscos(int numDiscos)
        {
            List <Disco> discos = new List <Disco>();

            for (int i = n; i >= 1; i--)
            {
                Disco disco = new Disco(i);
                Console.WriteLine(disco.getTamanyo());
                discos.Add(disco);
            }
            for (int i = 0; i < discos.Count; i++)
            {
                asignarDiscosPilaIni(discos[i]);
            }
        }
Esempio n. 24
0
        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);
            }
        }
Esempio n. 25
0
        public bool rellenarPila(int n)
        {
            if (n != 0)
            {
                for (int i = 0; i < n; i++)
                {
                    Disco disco = new Disco();
                    disco.Valor = i;
                    this.push(disco);
                }
                return(true);
            }

            return(false);
        }
Esempio n. 26
0
        /*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);
 */         }
        }
Esempio n. 27
0
        /*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
                    }
                }
            }
        }
Esempio n. 28
0
        public Disco pop()//para quitar un disco
        {
            if (isEmpty() == true)
            {
                return(null);
            }
            else
            {
                //variable tipo disco
                Disco variable = elementos[elementos.Count - 1];//donde guardamos en la variable el ultimo elemento de la lista
                elementos.RemoveAt(elementos.Count - 1);
                Size--;

                return(variable);
            }
        }
Esempio n. 29
0
        public Disco pop()
        {
            Disco discoExtraido = elementos.Last();

            elementos.Remove(discoExtraido);
            // si al borrar el disco esta vacio el top = -1
            if (!isEmpty())
            {
                top = elementos.Last().Valor;
            }
            else
            {
                top = -1;
            }
            return(discoExtraido);
        }
Esempio n. 30
0
        public Disco pop()
        {
            Disco discoEliminado = this.Elementos[0];

            this.Elementos.RemoveAt(0);
            this.Size = this.Elementos.Count;
            if (isEmpty() == true)
            {
                this.Top = 99;
            }
            if (isEmpty() == false)
            {
                this.Top = this.Elementos[0].Valor;
            }
            return(discoEliminado);
        }