sábado, 14 de septiembre de 2013

TORRES DE HANOI

TORRES DE HANOI.


Son uno de los problemas clásicos con los que todo científico computacional en ciernes tiene que lidiar. Cuenta la leyenda que un templo del Lejano Oriente, los sacerdotes intentan mover una pila de discos dorados, de una aguja de diamante a otra. La pila inicial tiene 64 discos insertados en una aguja y se ordenan de abajo hacia arriba, de mayor a menor tamaño. Los sacerdotes intentan mover la pila de una aguja a otra, con las restricciones de que solo se puede mover un disco a la vez, y en ningún momento se puede colocar un disco más grande encima de uno más pequeño. Se cuenta con tres agujas, una de las cuales se usa para almacenar discos temporalmente. Se supone que el mundo acabara cuando los sacerdotes completen sus tareas, por lo que hay pocos incentivos para que nosotros podamos facilitar sus esfuerzos.
Supongamos que los sacerdotes intentan mover los discos de la aguja 1 a la aguja 2. Deseamos desarrollar un algoritmo que imprima la secuencia precisa de transferencia de los discos de una aguja a otra.

Si tratamos de encontrar una solución iterativa, es probable que terminemos “atados” manejando los discos sin esperanza. En vez de ello, si atacamos este problema mediante la recursividad podemos producir podemos producir rápidamente una solución.


   PROCESO:

import javax.swing.JOptionPane;
public class TorredeHanoi 
{
  private int numDiscos;
    private int numMovimientos;

    /**
     * @return the numDiscos
     */
    public int getNumDiscos() {
        return numDiscos;
    }

    /**
     * @param numDiscos the numDiscos to set
     */
    public void setNumDiscos(int numDiscos) {
        this.numDiscos = numDiscos;
    }

    /**
     * @return the numMovimientos
     */
    public int getNumMovimientos() {
        return numMovimientos;
    }

    /**
     * @param numMovimientos the numMovimientos to set
     */
    public void setNumMovimientos(int numMovimientos) {
        this.numMovimientos = numMovimientos;
    }
    public void captura()
        {
       numDiscos=Integer.parseInt(JOptionPane.showInputDialog(" *-Numero de discos:"));

        }
    public void intercambio(int numDiscos, int A,int B,int C)
    {
     if (numDiscos==1)
      {
      setNumMovimientos(getNumMovimientos() +1);
      JOptionPane.showMessageDialog(null, "*-Mover disco del poste A al poste B-*");
      }
     else
       {
    intercambio(numDiscos - 1, A,C,B);
    setNumMovimientos(getNumMovimientos() +1);
    JOptionPane.showMessageDialog(null, "*-Mover disco del poste A al poste C-*");
    intercambio(numDiscos-1, B,A,C);
       }
    }
    public void totalMovimientos()
       {
        JOptionPane.showMessageDialog(null, "*-El total de movimientos fueron:  "+ numMovimientos);
       }
}

SOLUCIÓN:

public class SolucionTorresdeHanoi
{
public static void main (String [] args)
  {
    TorredeHanoi objeto;

    objeto=new TorredeHanoi ();

    objeto.captura();
    objeto.intercambio(objeto.getNumDiscos(), 'A', 'B', 'C');
    objeto.totalMovimientos();
  }
}









P.O.O CON RELACIÓN A LA RECURSIVIDAD Y DIAGRAMAS UML

                                    

¿QUÉ ES POO?




La Programación Orientada a Objetos (POO u OOP según sus siglas en inglés) es un paradigma de programación que usa objetos y sus interacciones para diseñar aplicaciones y programas de computadora. Está basado en varias técnicas, incluyendo herencia, modularidad, polimorfismo, y encapsulamiento. Su uso se popularizó a principios de la década de 1990. Actualmente son muchos los lenguajes de programación que soportan la orientación a objetos.(4)
El término de Programación Orientada a Objetos indica más una forma de diseño y una metodología de desarrollo de software que un lenguaje de programación, ya que en realidad se puede aplicar el Diseño Orientado a Objetos (En inglés abreviado OOD, Object Oriented Design), a cualquier tipo de lenguaje de programación.
La programación Orientada a objetos (POO) es una forma especial de programar, más cercana a como expresaríamos las cosas en la vida real que otros tipos de programación.


                                       
                                          RECURSIVIDAD

Primero debemos decir que la recursividad no es una estructura de datos, sino que es una técnica de programación que nos permite que un bloque de instrucciones se ejecute n veces. Remplaza en ocasiones a estructuras repetitivas.
Este concepto será de gran utilidad para el capítulo de la estructura de datos tipo árbol.
La recursividad es un concepto difícil de entender en principio, pero luego de analizar diferentes problemas aparecen puntos comunes.
En Java los métodos pueden llamarse a sí mismos. Si dentro de un método existe la llamada a sí mismo decimos que el método es recursivo.
Cuando un método se llama a sí mismo, se asigna espacio en la pila para las nuevas variables locales y parámetros.
Al volver de una llamada recursiva, se recuperan de la pila las variables locales y los parámetros antiguos y la ejecución se reanuda en el punto de la llamada al método.

                            

                                     
                                 DIAGRAMAS UML

UML es un lenguaje para hacer modelos y es independiente de los métodos de análisis y diseño. Existen diferencias importantes entre un método y un lenguaje de modelado. Un método es una manera explícita de estructurar el pensamiento y las acciones de cada individuo. Además, el método le dice al usuario qué hacer, cómo hacerlo, cuándo hacerlo y por qué hacerlo; mientras que el lenguaje de modelado carece de estas instrucciones. Los métodos contienen modelos y esos modelos son utilizados para describir algo y comunicar los resultados del uso del método.
Un modelo es expresado en un lenguaje de modelado. Un lenguaje de modelado consiste de vistas, diagramas, elementos de modelo ¾ los símbolos utilizados en los modelos ¾ y un conjunto de mecanismos generales o reglas que indican cómo utilizar los elementos. Las reglas son sintácticas, semánticas y pragmáticas


PRÁCTICAS CON DIAGRAMAS UML 



1.- ELABORA UN PROGRAMA QUE SOLICITE TRES NÚMEROS AL USUARIO Y LOS IMPRIMA ORDENADOS DE MAYOR A MENOR.

public class numeroMayor
{
//atributos 
int num1, num2, num3;

//método
public static void main()
}

                                                                           }


2.-ELABORA UN PROGRAMA QUE CALCULE EL ÁREA DE TRES RECTÁNGULOS.


PROCESO:

import javax.swing.JOptionPane;
public class rectangulo
{
    private int base;
    private int altura;
    private int area;
    private int perimetro;

    /**
     * @return the base
     */
    public int getBase() {
        return base;
    }

    /**
     * @param base the base to set
     */
    public void setBase(int base) {
        this.base = base;
    }

    /**
     * @return the altura
     */
    public int getAltura() {
        return altura;
    }

    /**
     * @param altura the altura to set
     */
    public void setAltura(int altura) {
        this.altura = altura;
    }

    /**
     * @return the area
     */
    public int getArea() {
        return area;
    }

    /**
     * @param area the area to set
     */
    public void setArea(int area) {
        this.area = area;
    }

    /**
     * @return the perimetro
     */
    public int getPerimetro() {
        return perimetro;
    }

    /**
     * @param perimetro the perimetro to set
     */
    public void setPerimetro(int perimetro) {
        this.perimetro = perimetro;
    }
    public void captura()
    {
     base=Integer.parseInt(JOptionPane.showInputDialog("BASE: "));
     altura=Integer.parseInt(JOptionPane.showInputDialog("ALTURA: "));
    }
    public void calcularArea()
    {
    area=base*altura;    
    }
    public void calcularPerimetro()
    {
    perimetro=base+base+altura+altura;    
    }
    public void imprimir()
    {
    JOptionPane.showMessageDialog(null, "El area del rectangulo es: "+ area);
    JOptionPane.showMessageDialog(null, "El perimetro delm rectangulo es:"+ perimetro);
    }
}

SOLUCIÓN:

public class SolucionRec
{
 public static void main(String []args)
  {
     //declarando los objetos
     rectangulo r1, r2, r3;
     //craendo los objetos
     r1=new rectangulo();
     r2=new rectangulo();
     r3=new rectangulo();

     r1.captura();
     r1.calcularArea();
     r1.calcularPerimetro();
     r1.imprimir();

     r2.captura();
     r2.calcularArea();
     r2.calcularPerimetro();
     r2.imprimir();

     r3.captura();
     r3.calcularArea();
     r3.calcularPerimetro();
     r3.imprimir();
  }

}



3.-ELABORA UN PROGRAMA QUE CALCULE EL ÁREA DE UN TRIÁNGULO.




PROCESO:

import javax.swing.JOptionPane;

public class Triangulo
{
private int base;
private int altura;
private float area;
private int perimetro;

    /**
     * @return the base
     */
    public int getBase() {
        return base;
    }

    /**
     * @param base the base to set
     */
    public void setBase(int base) {
        this.base = base;
    }

    /**
     * @return the altura
     */
    public int getAltura() {
        return altura;
    }

    /**
     * @param altura the altura to set
     */
    public void setAltura(int altura) {
        this.altura = altura;
    }

    /**
     * @return the area
     */
    public float getArea() {
        return area;
    }

    /**
     * @param area the area to set
     */
    public void setArea(float area) {
        this.area = area;
    }

    /**
     * @return the perimetro
     */
    public int getPerimetro() {
        return perimetro;
    }

    /**
     * @param perimetro the perimetro to set
     */
    public void setPerimetro(int perimetro) {
        this.perimetro = perimetro;
    }
    public void captura()
    {
    base=Integer.parseInt(JOptionPane.showInputDialog("BASE: "));
    altura=Integer.parseInt(JOptionPane.showInputDialog("ALTURA: "));
    }
    public void calcularArea()
    {
    area=base*altura/2;
    }
    public void calcularPerimetro()
    {
    perimetro=base+altura+altura;
    }
    public void imprimir()
    {
    JOptionPane.showMessageDialog(null, "El area del triangulo es: "+ area);
    JOptionPane.showMessageDialog(null, "El perimetro del triangulo es:"+ perimetro);
    }

}

SOLUCIÓN:

public class SolucionTria
{
public static void main(String []args)
  {
     //declarando los objetos
     Triangulo t1, t2, t3;
     //craendo los objetos
     t1=new Triangulo();
     t2=new Triangulo();
     t3=new Triangulo();

     t1.captura();
     t1.calcularArea();
     t1.calcularPerimetro();
     t1.imprimir();

     t2.captura();
     t2.calcularArea();
     t2.calcularPerimetro();
     t2.imprimir();

     t3.captura();
     t3.calcularArea();
     t3.calcularPerimetro();
     t3.imprimir();
  }
}

4.-ELABORAR UN PROGRAMA QUE CALCULE EL FACTORIAL DE "N" FACTORIALES.


PROCESO:

import javax.swing.JOptionPane;
public class Factorial
{
private int nùmero;
    private int fact=1;

    /**
     * @return the numero
     */
    public int getNumero() {
        return nùmero;
    }

    /**
     * @param numero the numero to set
     */
    public void setNumero(int numero) {
        this.nùmero = numero;
    }

    /**
     * @return the fact
     */
    public int getFact() {
        return fact;
    }

    /**
     * @param fact the fact to set
     */
    public void setFact(int fact) {
        this.fact = fact;
    }
    public void captura()
     {
        nùmero=Integer.parseInt(JOptionPane.showInputDialog("Nùmero:"));
     }
     public int calcularFactorial(int n)
     {
         if(n==1 || n==0)
         {
          return 1;
         }
          else
             {
           fact= n*calcularFactorial(n-1);
           return fact;
             }
     }
      public void imprimirFactorial()
        {
      JOptionPane.showMessageDialog(null, "El factorianl es:  " +fact);
        }
}

SOLUCIÓN:

public class SolucionFact
{
public static void main(String[]args)
   {
  //declarando los objetos
    Factorial n;
    //creando los objetos
    n=new Factorial();

    n.captura();
    n.calcularFactorial(n.getNumero());
    n.imprimirFactorial();
   }

}