martes, 8 de octubre de 2013

PEAJE DE CAMIONES

Haremos un programa que calcule cuanto tiene que pagar de peaje un camión. Teniendo como información los ejes que tiene un camión y su peso en toneladas. Nos referimos con eje de un camión a las lineas imaginarias de unión transversal, que coinciden con el lugar donde se encuentran las ruedas del camión ya que este es quien une las parejas de ruedas de manera paralela.

Problema:
Calcular el costo de peaje de camiones. Los camiones que llegan a una estación de peaje deben pagar $50.00 por cada eje, mas $100.00 por cada tonelada de peso total del camión.

Nota:  Y como en el programa anterior, usaremos dos clases, en la primera realizaremos el calculo y en la segunda haremos uso del programa.


1ra. Clase: PeajeDeCamiones

  • Diagrama UML











  • Diagrama de Flujo

  • Programa


package Peaje;
import javax.swing.JOptionPane;
public class PeajeDeCamiones {

    private int Ejes;
    private int Toneladas;
    private int PagoPorEje=50;
    private int PagoPorTonelada=100;
    private int PagoTotal;
    //encapsulamos nuestras variables
    public int getEjes() {
        return Ejes;
    }
    public void setEje(int Ejes) {
        this.Ejes = Ejes;
    }
    public int getToneladas() {
        return Toneladas;
    }
    public void setToneladas(int Toneladas) {
        this.Toneladas = Toneladas;
    }
    public int getPagoPorEje() {
        return PagoPorEje;
    }
    public void setPagoPorEje(int PagoPorEje) {
        this.PagoPorEje = PagoPorEje;
    }
    public int getPagoPorTonelada() {
        return PagoPorTonelada;
    }
    public void setPagoPorTonelada(int PagoPorTonelada) {
        this.PagoPorTonelada = PagoPorTonelada;
    }
    public int getPagoTotal() {
        return PagoTotal;
    }
    public void setPagoTotal(int PagoTotal) {
        this.PagoTotal = PagoTotal;
    }
    public void Captura(){
    Ejes=Integer.parseInt(JOptionPane.showInputDialog("¿CUANTOS EJES TIENE EL CAMION?:"));
    Toneladas=Integer.parseInt(JOptionPane.showInputDialog("¿CUANTAS TONELADAS PESA?:"));
    }
    public void Calculo(){
    PagoTotal=(Ejes*PagoPorEje)+(Toneladas*PagoPorTonelada);    
    }
    public void Imprime(){
       JOptionPane.showMessageDialog(null,"***PEAJE DE CAMIONES***\n\n   EJES DEL CAMION: "+Ejes
               +"\n   PESO POR TONELADAS: "+Toneladas+"\n   PAGO TOTAL: "+PagoTotal); // concatenamos los resultados
    }
}

2da. Clase: Usar



  • Programa


package Peaje;

import javax.swing.JOptionPane;
public class Usar {
    public static void main(String arg[]){
    PeajeDeCamiones P;
    P=new PeajeDeCamiones();
    
    P.Captura();
    P.Calculo();
    P.Imprime();
    }
}


Ejecutar programa

Ejecutamos el programa y la primero ventana nos pide los ejes que tiene el camión...



       
                        .... posteriormente nos pide su peso en toneladas...



... y por último nos envía los resultados, mostrandonos los datos capturados y el total a pagar.






Conclusión:
Este programa no requiere de mucha explicación. Realizamos el calculo del Peaje de camiones tomando en cuenta los ejes que pudiera tener el camión y su peso en toneladas, dando como resultado el total a pagar.

lunes, 7 de octubre de 2013

SALARIO DIARIO

Para demostrar la eficiencia de la Estructura de datos bajo el paradigma Orientado a objetos realizaremos el siguiente problema:

Problema:
Calcular el salario diario de un empleado con base a lo siguiente:
  1. Por cada hora trabajada recibe $17.50 para las primeras 8 hrs.
  2. Por cada hora extra trabajada recibe 1.5 veces el costo de la hora de trabajo dentro del horario normal.
Nota: Usaremos dos clases, la primera hará el calculo de el salario por medio de la captura de las horas trabajadas; y la segunda hará uso de la primera clase.

1ra. Clase: Calcular_Salario

  • Diagrama UML













  • Diagrama de Flujo
Recurriremos esta vez a un diagrama de flujo para entender de mejor manera el calculo de el salario diario.

El diagrama nos permite apreciar las condiciones que llevará el programa. Ya que el problema dado dice que una vez pasadas las primeras 8 horas de trabajo, las horas extras se pagarán al 1.5 veces de el pago normal. El diagrama nos indica cierta condición, para realizar los procedimientos correspondientes.
  • Programa
package Salario_Diario;
import javax.swing.JOptionPane;
public class Calcular_Salario {
    private String nombre; // agregamos el nombre de el empleado por simple estética
    private int HorasTrabajadas;
    private float SubSalario;
    private float SalarioTotal;
    private float PagoPorHora=17.50f;
    
    public String getNombre() {
        return nombre;
    }
    public void setNombre(String nombre) {
        this.nombre = nombre;
    }
    public int getHorasTrabajadas() {
        return HorasTrabajadas;
    }
    public void setHorasTrabajadas(int HorasTrabajadas) {
        this.HorasTrabajadas = HorasTrabajadas;
    }
    public float getSubSalario() {
        return SubSalario;
    }
    public void setSubSalario(float SubSalario) {
        this.SubSalario = SubSalario;
    }
    public float getSalarioTotal() {
        return SalarioTotal;
    }
    public void setSalarioTotal(float SalarioTotal) {
        this.SalarioTotal = SalarioTotal;
    }
    public float getPagoPorHora() {
        return PagoPorHora;
    }
    public void setPagoPorHora(float PagoPorHora) {
        this.PagoPorHora = PagoPorHora;
    }
    public void Captura(){
    nombre=JOptionPane.showInputDialog("NOMBRE:");
    HorasTrabajadas=Integer.parseInt(JOptionPane.showInputDialog("¿CUANTAS HORAS TRABAJÓ?"));//pedimos las horas trabajadas
    }
    public void CalcularSalario(){
        if (HorasTrabajadas>8){ //si la el empleado trabajó mas de ocho horas se realaizará el siguiente procedimiento
                SubSalario=(HorasTrabajadas-8)*(PagoPorHora*1.5f); //cuando se escribe un número con decimal se le agrega una f
                                                                   //de lo contrario nos marcará error
                SalarioTotal=(8*PagoPorHora)+SubSalario;
        }
        else{ // si la primera condición no se cumple entonces se realizará el siguiente procedimiento
                SalarioTotal=HorasTrabajadas*PagoPorHora
        }
    }
    public void ImprimirSalario(){
    JOptionPane.showMessageDialog(null,"***SALARIO DIARIO***\n\n"
                                  +"NOMBRES: "+nombre+"\n HORAS TRABAJADAS: "+HorasTrabajadas
                                  +"\nSALARIO DIARIO TOTAL: "+SalarioTotal);// imprimimos los resultados con una cadena
    }
}

2da. Clase: Usar

  • Programa
package Salario_Diario;
import javax.swing.JOptionPane;
public class Usar {
    public static void main (String arg[]){
        Calcular_Salario d;
        d=new Calcular_Salario();
        
        d.Captura(); //mandamos a llamar a los métodos
        d.CalcularSalario();
        d.ImprimirSalario();
    }
}

Ejecutar el Programa

Ejecutamos el programa....


...insertamos el nombre de el empleado....



                                     

                                     .... ahora insertamos las horas trabajadas...



... y estos son los resultados.







Conclusión:
En los problemas hay ciertos valores de algunas variables que se necesitan ser insertadas, pero hay otras, en las que su valor está definido, citamos los dos ejemplos en este problema. La mejor manera de organizar esto es estructurando lo datos y separar las clases en métodos.

TORRES DE HANOI

El segundo ejemplo más usado para la recursividad, es el juego de las Torres de Hanoi.
¿En que consiste el juego?
Representación Gráfica del juego
El juego tiene como elementos un base que contiene tres torres o varillas, en la primera, se encuentra una cierta cantidad de discos de diferentes tamaños ordenados de mayor a menor, de abajo hacia arriba. El juego consiste en llevar todos los discos a la tercera torre usando la segunda como auxiliar, tomando en cuenta las siguientes reglas:
  1. Solo se puede mover un disco a las vez, por lo tanto soló se moverá el disco que está arriba de cualquiera de las torres
  2. No se puede colocar un disco sobre otro mas pequeño
Este juego está basado en un leyenda muy antigua, aquí la tienen:

La leyenda...
“En el gran templo de Benarés, debajo de la cúpula que marca el centro del mundo, yace una base de bronce, en donde se encuentran acomodadas tres agujas de diamante, cada una del grueso del cuerpo de una abeja y de una altura de 50 cm aproximadamente. En una de estas agujas, Dios, en el momento de la Creación, colocó sesenta y cuatro discos de oro -el mayor sobre la base de bronce, y el resto de menor tamaño conforme se va ascendiendo-. Día y noche, incesantemente, los sacerdotes del templo se turnan en el trabajo de mover los discos de una aguja a otra de acuerdo con las leyes impuestas e inmutables de Brahma, que requieren que siempre haya algún sacerdote trabajando, que no muevan más de un disco a la vez y que deben colocar cada disco en alguna de las agujas de modo que no cubra a un disco de radio menor. Cuando los sesenta y cuatro discos hayan sido transferidos de la aguja en la que Dios los colocó, en el momento de la Creación, a otra aguja, el templo y los brahmanes se convertirán en polvo y, junto con ellos, el mundo desaparecerá...

.... y siguiendo con el tema....

Problema: 
  • Realizar un programa que muestre indicaciones para resolver el juego de las Torres de Hanoi, con n discos.
Nota: Usaremos dos clases, Torres De Hanoi y Jugar, en  la primera se harán las operaciones correspondientes y en el segundo se hará uso de la primera clase.


1ra. Clase: Torres.

  • Diagrama UML:










  • Programa:
package Torres_de_Hanoi;
import javax.swing.JOptionPane;
public class TorresDeHanoi {
    private int NumeroDeDiscos; // Esta variable nos indicará                                        cuantos discos van a usarse.
    private int NumeroDeMovimientos;
// Indicará el total de movimientos hechos para resolver el juego
    public int getNumeroDeDiscos(){//encapsulamiento de variables
        return NumeroDeDiscos;
    }
    public void setNumeroDeDiscos(int NumeroDeDiscos) {
        this.NumeroDeDiscos = NumeroDeDiscos;
    }
    public int getNumeroDeMovimientos() {
        return NumeroDeMovimientos;
    }
    public void setNumeroDeMovimientos(int NumeroDeMovimientos) {
        this.NumeroDeMovimientos = NumeroDeMovimientos;
    }
    public void Captura(){
    NumeroDeDiscos=Integer.parseInt(JOptionPane.showInputDialog("¿CUANTOS DISCOS SON?:"));
    }
    public void Intercambio(int NumDiscos, char A, char B, char C){ 
//Los parámetros se envían a la segunda clase
/*Tomemos en cuenta que el parámetro A, tomará el lugar de la torre inicio, la que inicialmente contiene todos los discos; el parámetro B, será la torre auxiliar; y el parámetro C será la torre destino, donde quedarán al final de juego todas las fichas*/      
       if (NumDiscos==1){
/*si el número de discos es igual a uno, lógicamente se moverá el disco de la torre inicio directamente a la de destino*/ 
           setNumeroDeMovimientos(getNumeroDeMovimientos()+1);
           JOptionPane.showMessageDialog(null, "Mover disco "+NumDiscos+" de la torre "+A+" a la torre "+C+"\nMOVIMIENTOS: "+NumeroDeMovimientos);
           }
        else{/*si la condicion primera no se cumple, quiere decir que se realizarán mas movimientos y serán los siguientes*/
            Intercambio(NumDiscos-1,A,C,B); 
/*... y entonces el método se llama a sí mismo, moviendo primero, el disco de la torre A, inicio, a la torre C, destino*/
            setNumeroDeMovimientos(getNumeroDeMovimientos()+1);
//se suman los movimientos efectuados
            JOptionPane.showMessageDialog(null,"Mover disco "+NumDiscos+" de la torre "+A+" a la torre "+C+"\nMOVIMIENTOS: "+NumeroDeMovimientos);
            Intercambio(NumDiscos-1,B,A,C);
/*... el método vuelve a llamarse a sí mismo, esta vez los parámetros donde de se encontraba la variable A ahora estará la variable B, para indicar el siguiente movimiento*/
           }
    }
    public void Movimientos() {
    JOptionPane.showMessageDialog(null,"TOTAL DE MOVIMIENTOS: "+NumeroDeMovimientos);
    }
}
    

2da. Clase: Jugar.

Nos vamos directamente con el programa...
  • Programa
package Torres_de_Hanoi;
import javax.swing.JOptionPane;
public class Jugar {
    public static void main(String arg[]){
     TorresDeHanoi k;
     
     k=new TorresDeHanoi(); 
// se declara y crea la variable que llama a la primera clase  
     k.Captura();                        
     k.Intercambio(k.getNumeroDeDiscos(),'A','B','C'); 
// se reciben los parámetros de el método Intercambio
     k.Movimientos();
    }
}

Ejecutar el programa

Aparte de los objetos corridos por el programa le acompañaré con una representación paso a paso de el juego.

Corremos el programa, desde la clase jugar, y la primera ventana nos pide el numero de discos a usar, en este caso, usaremos tres, y entonces nuestros elementos quedarán así...



y los movimientos serán de la siguiente manera.....


...movimiento #1...









.... movimiento #2...










.... movimiento #3....








.... movimiento #4....








.... movimiento #5....








.... movimiento #6....








.... movimiento #7....








... y finalmente.








Conclusión:
Las torres de Hanoi es uno de los ejemplos usados para el tema de recursividad, debido a que este juego forma parte de los problemas que se resuelven usando este termino. Se podría explicar la recursividad como un procedimiento que se usa cuando se requiere de que cierta acción, se tenga que hacer repetidas veces hasta cumplir con cierto límite, tenemos el ejemplo de las Torres de Hanoi, aquí se tiende a realizar la misma acción, misma que consiste en sacar una ficha de una torre y colocarla en otra, la veces necesarias hasta que todos los discos queden en la torre destino.