Programacion Ejercicios UD2

De MediaWiki
Ir a la navegación Ir a la búsqueda
  • En este punto entraría:
  • Estructuras condicionales: if / switch.
  • Estructuras de repetición: while, do-while, for,for/in.
  • 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

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

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             }
17             catch(NumberFormatException nfe){
18                 System.out.println("No has introducido un número entero,Vuelve a intentarlo...");
19             }
20             catch(Exception e){
21                 System.out.println("Se ha producido un error en la lectura de la línea por teclado");
22                 break;  // Salimos del while
23             }
24             suma+=numero;
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


  • 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                 posicion--; // Se pone la posición 1 tenemos que ir a la 0
17                 System.out.printf("El caracter en la posición %d es %s",posicion,cadena.charAt(posicion));
18             }
19             catch(InputMismatchException ime){
20                 System.out.println("\nNo has introducido un número.");
21                 scanner.nextLine();
22             }
23             catch(IndexOutOfBoundsException iobe){
24                 if (posicion!=-1){
25                     System.out.println("\nLa posición de la cadena no es correcta.");
26                 }
27             }
28             
29         }while(posicion!=-1);
30     } // 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 vocales 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.



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

Obtenido de «https://wiki.cifprodolfoucha.es/index.php?title=Programacion_Ejercicios_UD2&oldid=4359»