Como Programar en Java: Ejercicio 5.21

Aquí esta el ejercicio 5.21 de Como Programar en Java séptima edición.

package com.jlm.ccb.ejercicios.capitulocinco;

/**
 * Clase encargada de calcular los Triples de Pitagoras.
 * Ejercicio 5.21
 * @author LorettoTG
 * @version 1.0
 */
public class TriplesPitagoras {
    /**
     * Método encargado de calcular los Triples de
     * Pitagoras por fuerza bruta en longitudes que van
     * desde 1 hasta 500 unidades.
     */
    public void calcular() {
        /**
         * Contiene la suma de los cuadrados de los dos lados
         * de un triangulo.
         */
        int sumaLados = 0;

        /**
         * Contiene el total de triples de pitagoras.
         */
        int contador = 0;
        for (int lado1 = 1; lado1 <= 500; lado1++) {
            for (int lado2 = 1; lado2 <= 500; lado2++) {
                for (int hipotenusa = 1; hipotenusa <= 500; hipotenusa++) {
                    sumaLados = (lado1 * lado1) + (lado2 * lado2);
                    if ((hipotenusa * hipotenusa) == sumaLados) {
                        System.out.println("Triples de pitágoras con:\n"
                                + "\tLado 1: " + lado1
                                + "\n\tLado 2: " + lado2
                                + "\n\tHipotenusa: " + hipotenusa);
                        contador++;
                    }
                }
            }
        }
        System.out.println("Existen un total de " + contador
                    + " triples de pitágoras.");
    }

    /**
     * Punto de entrada a la clase y a la aplicación.
     * @param args matriz de argumentos de cadena.
     */
    public static void main(String[] args) {
        //El operador new es el encargado de crear instancias de
        //una clase, es decir los objetos que tienen las características
        //de la clase. El operador new de Java es capaz de reservar la
        //memoria para un objeto de este tipo sabiendo los atributos que
        //tiene según la definición de la clase.
        TriplesPitagoras triplesPitagoras = new TriplesPitagoras();
        triplesPitagoras.calcular();
    }
}

Como Programar en Java: Ejercicio 5.16

Aquí esta el ejercicio 5.16 de Como Programar en Java séptima edición.

package com.jlm.ccb.ejercicios.capitulocinco;

import java.util.Scanner;

/**
 * Clase encargada de imprimir barras horizontales.
 * Ejercicio 5.16
 * @author LorettoTG
 * @version 1.0
 */
public class BarrasHorizontales {
    /**
     * Método encargado de imprimir una barra horizontal
     * @param numeroAsteriscos int con el número de asteriscos
     * a imprimir.
     */
    public void imprimir(int numeroAsteriscos) {
        for (int contador = 1; contador <= numeroAsteriscos; contador++) {
            System.out.print('*');
        }
        System.out.println();
    }

    /**
     * Punto de entrada a la clase y a la aplicación.
     * @param args matriz de argumentos de cadena.
     */
    public static void main(String[] args) {
        //El operador new es el encargado de crear instancias de
        //una clase, es decir los objetos que tienen las características
        //de la clase. El operador new de Java es capaz de reservar la
        //memoria para un objeto de este tipo sabiendo los atributos que
        //tiene según la definición de la clase.
        BarrasHorizontales barras = new BarrasHorizontales();

        //Se crea un objeto Scanner para obtener la entrada
        //de datos del usuario.
        Scanner entrada = new Scanner(System.in);

        /**
         * Contiene el contador para el ciclo.
         */
        int contador = 1;
        /**
         * Contiene el numero ingresado por el usuario.
         */
        int numeroAsteriscos = 0;

        do {
            System.out.print("Deme el primer numero: ");
            numeroAsteriscos = entrada.nextInt();

            if (numeroAsteriscos > 0 && numeroAsteriscos < 30) {
                barras.imprimir(numeroAsteriscos);
                contador++;
            } else {
                System.out.println("Ingrese un numero entre 1 y 30");
            }
        } while (contador <= 5);

    }
}

Como Programar en Java: Ejercicio 5.18

Aquí esta el ejercicio 5.18 de Como Programar en Java séptima edición.

package com.jlm.ccb.ejercicios.capitulocinco;

/**
 * Clase que calcula el interes compuesto.
 * Ejercicio 5.18
 * @author LorettoTG
 * @author Deitel - Base tomada de su libro.
 * @version 1.0
 */
public class InteresCompuestoEnteros {
     /**
     * Punto de entrada a la clase y a la aplicación.
     * @param args matriz de argumentos de cadena.
     */
    public static void main(String args[]) {
        /**
         * Monto que se deposita al final del periodo - año
         */
        int monto;
        /**
         * Monto inicial los dos ultimos son los decimales
         */
        int principal = 100000;
        /**
         * La tasa de interés.
         */
        double tasa;

        for (tasa = 5; tasa <= 10; tasa++) {
            System.out.println("Con tasa de interes del " + tasa + "%.");
            //Se muestra el encabezado de la tabla.
            System.out.printf("%s%20s\n", "Anio", "Monto en deposito");

            //calcula el monto en deposito para cada uno de diez años
            for (int anio = 1; anio <= 10; anio++) {
                //calcula el nuevo monto para el año especificado
                monto = (int) (principal * Math.pow(1.0 + (tasa / 100), anio));

                // muestra el año y el monto
                System.out.printf("%4d%,17d.%02d\n",
                        anio, monto / 100, monto % 100);
            }
            System.out.printf("\n\n");
        }
    }
}

Como Programar en Java: Ejercicio 4.18

Aquí esta el ejercicio 4.18 de Como Programar en Java séptima edición.

package com.jlm.ccb.ejercicios.capitulo4;

import java.util.Scanner;

/**
 * Clase que contiene los datos de un cliente.
 * Ejercicio 4.18
 * @author LorettoTG
 * @version 1.0
 *
 */
public class Cliente {
    /**
     * Contiene el número de cuenta.
     */
    int cuenta;
    /**
     * Contiene el saldo al inicio del mes.
     */
    double saldoInicio;
    /**
     * Contiene el total de todos los artículos cargados
     * por el cliente en el mes.
     */
    double totalArticulos;
    /**
     * Contiene el total de todos los créditos aplicados
     * a la cuenta del cliente en el mes.
     */
    double totalCreditos;
    /**
     * Contiene el límite de crédito permitido.
     */
    double limiteCredito;

    /**
     * Método que calcula el nuevo saldo con la siguiente
     * formula =saldo inicial + cargos - créditos
     * @param saldoInicio double con el total de todos los
     * artículos cargados por el cliente en el mes.
     * @param totalArticulos double con el total de todos
     * los créditos aplicados a la cuenta del cliente en el mes.
     * @param totalCreditos double con el límite de crédito
     * permitido.
     */
    public void calcularSaldo(double saldoInicio, 
            double totalArticulos, double totalCreditos) {
        double nuevoSaldo = saldoInicio + totalArticulos - totalCreditos;
        System.out.println("Su nuevo saldo es: " + nuevoSaldo);
        if (nuevoSaldo > limiteCredito) {
            System.out.println("Se excedió el límite de su crédito");
        }
    }

    /**
     * Este es un getter que obtiene el cuenta.
     * @return el cuenta int.
     */
    public int getCuenta() {
        return cuenta;
    }
    /**
     * Este es un setter que asigna el cuenta.
     * @param cuenta de tipo int el cuenta a asignar.
     */
    public void setCuenta(int cuenta) {
        this.cuenta = cuenta;
    }
    /**
     * Este es un getter que obtiene el saldoInicio.
     * @return el saldoInicio double.
     */
    public double getSaldoInicio() {
        return saldoInicio;
    }
    /**
     * Este es un setter que asigna el saldoInicio.
     * @param saldoInicio de tipo double el 
     * saldoInicio a asignar.
     */
    public void setSaldoInicio(double saldoInicio) {
        this.saldoInicio = saldoInicio;
    }
    /**
     * Este es un getter que obtiene el totalArticulos.
     * @return el totalArticulos double.
     */
    public double getTotalArticulos() {
        return totalArticulos;
    }
    /**
     * Este es un setter que asigna el totalArticulos.
     * @param totalArticulos de tipo double el 
     * totalArticulos a asignar.
     */
    public void setTotalArticulos(double totalArticulos) {
        this.totalArticulos = totalArticulos;
    }
    /**
     * Este es un getter que obtiene el totalCreditos.
     * @return el totalCreditos double.
     */
    public double getTotalCreditos() {
        return totalCreditos;
    }
    /**
     * Este es un setter que asigna el totalCreditos.
     * @param totalCreditos de tipo double el 
     * totalCreditos a asignar.
     */
    public void setTotalCreditos(double totalCreditos) {
        this.totalCreditos = totalCreditos;
    }
    /**
     * Este es un getter que obtiene el limiteCredito.
     * @return el limiteCredito double.
     */
    public double getLimiteCredito() {
        return limiteCredito;
    }
    /**
     * Este es un setter que asigna el limiteCredito.
     * @param limiteCredito de tipo double 
     * el limiteCredito a asignar.
     */
    public void setLimiteCredito(double limiteCredito) {
        this.limiteCredito = limiteCredito;
    }

    /**
     * Punto de entrada a la clase y a la aplicación.
     * @param args matriz de argumentos de cadena.
     */
    public static void main(String[] args) {
        Cliente cliente = new Cliente();
        //Se crea un objeto Scanner para obtener la entrada
        //de datos del usuario.
        Scanner entrada = new Scanner(System.in);

        System.out.println("Deme el numero de cuenta: ");
        cliente.setCuenta(entrada.nextInt());

        System.out.println("Deme el saldo al inicio del mes: ");
        cliente.setSaldoInicio(entrada.nextDouble());

        System.out.println("Deme el total de todos los articulos: ");
        cliente.setTotalArticulos(entrada.nextDouble());

        System.out.println("Deme el total de creditos: ");
        cliente.setTotalCreditos(entrada.nextDouble());

        System.out.println("Deme el límite de crédito: ");
        cliente.setLimiteCredito(entrada.nextDouble());

        cliente.calcularSaldo(cliente.getSaldoInicio(),
                cliente.getTotalArticulos(), cliente.getTotalCreditos());
    }
}

Como Programar en Java: Ejercicio 4.30

Aquí esta el ejercicio 4.30 de Como Programar en Java séptima edición.

package com.jlm.ccb.ejercicios.capitulo4;

import java.util.Scanner;

/**
 * Clase encargada de analizar un entero de 5
 * dígitos e indicar si es o no es palíndromo.
 * Ejercicio 4.30
 * @author LorettoTG
 * @version 1.0
 *
 */
public class PalindromoNumero {
    /**
     * Método encargado de analizar si el numero es
     * o no es un palíndromo, existen mejores formas
     * de realizarlo pero debemos utilizar lo
     * aprendido hasta este momento.
     */
    public void analizar() {
        //Se crea un objeto Scanner para obtener la entrada
        //de datos del usuario.
        Scanner entrada = new Scanner(System.in);
        System.out.println("Deme el entero de 5 digitos: ");
        int entero = entrada.nextInt();

        //En el caso del ciclo while: Primero se evalúa la condición de entrada
        //si es verdadera ejecuta las sentencias en su cuerpo, luego vuelve a
        //verificar la condición de entrada y hasta que sea falsa sale del ciclo.
        while ((entero < 9999) || (entero > 100000)) {
            System.out.println("No es un entero de 5 digitos");
            System.out.println("Deme el entero de 5 digitos: ");
            entero = entrada.nextInt();
        }

        //Si el primer dígito es igual al ultimo dígito
        if ((entero / 10000) == (entero % 10)) {
            //Se quita el primer dígito
            entero = entero % 10000;
            //Se quita el ultimo dígito
            entero = entero / 10;
            if ((entero / 100) == (entero % 10)) {
                System.out.println("Es un palíndromo");
            } else {
                System.out.println("No es un palíndromo");
            }
        } else {
            System.out.println("No es un palíndromo");
        }
    }

    /**
     * Punto de entrada a la clase y a la aplicación.
     * @param args matriz de argumentos de cadena.
     */
    public static void main(String[] args) {
        //El operador new es el encargado de crear instancias de
        //una clase, es decir los objetos que tienen las características
        //de la clase. El operador new de Java es capaz de reservar la
        //memoria para un objeto de este tipo sabiendo los atributos que
        //tiene según la definición de la clase.
        PalindromoNumero palindromo = new PalindromoNumero();
        palindromo.analizar();
    }
}

Como Programar en Java: Ejercicio 3.1

Ejercicio 3.1 de Como Programar en Java Séptima Edición.

package com.jlm.ccb.ejercicios.capitulo3; import javax.swing.JOptionPane; /**  * Objeto que crea la interfaz para  * realizar la suma de dos enteros.  * Ejercicio 3.1  * @author LorettoTG  * @version 1.0  *  */ public class SumaGrafico {   /**    * Punto de entrada a la clase y a la aplicación.    * @param args matriz de argumentos de cadena.    */   public static void main(String[] args) {     //Prompt al usuario para que introduzca el primer numero     int primerNumero = Integer.parseInt(         JOptionPane.showInputDialog("Deme el primer entero a sumar") );     //Prompt al usuario para que introduzca el segundo numero     int segundoNumero = Integer.parseInt(         JOptionPane.showInputDialog("Deme el segundo entero a sumar") );     //Creando mensaje, usando %d indicamos que esperamos un int,     String message = String.format("La suma es: %d",         (primerNumero + segundoNumero) );     //Despliega el mensaje de bienvenida al usuario por nombre     JOptionPane.showMessageDialog(null, message);   } }