Programacion Ejercicios UD2

De MediaWiki
Saltar a: navegación, buscar
  • En este punto entraría:
  • Estructuras condicionales: if / switch.
  • Estructuras de repetición: while, do-while, for.
  • Estructuras de salto: break/continue.
  • Control de excepciones.
  • Debugger de programas.


  • Notas:
  • La estructura condicional 'if-else' ya la hemos trabajado en los ejercicios anteriores.
  • Utiliza printf cuando tengas que mostrar valores de variables.
  • Como no hemos visto los tipos de datos array no vamos a realizar ejercicios con la instrucción for/in
  • Para hacer ejercicios más variados, introducimos un método de la clase Math, de nombre random.
Este método devuelve un número de tipo double entre 0.0 y 1.0.
Si queremos obtener un entero entre 1 y 100 (por ejemplo), tendremos que escribir: int numAleatorio = (int)(1+Math.random()*99)
Debemos aplicar por tanto la fórmula: (int)(Math.random()*(num_maximo-num_minimo)+num_minimo).


Ejercicios Estructuras condicionales

  • Introduce un número por teclado entre 1-10.
Crea un tipo enumerado que guarde los valores posibles para una nota: MUY DEFICIENTE, INSUFICIENTE, SUFICIENTE, BIEN, NOTABLE y SOBRESALIENTE.
Guarda en una variable del tipo anterior, el valor correspondiente a su valor numérico, siendo:
  • 1,2: MUY_DEFICIENTE
  • 3,4: INSUFICIENTE
  • 5: SUFICIENTE
  • 6: BIEN
  • 7,8: NOTABLE
  • 9,10: SOBRESALIENTE
En caso de poner un número no válido se mostrará un mensaje de error informando del problema. Utiliza la opción 'default' para determinar si es inválido.
En caso de estar correcto, saldrá un mensaje con el texto: "CON EL NÚMERO XXX HAS OBTENIDO LA NOTA:YYYYY"
Nota: Intenta hacer una versión de este programa utilizando las sentencias if/else.


  • Lee una palabra desde el teclado, teniendo que empezar por una vocal.
Obtén la primera letra de la misma, convertida a mayúscula.
En función de la letra inicial deberás formas una frase, sumando palabras a una cadena.
  • Si la letra es 'A', deberás añadir a la cadena la palabra 'AMOR' y las palabras asociadas a las letras E e I.
  • Si la letra es 'E' deberás añadir a la cadena la palabra ' ES ' y las palabras asociadas a la letra I.
  • Si la letra es 'I' deberás añadir a la cadena la palabra 'MARAVILLOSO '
  • En cualquier otro caso, la cadena guardará el texto ' NO ESTÁ BIEN'.
Al final deberá imprimirse una cadena con el texto: PALABRA_INICIAL = cadena
Nota: Vas a tener que hacer uso del método charAt: Nos devuelve el carácter que se encuentra en la posición indicada por el parámetro int.


Solución Ejercicios Estructuras condicionales

  • Introduce un número por teclado entre 1-10.
Crea un tipo enumerado que guarde los valores posibles para una nota: MUY DEFICIENTE, INSUFICIENTE, SUFICIENTE, BIEN, NOTABLE y SOBRESALIENTE.
Guarda en una variable del tipo anterior, el valor correspondiente a su valor numérico, siendo:
  • 1,2: MUY_DEFICIENTE
  • 3,4: INSUFICIENTE
  • 5: SUFICIENTE
  • 6: BIEN
  • 7,8: NOTABLE
  • 9,10: SOBRESALIENTE
En caso de poner un número no válido se mostrará un mensaje de error informando del problema. Utiliza la opción 'default' para determinar si es inválido.
En caso de estar correcto, saldrá un mensaje con el texto: "CON EL NÚMERO XXX HAS OBTENIDO LA NOTA:YYYYY"
  1.  /**
  2.  * Clase: EjerciciosCondicionales
  3.  * En esta clase están implementados todos los ejercicios relacionados con if-switch
  4.  * @author Angel Fernández
  5.  * @version: 04/10/2017 V1.0
  6.  */
  7. public class EjerciciosCondicionales {
  8.  
  9.     static Scanner scanner;
  10.     enum NotasPosibles {MUY_DEFICIENTE,INSUFICIENTE,SUFICIENTE,BIEN,NOTABLE,SOBRESALIENTE};
  11.  
  12.  
  13.     /**
  14.      * Nombre: resolverEjercicioCondicional1()
  15.      * Resuelve el ejercicio 1 de la lista de ejercicios de este bloque
  16.      * Introduce un número por teclado entre 1-10.
  17.      *   Crea un tipo enumerado que guarde los valores posibles para una nota: MUY DEFICIENTE, INSUFICIENTE, SUFICIENTE, BIEN, NOTABLE y SOBRESALIENTE.
  18.      *   Guarda en una variable del tipo anterior, el valor correspondiente a su valor numérico, siendo:
  19.      *  <ul>
  20.      *  <li>1,2: MUY_DEFICIENTE</li>
  21.      *  <li>3,4: INSUFICIENTE</li>
  22.      *  <li>5: SUFICIENTE</li>
  23.      *  <li>6: BIEN</li>
  24.      *  <li>7,8: NOTABLE</li>
  25.      *  <li>9,10: SOBRESALIENTE</li></ul>
  26.      *   Al final, saldrá un mensaje con el texto: "CON EL NÚMERO XXX HAS OBTENIDO LA NOTA:YYYYY"
  27.      */
  28.     public static void resolverEjercicioCondicional1(){
  29.         byte numero=0;  // Número que se lee por teclado. Llega un byte.
  30.         NotasPosibles nota=NotasPosibles.MUY_DEFICIENTE;
  31.         boolean valido = true;  // Variable auxiliar que utilizaremos para saber si el número está entre 1-10
  32.        
  33.         System.out.println("Introduce un número:");
  34.         numero = scanner.nextByte();
  35.        
  36.         switch(numero){
  37.             case 1:     // Como le damos un valor inicial podríamos no poner las opciones de 1-2
  38.             case 2:
  39.                     nota = NotasPosibles.MUY_DEFICIENTE;
  40.                     break;
  41.             case 3:
  42.             case 4:
  43.                     nota = NotasPosibles.INSUFICIENTE;
  44.                     break;
  45.             case 5:
  46.                     nota = NotasPosibles.SUFICIENTE;
  47.                     break;
  48.             case 6:
  49.                     nota = NotasPosibles.BIEN;
  50.                     break;
  51.             case 7:
  52.             case 8:
  53.                     nota = NotasPosibles.NOTABLE;
  54.                     break;
  55.             case 9:
  56.             case 10:
  57.                     nota = NotasPosibles.SOBRESALIENTE;
  58.                     break;
  59.             default:
  60.                     valido = false;
  61.         }  // Fin del switch
  62.        
  63.         if (valido){
  64.             System.out.printf("CON EL NÚMERO %d HAS OBTENIDO LA NOTA %s",numero,nota);
  65.         }
  66.         else{
  67.             System.out.printf("El valor introducido '%s' no es válido.",numero);
  68.         }
  69.     }   // Fin del método resolverEjercicioCondicional1
  70.  
  71. }  // Fin de la clase EjerciciosCondicionales


  • Lee una palabra desde el teclado, teniendo que empezar por una vocal.
Obtén la primera letra de la misma, convertida a mayúscula.
En función de la letra inicial deberás formas una frase, sumando palabras a una cadena.
  • Si la letra es 'A', deberás añadir a la cadena la palabra 'AMOR' y las palabras asociadas a las letras E e I.
  • Si la letra es 'E' deberás añadir a la cadena la palabra ' ES ' y las palabras asociadas a la letra I.
  • Si la letra es 'I' deberás añadir a la cadena la palabra 'MARAVILLOSO '
  • En cualquier otro caso, la cadena guardará el texto ' NO ESTÁ BIEN'.
Al final deberá imprimirse una cadena con el texto: PALABRA_INICIAL = cadena
  1.      /**
  2.      * Nombre: resolverEjercicioCondicional2()
  3.      * Resuelve el ejercicio 2 de la lista de ejercicios de este bloque
  4.      * Lee una palabra desde el teclado, teniendo que empezar por una vocal.
  5.      * Obtén la primera letra de la misma, convertida a mayúscula.
  6.      * En función de la letra inicial deberás formas una frase, sumando palabras a una cadena.
  7.      * <ul><li>Si la letra es 'A', deberás añadir a la cadena la palabra 'AMOR' y las palabras asociadas a las letras E e I.</li>
  8.      * <li>Si la letra es 'E' deberás añadir a la cadena la palabra ' ES ' y las palabras asociadas a la letra I.</li>
  9.      * <li>Si la letra es 'I' deberás añadir a la cadena la palabra ' MARAVILLOSO '</li>
  10.      * <li>En cualquier otro caso, la cadena guardará el texto ' NO ESTÁ BIEN'.</li>
  11.      * </ul>
  12.      * Al final deberá imprimirse una cadena con el texto: PALABRA_INICIAL = cadena     */
  13.     public static void resolverEjercicioCondicional2(){
  14.         String cadena="";           // Cadena a leer por teclado
  15.         char letra = (char)0;       // Guarda la primera letra de la palabra
  16.         String frase="";            // Frase que vamos a ir formando en función de la letra
  17.        
  18.         System.out.println("Introduce una palabra que empieze por una letra:");
  19.         cadena = scanner.nextLine();
  20.        
  21.         cadena = cadena.toUpperCase();  // Guardamos la conversión porque la tenemos que mostrar al final
  22.         letra = cadena.charAt(0);
  23.         switch (letra){ // Si no vamos a hacer uso de la variable letra para nada más podríamos poner directamente la expresión
  24.             case 'A':
  25.                       frase+="AMOR";
  26.             case 'E':
  27.                       frase+=" ES ";
  28.             case 'I':
  29.                       frase+="MARAVILLOSO";
  30.                       break;
  31.             default:
  32.                       frase="NO ESTA BIEN";
  33.         }   // fin del switch
  34.        
  35.         System.out.printf("%s = %s%n",cadena,frase);
  36.        
  37.     }


Ejercicios Estructuras repetitivas

  • Calcula la suma de los 100 primeros números, la media y raíz cuadrada de la suma.


  • Lee por teclado 4 números. Indica cual de ellos es mayor.
Utiliza una estructura de repetición para leer los números.
Haz una ejecución paso a paso utilizando el modo debugger.


  • Modifica el ejercicio anterior.
Lee inicialmente un número que indique cuantas veces se va a leer del teclado un número.
Lee un número del teclado la cantidad de veces indicada anteriormente, indicando en la cadena de texto el número leído (Introduce el numero 1: numero 2:....)
Muestra por pantalla cual es el mayor.
Muestra por pantalla la suma de los número leídos y cuantos números fueron leídos.
Pon un punto de interrupción en la línea siguiente a donde realizas la lectura del número y ejecuta paso a paso hasta la lectura del siguiente número. Después elimina el punto de interrupción y continúa la ejecución.
Pon un punto de interrupción dentro del if donde compruebas cual es el número mayor. Cuando pare, comprueba cual es el número mayor guardado hasta el momento y cual va a ser el nuevo número mayor. Comprueba, sin cambiar de línea, cual será la suma del nuevo número sobre la suma total hasta ese momento (utilizando una expresión).


  • Lee por teclado una cadena y repite la lectura de la cadena hasta que se pulse enter (sin escribir nada).
Concatena las cadenas leídas separándalos por un espacio en blanco.
Muestra por pantalla la cadena final con la concatenación de todas las palabras.


  • Suma los números pares entre dos números indicados por teclado. Muestra por pantalla la suma de dichos números y cuantos números pares e impares fueron encontrados.
Establece un punto de interrupción dentro del bucle en el que la ejecución del programa pare cuando el número de pares sea mayor a 2. Continúa la ejecución línea a línea hasta procesar el siguiente número. Después quita el punto de interrupción y ejecuta el código hasta la primera línea después del bucle (utiliza la opción 'ejecutar hasta el cursor' dentro del modo depuración).


  • Mientras la suma de los números leídos por teclado sea inferior a 5000 se seguirá pidiendo números por teclado.
Al alcanzar esa cifra, se mostrará la suma y cuantos números fueron introducidos, indicando el número menor y el número mayor de todos los introducidos.


  • Se quiere leer desde el teclado notas de los alumnos.
Dichas notas deben estar entre los valores 1 y 10 incluidos, con decimales.
Se llevará cuenta del número de veces que el usuario introdujo una nota que no cumpliera el criterio anterior, informando del problema.
También se llevará cuenta del número de notas introducidas para obtener una media.
Se parará de introducir notas cuando la nota introducida sea el número -1. Esta nota no se contabilizará como nota mal introducida.
Al finalizar el programa deberá mostrar el número de notas mal introducidas, el número de notas bien introducidas y la media de todas ellas.


  • Haz un programa en el que el genere un número entero aleatorio entre 1 y 100.
El usuario intentará adivinar el número generado.
El programa contará los intentos del usuario por adivinar el número.
Cada vez que el usuario introduzca un número el programa informará si el número es mayor o menor al número generado.
Cuando el usuario adivine el número se mostrará el número de intentos que ha utilizado para adivinar el número.


  • Lee una frase por teclado y muéstrela del revés. Por ejemplo, si ponemos 'casa' debe mostrar 'asac'.


Solución Ejercicios Estructuras repetitivas

  • Calcula la suma de los 100 primeros números, la media y raíz cuadrada de la suma.
  1.      /**
  2.      * Nombre: resolverEjercicioRepeticion1()
  3.      * Resuelve el ejercicio 1 de la lista de ejercicios de este bloque
  4.      */
  5.     public static void resolverEjercicioRepeticion1(){
  6.         int suma=0;         // Guarda la suma de los 100 primeros números
  7.         float media=0f;     // Guarda la media de los 100 primeros números
  8.         double raiz=0d;     // Guarda la raíz cuadrada de los
  9.        
  10.         for (int cont=1;cont<=100;cont++){
  11.             suma+=cont;
  12.         }
  13.         media = suma/100f;
  14.         raiz = Math.sqrt(suma);
  15.        
  16.         System.out.printf("La suma da como resultado:%d%nLa media es %,.2f%nLa ráiz cuadrada de la suma es %,.6f",suma,media,raiz);
  17.        
  18.     } // Fin del método resolverEjercicioRepeticion1


  • Lee por teclado 4 números. Indica cual de ellos es mayor.
Utiliza una estructura de repetición para leer los números.
  1.     /**
  2.      * Nombre: resolverEjercicioRepeticion2()
  3.      * Resuelve el ejercicio 2 de la lista de ejercicios de este bloque
  4.      */
  5.     public static void resolverEjercicioRepeticion2(){
  6.        
  7.         int numero=0;   // Numero a leer por teclado
  8.         int mayor=0;    // Guarda el número mayor
  9.        
  10.         for(int cont=0;cont<4;cont++){  // Leemos cuatro números
  11.             System.out.println("\nIntroduce un número:");
  12.             numero = scanner.nextInt();
  13.            
  14.             if (numero>mayor){
  15.                 mayor=numero;
  16.             }
  17.         }
  18.         System.out.printf("El número mayor es %d%n",mayor);
  19.        
  20.        
  21.     }   // Fin del método resolverEjercicioRepeticion2


  • Modifica el ejercicio anterior.
Lee inicialmente un número que indique cuantas veces se va a leer del teclado.
Lee un número del teclado la cantidad de veces indicada anteriormente, indicando en la cadena de texto el número leído (Introduce el numero 1: numero 2:....)
Muestra por pantalla cual es el mayor.
Muestra por pantalla la suma de los número leídos y cuantos números fueron leídos.
  1.      /**
  2.      * Nombre: resolverEjercicioRepeticion3()
  3.      * Resuelve el ejercicio 3 de la lista de ejercicios de este bloque
  4.      */
  5.     public static void resolverEjercicioRepeticion3(){
  6.        
  7.         byte numeroVecesLeer=0; // Número de veces a leer por teclado. Suponemos que siempre sera menor a 128
  8.         int numero=0;   // Numero a leer por teclado
  9.         int mayor=0;    // Guarda el número mayor
  10.         long sumaNumeros=0L;    // Guarda la suma de los números
  11.        
  12.         System.out.println("\nIndica el número de veces a leer del teclado:");
  13.         numeroVecesLeer = scanner.nextByte();
  14.        
  15.         for(int cont=0;cont<numeroVecesLeer;cont++){  // Leemos los números indicados
  16.             System.out.printf("\nIntroduce un número %d:", cont+1); // Sumamos uno para que empiece en 0. Podríamos hacer que el bucle empezara en 1 hasta cont<=numero.
  17.             numero = scanner.nextInt();
  18.             sumaNumeros += numero;
  19.             if (numero>mayor){
  20.                 mayor=numero;
  21.             }
  22.         }
  23.         System.out.printf("El número mayor es:%d%n",mayor);
  24.         System.out.printf("La suma de todos los números es:%d%n",sumaNumeros);
  25.         System.out.printf("Fueron leídos %d números%n",numeroVecesLeer);
  26.        
  27.        
  28.     }   // Fin del método resolverEjercicioRepeticion3


  • Lee por teclado una cadena y repite la lectura de la cadena hasta que se pulse enter (sin escribir nada).
Concatena las cadenas leídas separándalos por un espacio en blanco.
Muestra por pantalla la cadena final con la concatenación de todas las palabras.
  1.      /**
  2.      * Nombre: resolverEjercicioRepeticion4()
  3.      * Resuelve el ejercicio 4 de la lista de ejercicios de este bloque
  4.      */
  5.     public static void resolverEjercicioRepeticion4(){
  6.         String cadenaFinal="";  // Concatena las cadenas leídas del teclado
  7.         String cadena="";       // Cadena leís por teclado.
  8.        
  9.         do{
  10.             System.out.println("\nIntroduce una cadena:");
  11.             cadena = scanner.nextLine();
  12.            
  13.             cadenaFinal += cadena + " ";    // La útlima palabra llevará un espacio en blanco.
  14.         }while(!cadena.equals(""));     // Podríamos poner cadena.length()>0
  15.        
  16.         System.out.printf("La cadena final es:%s%n",cadenaFinal);
  17.        
  18.     }  // Fin del método resolverEjercicioRepeticion4


  • Suma los números pares entre dos números indicados por teclado. Muestra por pantalla la suma de dichos números y cuantos números pares e impares fueron encontrados.
  1.      /**
  2.      * Nombre: resolverEjercicioRepeticion5()
  3.      * Resuelve el ejercicio 5 de la lista de ejercicios de este bloque
  4.      */
  5.     public static void resolverEjercicioRepeticion5(){
  6.  
  7.         short numeroInicial=0,numeroFinal=0; // Números introducidos por teclado. Suponemos que llega con el tipo short
  8.         short contNumPares=0,contNumImpares=0;
  9.         long suma=0l;
  10.        
  11.         System.out.println("Introduce el número inicial:");
  12.         numeroInicial = scanner.nextShort();
  13.        
  14.         System.out.println("Introduce el número final:");
  15.         numeroFinal = scanner.nextShort();
  16.        
  17.         for(short cont=numeroInicial;cont<=numeroFinal;cont++){
  18.             if (cont%2==0){ // Número par
  19.                 contNumPares++;
  20.             }
  21.             else{
  22.                 contNumImpares++;
  23.             }
  24.             suma += cont;
  25.         }
  26.        
  27.         System.out.printf("La suma total es:%,d%nNúmeros pares:%d - Números impares:%d%n",suma,contNumPares,contNumImpares);
  28.        
  29.     }  // Fin del método resolverEjercicioRepeticion5


  • Mientras la suma de los números leídos por teclado sea inferior a 5000, se seguirá pidiendo números por teclado.
Al alcanzar esa cifra, se mostrará la suma y cuantos números fueron introducidos, indicando el número menor y el número mayor de todos los introducidos.
  1.      /**
  2.      * Nombre: resolverEjercicioRepeticion6()
  3.      * Resuelve el ejercicio 6 de la lista de ejercicios de este bloque
  4.      */
  5.     public static void resolverEjercicioRepeticion6(){
  6.  
  7.         int numero=0;           // Número leído del teclado
  8.         long suma=0l;
  9.         byte contNumeros=0;     // Contador de números introducidos
  10.        
  11.        
  12.         while(suma<5000){
  13.             System.out.println("Introduce un número:");
  14.             numero = scanner.nextInt();
  15.             suma +=numero;
  16.             contNumeros++;
  17.         }
  18.        
  19.         System.out.printf("La suma total de números es de %,d%nFueron introducidos %d numeros.%n",suma,contNumeros);
  20.        
  21.     }  // Fin del método resolverEjercicioRepeticion6


  • Se quiere leer desde el teclado notas de los alumnos.
Dichas notas deben estar entre los valores 1 y 10 incluidos, con decimales.
Se llevará cuenta del número de veces que el usuario introdujo una nota que no cumpliera el criterio anterior, informando del problema.
También se llevará cuenta del número de notas introducidas para obtener una media.
Se parará de introducir notas cuando la nota introducida sea el número -1. Esta nota no se contabilizará como nota mal introducida.
Al finalizar el programa deberá mostrar el número de notas mal introducidas, el número de notas bien introducidas y la media de todas ellas.
  1.      /**
  2.      * Nombre: resolverEjercicioRepeticion7()
  3.      * Resuelve el ejercicio 7 de la lista de ejercicios de este bloque
  4.      */
  5.     public static void resolverEjercicioRepeticion7(){
  6.         float nota=0f;  // Nota que se lee por teclado
  7.         float suma=0f;  // Suma todas las notas para calcular la media.
  8.         byte contNotasCorrectas=0;  // Contador que lleva cuenta de las notas correctamente introducidas
  9.         byte contNotasErroneas=0;   // Contador que lleva cuenta de las notas mal introducidas (no están entre 1-10)
  10.         float media=0f; //Guarda la media de todas las notas.
  11.  
  12.         do {
  13.             System.out.println("Introduce una nota entre 1 y 10:");
  14.             nota = scanner.nextFloat();
  15.            
  16.             if ((nota>10) || (nota<1)){
  17.                 if ((int)nota != -1){
  18.                     contNotasErroneas++;
  19.                     System.out.println("Nota mal introducida (debe estar entre 1 y 10)\n");
  20.                 }
  21.             }
  22.             else{
  23.                 suma+=nota;
  24.                 contNotasCorrectas++;
  25.             }
  26.            
  27.         }while((int)nota != -1);   // No se puede poner ==-1 ya que los float/double no son exactos.Necesario cast
  28.  
  29.         media = suma/contNotasCorrectas;
  30.         System.out.printf("El número de notas incorrectas fue de %d%n",contNotasErroneas);
  31.         System.out.printf("El número de notas correctas fue de %d y la media es de %,.2f%n",contNotasCorrectas,media);
  32.        
  33.     }   // Fin del método resolverEjercicioRepeticion7



  • Haz un programa en el que el genere un número entero aleatorio entre 1 y 100.
El usuario intentará adivinar el número generado.
El programa contará los intentos del usuario por adivinar el número.
Cada vez que el usuario introduzca un número el programa informará si el número es mayor o menor al número generado.
Cuando el usuario adivine el número se mostrará el número de intentos que ha utilizado para adivinar el número.
  1.      /**
  2.      * Nombre: resolverEjercicioRepeticion8()
  3.      * Resuelve el ejercicio 8 de la lista de ejercicios de este bloque
  4.      */
  5.     public static void resolverEjercicioRepeticion8(){
  6.         int numeroAleatorio=0;  // Guardará el número generado
  7.         byte numIntentos=0;     // Llega con tipo byte
  8.         int numeroIntroducido=-1;// Número introducido por el usuario
  9.  
  10.         numeroAleatorio = (int)(1+Math.random()*99);
  11.        
  12.         while(numeroAleatorio!=numeroIntroducido){  // Valdría hacer un do...while
  13.                                                     // También podríamos utilizar una variable booleana para saber cuando acertó el número
  14.             do {
  15.                 System.out.println("\nIntroduce un número entre 1 y 100:");
  16.                 numeroIntroducido=scanner.nextInt();
  17.             }while(numeroIntroducido<1 || numeroIntroducido>100);
  18.            
  19.             if (numeroAleatorio!=numeroIntroducido){
  20.                 if (numeroIntroducido<numeroAleatorio){
  21.                     System.out.println("\nEl número es mayor...");
  22.                 }
  23.                 else{
  24.                     System.out.println("\nEl número es menor...");
  25.                 }
  26.             }
  27.            
  28.             numIntentos++;
  29.         }
  30.         System.out.printf("%nAcertaste!!!%nEl número misterioso era el %d y lo adivinaste en %d intentos",numeroAleatorio,numIntentos);
  31.        
  32.     }   // Fin del método resolverEjercicioRepeticion8


  • Lee una frase por teclado y muéstrela del revés. Por ejemplo, si ponemos 'casa' debe mostrar 'asac'.
Pista: Podemos hacer uso del método 'charAt' de la clase String.
  1.      /**
  2.      * Nombre: resolverEjercicioRepeticion9()
  3.      * Resuelve el ejercicio 9 de la lista de ejercicios de este bloque
  4.      */
  5.     public static void resolverEjercicioRepeticion9(){
  6.         String frase="";        // Frase a leer por teclado
  7.        
  8.         System.out.println("Introduce una frase:");
  9.         frase = scanner.nextLine();
  10.        
  11.         for(int cont=frase.length()-1;cont>=0;cont--){
  12.            
  13.             System.out.printf("%s",frase.charAt(cont));
  14.            
  15.         }
  16.        
  17.        
  18.     }  // Fin del método resolverEjercicioRepeticion9


Ejercicios Estructuras repetitivas: break-continue-bucles anidados

  • Muestra los 100 primeros números pares utilizando la sentencia continue. La sentencia que imprime los número debe estar fuera de cualquier if.


  • Lee por teclado los sueldos de 5 empleados, los cuales pueden tener céntimos.
En caso de que sean menores o iguales a 1000 euros (despreciando los céntimos), no deben ser sumados. Utiliza la sentencia continue.
Muestra la suma total y cuantos sueldos fueron sumados y cuantos no.


  • Sin programar el siguiente ejemplo, realizar la traza del siguiente programa y escribir cuál sería la salida por pantalla:
  1. int suma ;
  2. for ( int i = 0; i< 2; i++ ) {
  3.     for ( int j = 2; j >= i; --j ) {
  4.       suma =  i * 100 + j;
  5.       System.out.print(suma);
  6.     }
  7. }


  • Escribir el código java correspondiente a este pseudocódigo de varias maneras:
  1. a =1
  2. repetir{
  3.    a = a + 2;
  4. }hasta que (a>15)
  • Utilizando for
  • Utilizando while
  • Utilizando do..while


  • Dado el siguiente código reescribirlo usando un bucle distinto del for:
  1. for (int a = 23; a>= 5; a -=2){
  2.  
  3. }


  • Dado el siguiente código reescribirlo con instrucciones equivalentes que respeten el algoritmo original y usando un bucle distinto del for:
  1. // código para saber si el número n = 14548723 es primo
  2. int n = 14548723;
  3. boolean primo = true;
  4. for (int a = n-1; a>= 2&& primo; a--){
  5.      if (n%a == 0) primo = false;
  6. }


  • Hacer un bucle que pida una letra hasta que se pulse la letra N (en mayúscula o minúscula).
  • Utilizando break/continue.
  • Sin utilizar break/continue, poniendo una condición compuesta dentro de la definición del bucle for o while.


  • Escribir un bucle for que pida 10 números y que muestre su suma, el bucle for debe acabar si se introduce un número negativo (y se mostrará la suma de los números introducidos hasta ese momento.
Este ejercicio debe realizarse de 2 maneras diferentes:
  • Utilizando break/continue.
  • Sin utilizar break/continue, poniendo una condición compuesta dentro de la definición del bucle for.


  • Lee cadenas de texto hasta que se introduzca la cadena vacía (utiliza la sentencia break) o mientras que el número de vocales sea menor que 50.
Al finalizar se debe de mostrar el número de caracteres introducidos y el número de vocales.
En el caso de que el usuario introduzca una palabra menor a tres caracteres, no se debe procesar y se llevará cuenta del número de palabras de este tipo introducidas. Al finalizar se debe de mostrar el número de palabras menor de tres caracteres introducidas.
Utiliza switch para determinar cuando una letra es una de las vocales.


  • Muestra por pantalla los números del 1 al 100 en filas de 10 números utilizando bucles anidados.





Solución Ejercicios Estructuras repetitivas: break-continue-bucles anidados

  • Muestra los 100 primeros números pares utilizando la sentencia continue. La sentencia que imprime los número debe estar fuera de cualquier if.
  1.     /**
  2.     * Nombre: resolverEjercicioRepeticionBreakContinue1()
  3.     * Resuelve el ejercicio 1 de la
  4.     * lista de ejercicios de este bloque
  5.     */
  6.     public static void resolverEjercicioRepeticionBreakContinue1() {
  7.        
  8.         for (int cont=1;cont<=100;cont++){
  9.            
  10.             if (cont%2!=0){
  11.                 continue;
  12.             }
  13.  
  14.             System.out.printf("%d-",cont);
  15.            
  16.            
  17.         }
  18.  
  19.     } // Fin del método resolverEjercicioRepeticionBreakContinue1


  • Lee por teclado los sueldos de 5 empleados, los cuales pueden tener céntimos.
En caso de que sean menores o iguales a 1000 euros (despreciando los céntimos), no deben ser sumados. Utiliza la sentencia continue.
Muestra la suma total y cuantos sueldos fueron sumados y cuantos no.
  1.     /**
  2.     * Nombre: resolverEjercicioRepeticionBreakContinue2()
  3.     * Resuelve el ejercicio 2 de la
  4.     * lista de ejercicios de este bloque
  5.     */
  6.     public static void resolverEjercicioRepeticionBreakContinue2() {
  7.         double sueldo=0d;   // Sueldo del empleado.
  8.         double sumaSueldos=0d;  // Guarda la suma de los sueldos
  9.         byte contSueldosNoSumados=0,contSueldosSumados=0;
  10.        
  11.         for (int cont=0;cont<5;cont++){
  12.            
  13.             System.out.println("Introduce un número:");
  14.             sueldo = scanner.nextDouble();
  15.            
  16.             if (Math.floor(sueldo)<=1000){   // Podríamos poner (int)sueldo
  17.                 contSueldosNoSumados++;
  18.                 continue;
  19.             }
  20.             sumaSueldos += sueldo;  // Fijarse que con el break no hace falta else
  21.             contSueldosSumados++;
  22.         }
  23.         System.out.printf("%nLa suma total es %,.2f.%n El número de sueldos sumados fue %d y el de sueldos no sumados fue %d%n",sumaSueldos,contSueldosSumados,contSueldosNoSumados);
  24.        
  25.  
  26.     } // Fin del método resolverEjercicioRepeticionBreakContinue2


  • Sin programar el siguiente ejemplo, realizar la traza del siguiente programa y escribir

cuál sería la salida por pantalla:

  1. int suma ;
  2. for ( int i = 0; i< 2; i++ ) {
  3.     for ( int j = 2; j >= i; --j ) {
  4.       suma =  i * 100 + j;
  5.       System.out.print(suma);
  6.     }
  7. }
Programacion ej bucles anidados 1.jpg


  • Sin programar el siguiente ejemplo, realizar la traza del siguiente programa y escribir cuál sería la salida por pantalla:
  1. int j ;
  2. for (int i = 0; i< 3; i++) {
  3.     j = i + 1;  
  4.  
  5.     while ( j < 3) {
  6.         System.out.println (j - i);
  7.         j++ ;  
  8.     }
  9. }
Programacion ej bucles anidados 2.jpg




  • Escribir el código java correspondiente a este pseudocódigo de varias maneras:
  1. a =1
  2. repetir{
  3.    a = a + 2;
  4. }hasta que (a>15)
  • Utilizando for
  1. for (int a = 1; !(a>15); a+=2){
  2. }


  • Utilizando while
  1. int a = 1;
  2. while (!(a>15)){
  3.    a += 2;
  4. }


  • Utilizando do..while
  1. int a = 1;
  2. // Solución 1
  3. do {
  4.     a += 2;
  5. } while (!(a>15));
  6.  
  7. // Solución 2
  8. int a = 1;
  9. do {
  10.     a += 2;
  11. } while (a<=15);


  • Dado el siguiente código reescribirlo usando un bucle distinto del for:
  1. for (int a = 23; a>= 5; a -=2){
  2.  
  3. }
  1. int a = 1;
  2. do {
  3.    a += 2;
  4. } while (a<=15);


  • Dado el siguiente código reescribirlo con instrucciones equivalentes que respeten el algoritmo original y usando un bucle distinto del for:
  1. // código para saber si el número n = 14548723 es primo
  2. int n = 14548723;
  3. boolean primo = true;
  4. for (int a = n-1; a>= 2&& primo; a--){
  5.      if (n%a == 0) primo = false;
  6. }
  1. int n = 14548723;
  2. boolean primo = true;
  3. int a = n-1;
  4. while (a>= 2 && primo){
  5.     if (n%a == 0) primo = false;
  6.     a--;
  7. }


  • Hacer un bucle que pida una letra hasta que se pulse la letra N (en mayúscula o minúscula).
  • Utilizando break/continue.
  1. char letra=0;
  2. do {
  3.   System.out.println("Introduce una letra (N o n para finalizar): ");
  4.   letra = scanner.nextChar();
  5.   if (letra == 'N' || letra == 'n') break;
  6. } while (true)
  • Sin utilizar break/continue, poniendo una condición compuesta dentro de la definición del bucle for o while.
  1. char letra=0;
  2. do {
  3.   System.out.println("Introduce una letra (N o n para finalizar): ");
  4.   letra = scanner.nextChar();
  5. } while (letra != 'N' && letra != 'n')


  • Escribir un bucle for que pida 10 números y que muestre su suma, el bucle for o while debe acabar si se introduce un número negativo (y se mostrará la suma de los números introducidos hasta ese momento.
Este ejercicio debe realizarse de 2 maneras diferentes:
  • Utilizando break/continue.
  1. public static void for_1() {
  2.   double sumatorio = 0d;
  3.   double numero = 0d;
  4.  
  5.   for (int i = 1; i<=10; ++i){ // repetir 10 veces
  6.        System.out.println("Escribe un número (negativo para finalizar): ");
  7.        numero = scanner.nextDouble();
  8.        sumatorio += numero;
  9.        if (numero <0){
  10.            break;
  11.        } // if
  12.   } // for
  13. } // Fin del método for_1
  14. ::
  • Sin utilizar break/continue, poniendo una condición compuesta dentro de la definición del bucle for o while.
  1. public static void for_2() {
  2.   double sumatorio = 0d;
  3.   double numero = 0d;
  4.  
  5.   for (int i = 1; i<=10 && numero >= 0; ++i){ // repetir 10 veces
  6.        System.out.println("Escribe un número (negativo para finalizar): ");
  7.        numero = scanner.nextDouble();
  8.        sumatorio += numero;
  9.   } // for
  10. } // Fin del método for_2
  11. ::



  • Lee cadenas de texto hasta que se introduzca la cadena vacía (utiliza la sentencia break) o mientras que el número de vocales sea menor que 50.
Al finalizar se debe de mostrar el número de caracteres introducidos y el número de vocales.
En el caso de que el usuario introduzca una palabra menor a tres caracteres, no se debe procesar y se llevará cuenta del número de palabras de este tipo introducidas. Al finalizar se debe de mostrar el número de palabras menor de tres caracteres introducidas.
Utiliza switch para determinar cuando una letra es una de las vocales.
  1.     /**
  2.     * Nombre: resolverEjercicioRepeticionBreakContinue3()
  3.     * Resuelve el ejercicio 3 de la
  4.     * lista de ejercicios de este bloque
  5.     */
  6.     public static void resolverEjercicioRepeticionBreakContinue3() {
  7.        
  8.         String cadena="";   // Cadena a leer por teclado
  9.         byte numCadenasMenor=0; // Número de cadenas menores de 3 caracteres
  10.         short numCaracteres=0;  // Número de caracteres
  11.         byte numVocales=0;      // Número de vocales. Suponemos que nunca será mayor a 128
  12.        
  13.         while(numVocales<50){
  14.             System.out.println("\nIntroduce una cadena de texto:");
  15.             cadena = scanner.nextLine();
  16.             if (cadena.equals("")){
  17.                 break;
  18.             }
  19.            
  20.             cadena = cadena.toUpperCase();  // Pasamos a mayúsculas para no tener que preguntar por a A, e E,...
  21.             if (cadena.length()<3){
  22.                 numCadenasMenor++;
  23.                 continue;
  24.             }
  25.             numCaracteres+=cadena.length();
  26.             for(int cont=0;cont<cadena.length();cont++){    // Buscamos en todos los caracteres las vocales
  27.                 switch(cadena.charAt(cont)){
  28.                     case 'A':
  29.                     case 'E':
  30.                     case 'I':
  31.                     case 'O':
  32.                     case 'U':
  33.                         numVocales++;
  34.                 }
  35.             }
  36.         }
  37.        
  38.         System.out.printf("%nEl número de caracteres total es %d",numCaracteres);
  39.         System.out.printf("%nEl número de vocales es %d",numVocales);
  40.         System.out.printf("%nEl número de palabras menor a 3 caracteres es %d",numCadenasMenor);
  41.  
  42.     } // Fin del método resolverEjercicioRepeticionBreakContinue3


  • Muestra por pantalla los números del 1 al 100 en filas de 10 números utilizando bucles anidados.
  1.     /**
  2.     * Nombre: resolverEjercicioRepeticionBreakContinue4()
  3.     * Resuelve el ejercicio 4 de la
  4.     * lista de ejercicios de este bloque
  5.     */
  6.     public static void resolverEjercicioRepeticionBreakContinue4() {
  7.  
  8.             for(int cont1=1;cont1<=10;cont1++){
  9.                 for(int cont2=1;cont2<=10;cont2++){
  10.                     System.out.printf("%d ",((cont1-1)*10)+cont2);
  11.                 }
  12.                 System.out.println("\n");
  13.             }
  14.     } // Fin del método resolverEjercicioRepeticionBreakContinue4

Aclaración del uso de finally

  • Las excepciones son errores que se pueden producir durante la ejecución de un programa y que provocan el fallo del mismo. Ejemplo de excepciones los tenemos cuando intentamos acceder a un fichero que no existe, cuando intentamos acceder a una posición de una cadena que no existe, cuando intentamos dividir un número entero por 0.
Lo que nos permite la sección try/catch es gestionar ese tipo de errores para que nuestro programa pueda seguir funcionando.
Lo que sucede es que si se produce una excepción, normalmente vamos a querer salir del procedimiento (método en POO) y no continuar con su ejecución.
Lo que permite la sección finally es que se ejecute un conjunto de instrucciones antes de salir del procedimiento, por lo que se suele utilizar para 'liberar' aquellos recursos que fueran 'abiertos' por el método (normalmente en la sección try).
Veamos un ejemplo:
  1.     public static void aplicarExcepcion(){
  2.         String cadena="ANGEL";
  3.         try{
  4.             // Abrimos recursos
  5.             System.out.println(cadena.charAt(55));  // Provoca la excepción
  6.         }
  7.         catch (IndexOutOfBoundsException ioe){
  8.             System.err.println("FORA DE INDICE");
  9.             System.err.println(ioe.getMessage());;
  10.             return;
  11.         }
  12.         catch (Exception e){
  13.             System.err.println(e.getMessage());;
  14.             return;
  15.         }
  16.         finally{
  17.             // Pechamos recursos
  18.             System.out.println("SAIMOS");
  19.         }
  20.        
  21.         System.out.println("Finaliza método");
  22.        
  23.     }
  • Línea 5: Provoca la excepción al intentar acceder a un
  • Línea 10,14: En caso de excepción salimos del método ya que consideramos que no debemos seguir ejecutando el método.
  • Líneas 16-18: A pesar que hemos ejecutado la orden 'return' al estar dentro de un try/catch, va a ejecutar las sentencias de finally.
  • Cuando conectamos con una base de datos para realizar una consulta, cuando abrimos un fichero para guardar o consultar datos en él,estamos 'abriendo' recursos, que en caso de que se produzca una excepción (o si todo va bien) debemos de cerrar. Estas son las instrucciones que deberíamos poner en la sección finally.




Ejercicios control de excepciones

En todos los ejercicios se debe hacer uso de las excepciones y se informará del tipo de problema encontrado.
  • Lee cadenas por teclado. Intenta convertir la cadena a un número entero. Acumula (suma) los valores numéricos introducidos. Controla que el usuario no introduzca un tipo de dato equivocado y en caso de hacerlo, muestra un aviso.
Se repetirá hasta que introduzca el número 0.
Si la suma es mayor que 100 imprimirá la cadena 'La suma es mayor que 100'. En caso contrario imprimirá la cadena 'La suma no es mayor que 100'. Utiliza el operador ternario.
Al final aparecerá la suma de los números introducidos.


  • Lee dos números por teclado (controlando que sean números entre 0-120 sin decimales) y divide uno entre el otro. En caso de intentar dividir por cero, debe sustituirse por el número 1 (utilizar el operador ternario), hacer la división y mostrar el resultado con dos dígitos decimales.


  • Lee una cadena de texto.
A continuación se debe de pedir un número entero positivo y se mostrará la letra que se corresponda con la posición indicada por el número.
La posición introducida por el usuario empieza en 1, pero recuerda que en las cadenas empieza en 0.
Se repetirá hasta que el usuario introduzca el número -1.


  • Implementa el juego del ahorcado.
Primero se pedirá una palabra a adivinar.
Cuando se empiece a jugar el ordenador informará del número de letras que tiene la palabra y pedirá una letra al usuario.
Se llevará cuenta del número de intentos y si pasa de 10, el usuario perderá.
Por cada intento se mostrará la palabra ocultando las letras que no se han descubierto con un * y mostrando las descubiertas.
En caso de que el usuario introduzca esta entrada: resuelvo:palabra , el ordenador debe coger la palabra y compararla con la palabra secreta.
Si el usuario adivina todas las letras o si adivina la palabra entera con la entrada anterior, se debe mostrar un mensaje de felicidades indicando el número de intentos utilizados y cuantos intentos quedaban para perder el juego.
Idea: Aún no sabemos como crear estructuras de datos como los arrays, que nos servirían para resolver este juego. En este caso, piensa que vas a necesitar una variable donde guardar la palabra en la que aparecen los * y las letras descubiertas.


  • Mejoras al ejercicio anterior:
  • Aún no vimos el uso de arrays, un tipo de dato de referencia.
Adelantándonos un poco, diremos que un array es un tipo de dato que guarda un conjunto de datos del mismo tipo dentro de una estructura.
Para definir un array de un tipo de dato lo hacemos de la forma: String datos[];
Si queremos que en la definición asignar unos valores al array, lo podemos hacer de la siguiente forma: String datos[]={"dato1","dato2","dato3"};
  • Para acceder a un elemento de un array lo haremos con un índice que indica la posición del array a la que queremos acceder, por ejemplo: datos[0] => "dato1", datos[1] = "dato2"
Sabiendo lo anterior, modifica el ejercicio y crea un array de palabras claves que serán las palabras que tendrá que adivinar el usuario. Por lo tanto ahora ya no pedirá la palabra por teclado, sino que escogerá una al azar (utilizando el método random, ya visto anteriormente).


  • Con lo que sabemos hasta ahora, para desvelar una letra de la palabra oculta (la que lleva *) debemos hacer trozos de cadena para mostrar una letra, de forma que si el usuario encontró la letra 'A' en la posición 3, debemos de 'cortar' la palabra oculta en la posición 2, concatenar la letra encontrada y concatenar desde la posición 4 hasta el final.
Una forma más fácil es utilizar la clase StringBuilder y su método replace ya que permite reemplazar un carácter indicando su posición.
Sabiendo lo anterior utiliza la clase StringBuuilder para guardar la palabra oculta.



Solución ejercicios control de excepciones

  • Lee cadenas por teclado. Intenta convertir la cadena a un número entero. Acumula (suma) los valores numéricos introducidos. Controla que el usuario no introduzca un tipo de dato equivocado y en caso de hacerlo, muestra un aviso.
Se repetirá hasta que introduzca el número 0.
Si la suma es mayor que 100 imprimirá la cadena 'La suma es mayor que 100'. En caso contrario imprimirá la cadena 'La suma no es mayor que 100'. Utiliza el operador ternario.
Al final aparecerá la suma de los números introducidos.
  1.     /**
  2.     * Nombre: resolverEjercicioExcepciones1()
  3.     * Resuelve el ejercicio 1 de la
  4.     * lista de ejercicios de este bloque
  5.     */
  6.     public static void resolverEjercicioExcepciones1() {
  7.         String cadena="";   // Cadena a leer por teclado
  8.         int numero=-1;      // Donde se guarda la cadena convertida
  9.         int suma=0;      // Suma los numeros introducidos
  10.        
  11.         do{
  12.             System.out.println("Introduce un número:");
  13.             try{
  14.                 cadena = scanner.nextLine();
  15.                 numero = Integer.parseInt(cadena);
  16.                 suma+=numero;
  17.             }
  18.             catch(NumberFormatException nfe){
  19.                 System.out.println("No has introducido un número entero,Vuelve a intentarlo...");
  20.             }
  21.             catch(Exception e){
  22.                 System.out.println("Se ha producido un error en la lectura de la línea por teclado");
  23.                 break;  // Salimos del while
  24.             }
  25.            
  26.         }while(numero!=0);
  27.        
  28.         System.out.printf("%n%s",(suma>100) ? "La suma es mayor que 100" : "La suma no es mayot que 100");
  29.         System.out.printf("%nLa suma es %d",suma);
  30.        
  31.        
  32.  
  33.     } // Fin del método resolverEjercicioExcepciones1
  • Línea 16: La suma tiene que ir dentro del try y no después de las secciones de catch, debido a que si introducimos un índice fuera de rango, el catch no sale del bucle y número sigue valiendo el valor anterior.


  • Lee dos números por teclado (controlando que sean números entre 0-120 sin decimales) y divide uno entre el otro. En caso de intentar dividir por cero debe sustituirse por el número 1 (utilizar el operador ternario), hacer la división y mostrar el resultado con dos dígitos decimales.
  1.     /**
  2.     * Nombre: resolverEjercicioExcepciones2()
  3.     * Resuelve el ejercicio 2 de la
  4.     * lista de ejercicios de este bloque
  5.     */
  6.     public static void resolverEjercicioExcepciones2() {
  7.         byte numero1=-1,numero2=-1; // Numeros a leer por teclado
  8.                                     // Los inicializamos a -1 ya que en caso de excepción llegaría con el valor 0 y saldrían del while
  9.         double division=0d;            // Guarda el resultado de dividir los dos números
  10.        
  11.         do{
  12.             System.out.println("Introduce el número 1:");
  13.             try{
  14.                 numero1 = scanner.nextByte();
  15.             }
  16.             catch(InputMismatchException ime){
  17.                 System.out.println("No has introducido un número entero,Vuelve a intentarlo...");
  18.                 scanner.nextLine(); // Sino continúa leyendo la entrada anterior
  19.             }
  20.             if ((numero1<1) || (numero1>120)){
  21.                 System.out.println("El número debe de estar entre 1 y 120");
  22.             }
  23.            
  24.         }while((numero1<0) || (numero1>120));
  25.  
  26.         // Como vemos el código es el mismo para el número2.
  27.         // Cuando veamos como crear métodos, este código iría en un método al cual llamariamos y nos devolvería el número
  28.         do{
  29.             System.out.println("Introduce el número 2:");
  30.             try{
  31.                 numero2 = scanner.nextByte();
  32.             }
  33.             catch(InputMismatchException ime){
  34.                 System.out.println("No has introducido un número entero,Vuelve a intentarlo...");
  35.                 scanner.nextLine(); // Sino continúa leyendo la entrada anterior
  36.             }
  37.             if ((numero2<0) || (numero2>120)){
  38.                 System.out.println("El número debe de estar entre 1 y 120");
  39.             }
  40.            
  41.         }while((numero2<0) || (numero2>120));
  42.  
  43.         numero2 = (numero2==0) ? 1 : numero2;
  44.         division = (double)numero1/numero2;
  45.         System.out.printf("%nEl resultado de la división es %.02f",division);
  46.     } // Fin del método resolverEjercicioExcepciones2


  • Lee una cadena de texto.
A continuación se debe de pedir un número entero positivo y se mostrará la letra que se corresponda con la posición indicada por el número.
La posición introducida por el usuario empieza en 1, pero recuerda que en las cadenas empieza en 0.
Se repetirá hasta que el usuario introduzca el número -1.
  1.     /**
  2.     * Nombre: resolverEjercicioExcepciones3()
  3.     * Resuelve el ejercicio 3 de la
  4.     * lista de ejercicios de este bloque
  5.     */
  6.     public static void resolverEjercicioExcepciones3() {
  7.         String cadena="";    // Cadena a leer por teclado.
  8.         byte posicion=0;    // Posición de la cadena a leer por teclado. Suponemos que será menor a 128
  9.        
  10.         System.out.println("\nIntroduce una cadena:");
  11.         cadena = scanner.nextLine();
  12.         do{
  13.             System.out.println("\nIntroduce la posición de la cadena:");
  14.             try{
  15.                 posicion = scanner.nextByte();
  16.                 if (posicion!=-1){
  17.                     System.out.printf("El caracter en la posición %d es %s",posicion,cadena.charAt(posicion-1));
  18.                 }
  19.             }
  20.             catch(InputMismatchException ime){
  21.                 System.out.println("\nNo has introducido un número.");
  22.                 scanner.nextLine();
  23.             }
  24.             catch(IndexOutOfBoundsException iobe){
  25.                 System.out.println("\nLa posición de la cadena no es correcta.");
  26.             }
  27.            
  28.         }while(posicion!=-1);
  29.     } // Fin del método resolverEjercicioExcepciones3


  • Implementa el juego del ahorcado.
Primero se pedirá una palabra a adivinar.
Cuando se empiece a jugar el ordenador informará del número de letras que tiene la palabra y pedirá una letra al usuario.
Se llevará cuenta del número de intentos y si pasa de 10, el usuario perderá.
Por cada intento se mostrará la palabra ocultando las letras que no se han descubierto con un * y mostrando las descubiertas.
En caso de que el usuario introduzca esta entrada: resuelvo:palabra , el ordenador debe coger la palabra y compararla con la palabra secreta.
Si el usuario adivina todas las letras o si adivina la palabra entera con la entrada anterior, se debe mostrar un mensaje de felicidades indicando el número de intentos utilizados y cuantos intentos quedaban para perder el juego.
Idea: Aún no sabemos como crear estructuras de datos como los arrays, que nos servirían para resolver este juego. En este caso, piensa que vas a necesitar una variable donde guardar la palabra en la que aparecen los * y las letras descubiertas.


  1.     /**
  2.      * Programa que simula el juego del ahorcado.
  3.      */
  4.     public static void xogarAforcado(){
  5.         final byte NUM_INTENTOS=10;     // Si llega a este número el jugador pierde.
  6.         byte numIntentos=0;             // Número de intentos del usuario
  7.         boolean adivinada=false;        // Indica si se adivinó la palabra
  8.         boolean letraEncontrada=false;  // Indica si la letra puesta por el usuario está dentro de la palabra a buscar
  9.        
  10.         String palabraAdivinar="";      // Palabra que introduce el usuario
  11.         String palabraMostrar="";       // Palabra a mostrar al usuario a medida que va adivinando. Tiene los *
  12.         String cadena = "";             // Letra a introducir por el usuario o cadena resuelvo:palabra
  13.        
  14.        
  15.         System.out.println("Introduce la palabra a adivinar:");
  16.         try{
  17.             palabraAdivinar = scanner.nextLine().toUpperCase();     // Pasamos a mayusculas
  18.         }
  19.         catch(Exception e){ // Capturamos todas las excepciones
  20.             System.out.println("Hubo un problema:" +e.getMessage());    
  21.             return;  // Salimos ya que no sabemos 'lanzar' una excepción =>  throw  new IllegalStateException("Hubo un problema:" +e.getMessage());
  22.         }
  23.        
  24.         for(int cont=0;cont<palabraAdivinar.length();cont++){   // Ponemos todo a *
  25.             palabraMostrar +="*";
  26.         }
  27.        
  28.         System.out.printf("Número de letras:%d%n",palabraAdivinar.length());
  29.         while(numIntentos<NUM_INTENTOS && !adivinada){
  30.             System.out.printf("Palabra a adivinar:%s%n",palabraMostrar);
  31.             System.out.printf("Número de intentos realizados:%d%n",numIntentos);
  32.             System.out.printf("Número de intentos restantes:%d%n",NUM_INTENTOS - numIntentos);
  33.             System.out.println("Introduce una letra:");
  34.             cadena = scanner.nextLine().toUpperCase();
  35.            
  36.             if(cadena.indexOf(("RESUELVO:"))!=-1){  // Optó por resolver la palabra. Podríamos buscar con el método contains  => HACERLO
  37.                 if (cadena.substring(9, cadena.length()).equals(palabraAdivinar)){
  38.                     adivinada = true;
  39.                 }
  40.                 break;
  41.             }
  42.  
  43.             for(int cont=0;cont<palabraAdivinar.length();cont++){   // Buscamos la letra en toda la palabra. Aún no vimos los arrays pero existe un método (toCharArray) en la clase String que podríamos hacer utilizado
  44.                 if (String.valueOf(palabraAdivinar.charAt(cont)).equals(cadena)){
  45.                     letraEncontrada=true;
  46.                     palabraMostrar = palabraMostrar.substring(0, cont) + cadena + palabraMostrar.substring(cont+1, palabraMostrar.length()); // Letra se va a convertir implicitamente a String
  47.                 }
  48.             }
  49.             if (letraEncontrada){ // Si la encontró miramos que no la haya adivinado. Una forma es comprobar si quedan *
  50.                 if (palabraMostrar.indexOf("*")==-1){       // Podríamos buscar con el método contains  => HACERLO
  51.                     adivinada = true;
  52.                 }
  53.             }
  54.             numIntentos++;
  55.            
  56.         }   // Fin del While
  57.        
  58.         if (adivinada){
  59.             System.out.println("\n!!!!FELICIDADES!!!!");
  60.             System.out.printf("%nAdinivista la palabra en %d intentos...",numIntentos);
  61.             System.out.printf("%nLa palabra es %s.",palabraAdivinar);
  62.         }
  63.         else{
  64.             System.out.println("\n!!!!QUE MAL LO HICISTE!!!!");
  65.             System.out.printf("%nNo adinivista la palabra en %d intentos...",NUM_INTENTOS);
  66.             System.out.printf("%nLa palabra es %s.",palabraAdivinar);
  67.         }
  68.        
  69.        
  70.        
  71.     }  // Fin del método xogarAforcado()

Ejercicios propuestos

  • El usuario debe introducir por teclado un código ISBN y comprobar si es válido.
Dicho ISBN puede ser de 10 o de 13 caracteres.
  • Si es de 10 caracteres, debemos multiplicar cada dígito (si el último carácter es una X, su valor es 10) por la posición que ocupa y calcular la suma de todos ellos. Si la suma es múltiplo de 11, el isbn es correcto.
Por ejemplo: 84-973-6467-8
8*1+4*2+9*3+7*4+3*5+6*6+4*7+6*8+7*9+8*10 = 8+8+27+28+15+36+28+48+63+80=341
  • Si es de 13 caracteres, debemos multiplicar cada número por 1 si la posición que ocupa es impar o por 3 si la posición es par, y calcular la suma de todos salvo del último que es el dígito de control.
Dividimos el resultado de la suma anterior por 10 y obtenemos el resto de la división. Restamos a 10 el resto obtenido. El isbn será correcto si el valor obtenido es igual al dígito de control (el último dígito).
Por ejemplo: 978-1516843886
Dígito de control: 6
9*1+7*3+8*1+1*3+5*1+1*3+6*1+8*3+4*1+3*3+8*1+8*3 = 9+21+8+3+5+3+6+24+4+9+8+24 = 124
124/10 => Resto = 4
10 - 4 = 6 = Dígito de control.
Haz uso del método replaceAll de la clase String para eliminar los guiones del isbn introducido.


  • Implementa un algoritmo en el que dado un entero n > 1 leído por teclado, calcule e imprima los elementos correspondientes a la Conjetura de Ullman, que consiste en:
  • Se pide por teclado un entero positivo.
  • Si es par se divide entre 2.
  • Si es impar se multiplica por 3 y se agrega 1.
  • Se repite hasta obtener el número 1.
Por ejemplo: 18
Salida> 18 9 28 14 7 22 11 34 17 52 26 13 40 20 10 5 16 8 4 2 1


  • Implementa un algoritmo de codificación. Dicho algoritmo consiste en desplazar cada letra de una cadena leída 3 posiciones a la derecha (Cifrado César). Por ejemplo, la cadena 'CASA' quedaría como 'FDVD'.
Antes de codificar, convierta la cadena a mayúsculas.
Nota: Cuidado con la X,Y,Z....:)


Pistas: Podemos hacerlo de dos formas:
  • Utilizando una constante de tipo cadena en la que estén recogidas todas las letras
  • Aprovechando que el tipo de datos 'char' es tratado como un número por Java.


  • Diseña un programa que pida introducir un número entero distinto a cero y muestre sus divisores.


  • Desarrolla un algoritmo que recorra los primeros 500 números enteros y determine cuántos de ellos son impares y cuantos son pares. Se debe mostrar la suma de todos los números que sean pares.


  • En este enlace disponéis de algoritmos con su solución en pseudocódigo y diagrama de flujo que podéis realizar.


  • En este enlace hay 50 algoritmos con su solución en pseudocódigo que podéis realizar.




Página creada por Angel D. Fernández González