Como Programar en Java: Ejercicio 5.23

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

package com.jlm.ccb.ejercicios.capitulocinco;

/**
 * Clase encargada de convertir las siguientes
 * expresiones utilizando leyes de Morgan.
 * !( x < 5 ) && !( y >= 7 )
 * !( x == y ) || !( z != 5 )
 * !( ( x <= 8 ) && ( y > 4 ) )
 * !( ( x > 4 ) || ( y <= 6 ) )
 * Ejercicio 5.23
 * @author LorettoTG
 * @version 1.0
 */
public class LeyesMorgan {
    /**
     * Método encargado de convertir algunas condiciones
     * con las leyes de morgan. Si se imprime alguna leyenda
     * de no es cierto quiere decir que las leyes de Morgan
     * no fueron aplicadas correctamente.
     * @param x int Con el primer entero introducido.
     * @param y int Con el segundo entero introducido.
     * @param z int Con el tercer entero introducido.
     */
    public void calcular(int x, int y, int z) {
        if (((!(x < 5) && !(y >= 7)))
                != (((x >= 5) && (y < 7)))) {
            System.out.println("No es cierto 1");
        }


         if (((!(x == y) || !(z != 5)))
                 != ((x != y) || (z == 5))) {
             System.out.println("No es cierto 2");
         }

         if ((!((x <= 8) && (y > 4)))
                 != ((x > 8) || (y <= 4))) {
             System.out.println("No es cierto 3");
         }
         if ((!((x > 4) || (y <= 6)))
                 != ((x <= 4) && (y > 6))) {
             System.out.println("No es cierto 4");
         }
    }

    /**
     * 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.
        LeyesMorgan leyes = new LeyesMorgan();
        for (int x = 1; x <= 10; x++) {
            for (int y = 1; y <= 10; y++) {
                for (int z = 1; z <= 10; z++) {
                    leyes.calcular(x, y, z);
                }
            }
        }

    }
}

Como Programar en Java: Ejercicio 5.22

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

package com.jlm.ccb.ejercicios.capitulocinco;

/**
 * Clase encargada de imprimir diferentes patrones utilizando
 * seguidos.
 * Ejercicio 5.22
 * @author LorettoTG
 * @version 1.0
 */
public class ImprimirAsteriscosAstutos {
    /**
     * Método encargado de imprimir 4 diferentes patrones.
     */
    public void imprimirPatrones() {
        for (int renglon = 1; renglon <= 10; renglon++) {
            for (int columna = 1; columna <= 55; columna++) {
                if (columna <= 10) {
                    if (columna <= renglon) {
                        System.out.print('*');
                    } else {
                        System.out.print(' ');
                    }
                } else if (columna > 10 && columna <= 15) {
                    System.out.print(' ');
                } else if (columna > 15 && columna <= 25) {
                    if ((columna - 15) <= (11 - renglon)) {
                        System.out.print('*');
                    } else {
                        System.out.print(' ');
                    }
                } else if (columna > 25 && columna <= 30) {
                    System.out.print(' ');
                } else if (columna > 30 && columna <= 40) {
                    if ((columna - 30) < renglon) {
                        System.out.print(' ');
                    } else {
                        System.out.print('*');
                    }
                } else if (columna > 40 && columna <= 45) {
                    System.out.print(' ');
                } else {
                    if ((columna - 45) <= (10 - renglon)) {
                        System.out.print(' ');
                    } else {
                        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.
        ImprimirAsteriscosAstutos asteriscos = new ImprimirAsteriscosAstutos();
        asteriscos.imprimirPatrones();
    }
}

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.20

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

package com.jlm.ccb.ejercicios.capitulocinco;

/**
 * Clase encargada de calcular aproximaciones
 * al número PI.
 * Ejercicio 5.20
 * @author LorettoTG
 * @version 1.0
 */
public class AproximacionesPI {
    /**
     * Método encargado de calcular als aproximaciones
     * a la constante matematica PI.
     * @param terminos int con el numero de terminos a
     * calcular.
     * @return resultado double con la aproximacion a PI.
     */
    public double aproximar(int terminos) {
        double resultado = 4.0;
        for (int contador = 2; contador <= terminos; contador++) {
            resultado += (4.0 / ((contador * 2) - 1))
                            * Math.pow(-1, contador - 1);
        }
        return 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.
        AproximacionesPI pi = new AproximacionesPI();

        for (int contador = 1; contador <= 9999; contador++) {
            System.out.printf("%05d  %20.15f\n",
                    contador, pi.aproximar(contador));
        }
    }
}

Como Programar en Java: Ejercicio 5.17

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

package com.jlm.ccb.ejercicios.capitulocinco;

import java.util.Scanner;

/**
 * Clase encargada de calcular el valor total de venta
 * de todos los productos vendidos.
 * Ejercicio 5.17
 * @author LorettoTG
 * @version 1.0
 */
public class Almacen {
    /**
     * Método encargad de calcular el valor total de
     * venta de todos los productos vendidos.
     * @return resultado double con el total de la venta.
     */
    public double calcular() {
        /**
         * Contiene el total de la venta.
         */
        double resultado = 0.0;
        //Se crea un objeto Scanner para obtener la entrada
        //de datos del usuario.
        Scanner entrada = new Scanner(System.in);

        /**
         * Contiene el numero del producto.
         */
        int numeroProducto = 0;

        do {
            System.out.println("Deme el numero del producto: ");
            numeroProducto = entrada.nextInt();

            switch (numeroProducto) {
            case 0:
                break;
            case 1:
                resultado += cantidad() * 2.98;
                break;
            case 2:
                resultado += cantidad() * 4.5;
                break;
            case 3:
                resultado += cantidad() * 9.98;
                break;
            case 4:
                resultado += cantidad() * 4.49;
                break;
            case 5:
                resultado += cantidad() * 6.87;
                break;
            default:
                System.out.println("No es un producto valido");
            }
        } while (numeroProducto != 0);

        return resultado;
    }

    /**
     * Método encargado de verificar que la cantidad que
     * da el usuario sea mayor a cero.
     * @return cantidad int con la cantidad validada.
     */
    private int cantidad() {
        /**
         * Contiene la cantidad que se vendio de un producto.
         */
        int cantidad = 0;
        //Se crea un objeto Scanner para obtener la entrada
        //de datos del usuario.
        Scanner entrada = new Scanner(System.in);

        while (true) {
            System.out.println("Deme la cantidad vendida del producto: ");
            cantidad = entrada.nextInt();
            if (cantidad > 0) {
                return cantidad;
            } else {
                System.out.println("Escriba una cantidad mayor a cero.");
            }
        }
    }

    /**
     * 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 caracteristicas
        //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.
        Almacen almacen = new Almacen();

        //%.2f indica que espera un double y que tendra en el area de
        //decimales solo dos digitos.
        System.out.printf("El total de ventas es: %.2f", almacen.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");
        }
    }
}