Como Programar en Java: Ejercicio 6.34

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

package com.jlm.ccb.ejercicios.capituloseis;

import java.util.Random;
import java.util.Scanner;

/**
 * Clase encargada de realizar el juego de adivina
 * un número y arroja un mensaje dependiendo el
 * número de intentos que realizo el usuario.
 * Ejercicio 6.34
 * @author LorettoTG
 * @version 1.0
 */
public class AdivinaNumeroSecreto {
    //Se crea un objeto Scanner para obtener la entrada
    //de datos del usuario.
    static Scanner entrada = new Scanner(System.in);

    /**
     * Método encargado de generar un número aleatorio
     * entre 1 a 1000 e indicar si el usuario se acerco
     * o no al número.
     */
    public void adivinar() {
        Random aleatorio = new Random();
        int aAdivinar = aleatorio.nextInt(1000) + 1;
        int ingresado = 0;
        int contador = 0;

        System.out.println("Adivine un número entre 1 a 1000");

        while (aAdivinar != ingresado) {
            ingresado = entrada.nextInt();

            if (ingresado < aAdivinar) {
                System.out.println("Demasiado bajo. Intente de nuevo.");
                contador++;
            } else if (ingresado > aAdivinar) {
                System.out.println("Demasiado alto. Intente de nuevo.");
                contador++;
            } else {
                contador++;
                System.out.println("FELICIDADES. Adivino el número!");
                if (contador < 10) {
                    System.out.println("O ya sabía ustede el secreto, "
                            + "o tuvo suerte!");
                } else if (contador > 10) {
                    System.out.println("Debería haberlo hecho mejor.");
                } else {
                    System.out.println("Aja! Sabia usted el secreto!");
                }
            }
        }
    }

    /**
     * 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.
        AdivinaNumeroSecreto numero = new AdivinaNumeroSecreto();

        int opcion = 1;

        while (opcion == 1) {
            numero.adivinar();
            System.out.println("Quiere adivinar otro número? "
                    + "(1) Si, (Otro) No");
            opcion = entrada.nextInt();
        }
    }
}

Como Programar en Java: Ejercicio 6.34

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

package com.jlm.ccb.ejercicios.capituloseis;

import java.util.Random;
import java.util.Scanner;

/**
 * Clase encargada de realizar el juego de adivina
 * un número y arroja un mensaje dependiendo el
 * número de intentos que realizo el usuario.
 * Ejercicio 6.34
 * @author LorettoTG
 * @version 1.0
 */
public class AdivinaNumeroSecreto {
    //Se crea un objeto Scanner para obtener la entrada
    //de datos del usuario.
    static Scanner entrada = new Scanner(System.in);

    /**
     * Método encargado de generar un número aleatorio
     * entre 1 a 1000 e indicar si el usuario se acerco
     * o no al número.
     */
    public void adivinar() {
        Random aleatorio = new Random();
        int aAdivinar = aleatorio.nextInt(1000) + 1;
        int ingresado = 0;
        int contador = 0;

        System.out.println("Adivine un número entre 1 a 1000");

        while (aAdivinar != ingresado) {
            ingresado = entrada.nextInt();

            if (ingresado < aAdivinar) {
                System.out.println("Demasiado bajo. Intente de nuevo.");
                contador++;
            } else if (ingresado > aAdivinar) {
                System.out.println("Demasiado alto. Intente de nuevo.");
                contador++;
            } else {
                contador++;
                System.out.println("FELICIDADES. Adivino el número!");
                if (contador < 10) {
                    System.out.println("O ya sabía ustede el secreto, "
                            + "o tuvo suerte!");
                } else if (contador > 10) {
                    System.out.println("Debería haberlo hecho mejor.");
                } else {
                    System.out.println("Aja! Sabia usted el secreto!");
                }
            }
        }
    }

    /**
     * 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.
        AdivinaNumeroSecreto numero = new AdivinaNumeroSecreto();

        int opcion = 1;

        while (opcion == 1) {
            numero.adivinar();
            System.out.println("Quiere adivinar otro número? "
                    + "(1) Si, (Otro) No");
            opcion = entrada.nextInt();
        }
    }
}

Como Programar en Java: Ejercicio 6.33

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

package com.jlm.ccb.ejercicios.capituloseis;

import java.util.Random;
import java.util.Scanner;

/**
 * Clase encargada de realizar el juego de adivina
 * un número.
 * Ejercicio 6.33
 * @author LorettoTG
 * @version 1.0
 */
public class AdivinaNumero {
    //Se crea un objeto Scanner para obtener la entrada
    //de datos del usuario.
    static Scanner entrada = new Scanner(System.in);

    /**
     * Método encargado de generar un número aleatorio
     * entre 1 a 1000 e indicar si el usuario se acerco
     * o no al número.
     */
    public void adivinar() {
        Random aleatorio = new Random();
        int aAdivinar = aleatorio.nextInt(1000) + 1;
        int ingresado = 0;

        System.out.println("Adivine un número entre 1 a 1000");

        while (aAdivinar != ingresado) {
            ingresado = entrada.nextInt();

            if (ingresado < aAdivinar) {
                System.out.println("Demasiado bajo. Intente de nuevo.");
            } else if (ingresado > aAdivinar) {
                System.out.println("Demasiado alto. Intente de nuevo.");
            } else {
                System.out.println("FELICIDADES. Adivino el número!");
            }
        }
    }

    /**
     * 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.
        AdivinaNumero numero = new AdivinaNumero();

        int opcion = 1;

        while (opcion == 1) {
            numero.adivinar();
            System.out.println("Quiere adivinar otro número? "
                    + "(1) Si, (Otro) No");
            opcion = entrada.nextInt();
        }
    }
}

Como Programar en Java: Ejercicio 5.27

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

package com.jlm.ccb.ejercicios.capitulocinco;

/**
 * Clase encargada de simular una salida de un ciclo
 * sin utilizar continue.
 * Ejercicio 5.27
 * @author LorettoTG
 * @version 1.0
 */
public class NoContinue {
    /**
     * Punto de entrada a la clase y a la aplicación.
     * @param args matriz de argumentos de cadena.
     */
    public static void main(String[] args) {
        for (int cuenta = 1; cuenta <= 10; cuenta++) {
            if (cuenta != 5) {
                System.out.printf("%d ", cuenta);
            }
        }
        System.out.println("\nSe uso continue para omitir imprimir 5");
    }
}

Como Programar en Java: Ejercicio 5.25

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

package com.jlm.ccb.ejercicios.capitulocinco;

import java.util.Scanner;

/**
 * Clase encargada de imprimir un Rombo
 * con asteriscos.
 * Ejercicio 5.25
 * @author LorettoTG
 * @version 1.0
 */
public class RomboTamano {
    /**
     * Método encargado de imprimir un Rombo
     * con asteriscos.
     * @param numero int Con un numero impar, si no
     * fuera impar el metodo lo indicara.
     */
    public void imprimir(int numero) {
        if (numero < 0 || numero > 19) {
            System.out.println("Debe estar entre 1 y 19 el numero.");
        } else {
            if (numero % 2 == 0) {
                System.out.println("No es un número impar.");
            } else {
                int media = numero / 2 + 1;
                for (int renglon = 1; renglon <= numero; renglon++) {
                    for (int columna = 1; columna <= numero;
                            columna++) {
                        if (renglon <= media) {
                            if (((media - renglon) < columna)
                                    && (columna < (media + renglon))) {
                                System.out.print('*');
                            } else {
                                System.out.print(' ');
                            }
                        } else {
                            if (((renglon - media) < columna)
                                    && (columna < (media * 2
                                    - (renglon - media)))) {
                                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.
        RomboTamano rombo = new RomboTamano();

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

        System.out.println("Deme un número impar: ");
        int numero = entrada.nextInt();
        rombo.imprimir(numero);
    }
}

Como Programar en Java: Ejercicio 5.24

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

package com.jlm.ccb.ejercicios.capitulocinco;

/**
 * Clase encargada de imprimir un Rombo
 * con asteriscos.
 * Ejercicio 5.24
 * @author LorettoTG
 * @version 1.0
 */
public class Rombo {
    /**
     * Método encargado de imprimir un Rombo
     * con asteriscos.
     */
    public void imprimir() {
        int media = 9 / 2 + 1;
        for (int renglon = 1; renglon <= 9; renglon++) {
            for (int columna = 1; columna <= 9; columna++) {
                if (renglon <= media) {
                    if (((media - renglon) < columna)
                            && (columna < (media + renglon))) {
                        System.out.print('*');
                    } else {
                        System.out.print(' ');
                    }
                } else {
                    if (((renglon - media) < columna)
                            && (columna < (media * 2 - (renglon - media)))) {
                        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.
        Rombo rombo = new Rombo();
        rombo.imprimir();
    }
}

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();
    }
}