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 5.12

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

package com.jlm.ccb.ejercicios.capitulocinco;

/**
 * Clase que calcula el producto de los números impares del 1 al 15.
 * Ejercicio 5.12
 * @author LorettoTG
 * @version 1.0
 */
public class ProductoImpares {
    /**
     * Método encargado de calcular el producto de los números impares
     * que están presentes del 1 al 15.
     */
    public void calcularProducto() {
        int contador = 0;
        int resultado = 1;
        for (contador = 1; contador <= 15; contador++) {
            if ((contador % 2) != 0) {
                resultado *= contador;
            }
        }
        System.out.println("El producto de los números impares es: "
                + resultado);
    }

    /**
     * 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.
        ProductoImpares productoImpares = new ProductoImpares();
        productoImpares.calcularProducto();
    }
}