Ejercicios tema 5
Ejercicio 1. Crear un programa que muestre los múltiplos de 5 entre los números 0 y 100 usando un bucle for.
Solución:
public class Main {
public static void main(String[] args) {
//Creamos un bucle for
//i = 0 ya que es nuestro primer valor,
//después ponemos 100 como valor máximo.
//Por último añadimos i++ para indicar que el el valor aumente de uno en 1. for (int i = 0; i<=100; i++) {
//Ahora queremos mostrar los números que sean múltiplos de 5.
//Así que añadimos un if.
if (i%5==0) {
System.out.println(i);
}
}
}
}Ejercicio 2. Crear un programa que muestre los múltiplos de 5 entre los números 0 y 100 usando un bucle while.
Solución:
public class Main {
public static void main(String[] args) {
//Es necesario crear la variable antes de escribir el bucle while.
int i=0;
//Ahora vamos con el bucle while.
//Mientras el valor sea menor o igual que 100, nuestro programa se ejecutará
while (i<=100) {
//Utilizamos un if como para mostrar solamente los múltiplos de 5.
if (i%5==0) {
System.out.println(i);
}
// Utilizamos i++ para que nuestra variable aumente de uno en uno.
i++;
}
}
}Ejercicio 3. Mostrar números comprendidos entre 320 y 160 de veinte en veinte y hacia atrás usando un bucle for.
Solución:
public class Main {
public static void main(String[] args) {
for (int i =320; i>=160; i-- ) {
if (i%20==0){
System.out.println(i);
}
}
}
}💡Inicializa la variable de control: La variable de control en un bucle en Java es una variable que se usa para contar o seguir el número de veces que el bucle se ha ejecutado. Ayuda a decidir cuándo el bucle debe parar.
Ejercicio 4. Mostrar números comprendidos entre 320 y 160 de veinte en veinte y hacia atrás usando un bucle while.
Solución:
public class Main {
public static void main(String[] args) { int i = 320;
while (i>=160) {
if (i%20==0) {
System.out.println(i);
}
i--;
}
// En este caso hemos colocado i-- debajo de la línea de if
// Esto se debe a que el programa lee de arriba a abajo.
// Si hubiésemos colocado i-- antes del if, el primer valor que considerado sería 319.
// Por lo tanto hubiésemos perdido el valor 320
}
}💡Actualiza la variable de control: Modifica la variable de control en cada iteración para que el bucle pueda avanzar y eventualmente terminar.
Ejercicio 5. Creamos un programa que pida una contraseña para abrir una maleta. La contraseña es 7678. Si se acierta, se abre. Pero si después de 5 intentos no se consigue, se bloquea.
Solución:
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
// Primero creamos nuestra contraseña. int password = 7678;
//Creamos un scanner ya que tendremos que meter dato por teclado.
Scanner ejercicio = new Scanner(System.in);
//Usamos un for para tener 5 intentos.
//Añadimos i++ para que los intentos vayan de uno en uno.
for (int i = 0; i<5; i++ ) {
System.out.println("Introduce una contraseña");
//Introducimos datos por teclado
int intento = ejercicio.nextInt();
//Ahora usamos nuestra condicional.
if (intento == password) {
System.out.println("Maleta abierta");
//Es necesario poner un System.exit si acertamos la contraseña
//Así el programa se cerrará.
System.exit(0);
} else System.out.println("Dato erróneo");
}
//Fuera del bucle, después de los cinco intentos, añadimos la siguiente linea: System.out.println("Te quedaste sin intentos");
}
}Ejercicio 6. Crea un programa que muestre la tabla de multiplicar del 8.
Solución usando for:
public class Main {
public static void main(String[] args) {
for (int i=1; i<=10; i++ ) {
System.out.println(i +" x " + 8 + " = " + (i*8));
}
}
}Solución usando while:
public class Main {
public static void main(String[] args) {
int i = 0;
while (i<10) { i++;
System.out.println(i +" x " + 8 + " = " + (i*8));
}
}
}Ejercicio 7. Crea un programa que calcule la media aritmética de números introducidos por teclado hasta que se introduzca uno negativo. (El número negativo no cuenta para la media).
Solución:
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner ejercicio = new Scanner(System.in);
//La media aritmética es la división de la suma total entre el número de valores.
// Así que vamos a crear dos variables.
double sumaTotal =0; double datosTotales=0;
//Necesitamos crear una variable que albergue el valor de cada vez que introduzcamos una cifra.
int numero = 0;
//Creamos la variable media. double media =0;
//A todas las variables les asignamos valor cero ya que de momento es lo que valen.
//Creamos el while sólo para cuando nuestra cifra introducida sea mayor de 0.
while (numero>=0) {
System.out.println("Introduce una número");
numero = ejercicio.nextInt();
// Este while toma en consideracion todas las cifras introducidas.
// Pero la última tiene valor negativo y no queremos usarla.
// Así que metemos un if para que solo cuente valores positivos.
if (numero>=0) { datosTotales++;
sumaTotal = sumaTotal + numero;
}
}
media = sumaTotal/datosTotales; System.out.println("Suma total es = " + sumaTotal);
System.out.println("El numero de cifras introducidas es " + datosTotales);
System.out.println("La media es: = " + media);
}
}Ejercicio 8. Creamos un programa que muestre el cuadrado y el cubo de los 5 números siguientes a uno introducido por teclado.
Solución:
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner ejercicio = new Scanner(System.in);
System.out.println("Introduce un número");
int numero = ejercicio.nextInt();
//Usamos un for. El primer valor es numero +1.
// El ultimo valor deberá ser menor o igual que numero +5
for (int i= numero +1; i<=numero+5;i++) {
System.out.println("El número es: " + i + ", su cuadrado es " + i*i + ", el cubo es " + i*i*i);
}
}
}Ejercicio 9. Crea un programa en el que introduzcamos 10 números por teclado y este nos diga cuántos son pares y cuántos son impares.
Solución:
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner ejercicio = new Scanner (System.in);
// Creamos dos variables para contabilizar la cantidad de pares e impares. int pares = 0;
int impares =0;
// Creamos un bucle for que nos permita introducir diez datos
for (int i= 0; i<10;i++) {
System.out.println("Introduce un número");
int dato = ejercicio.nextInt();
// Ahora mediante un if, hacemos que se sume 1 a los pares o a los impares
// Se puede hacer de dos formas. Añadiendo ++ o haciendo: variable = variable +1
if (dato%2==0) {
pares = pares +1;
} else impares++;
}
//Ahora simplemente mostramos la suma total tanto de pares como impares.
System.out.println("Total de números pares: " + pares);
System.out.println("Total de números impares: " + impares);
}
}Ejercicio 10. Complicamos un poco el ejercicio 5. Creamos un programa que pida una contraseña para abrir una maleta. La contraseña es 7678. Si se acierta, se abre. Pero si después de 5 intentos no se consigue, se bloquea. Si introduces un número con más o menos de 4 cifras, el programa te dirá que la contraseña debe tener 4 cifras y no contará como intento.
Solución:
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
int password = 7678;
int intentosProbados = 0;
Scanner ejercicio = new Scanner(System.in);
while (intentosProbados<5) {
System.out.println("Introduce una contraseña");
int intento = ejercicio.nextInt();
if (intento > 999 && intento < 100000 ) {
intentosProbados ++;
}
if (intento <= 999 || intento >= 100000 ) {
System.out.println("La contraseña debe tener cuatro cifras");
}else
//Ahora usamos nuestra condicional.
if (intento == password) {
System.out.println("Maleta abierta");
//Es necesario poner un System.exit si acertamos la contraseña
//Así el programa se cerrará.
System.exit(0);
} else System.out.println("Contraseña incorrecta");
}
//Fuera del bucle, después de los cinco intentos, añadimos la siguiente línea:
System.out.println("Te quedaste sin intentos");
}
}
Ejercicio 11. Crear un programa en el que se introduzcan una base y un exponente, y que muestre el resultado.
Solución:
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner ejercicio = new Scanner (System.in);
System.out.println("Introduce la base");
int base = ejercicio.nextInt();
System.out.println("Introduce el exponente");
int exponente = ejercicio.nextInt();
//Creamos también una variable resultado que de momento tiene el mismo valor que la base.
int resultado =base;
// Cuando elevamos algo al cuadrado multiplicamos base por base osea una multiplicación.
// Al elevarlo al cubo multiplicamos base por base, por base. Dos multiplicaciones.
// Al elevarlo a 4, son tres operaciones. Osea siempre una menos que el exponente.
// Por lo tanto este este sera nuestro for.
for (int i = 0; i<exponente -1;i++) {
resultado = resultado*base;
}
System.out.println("El resultado es " + resultado);
}
}
Ejercicio 12. Creamos un programa en el que introduzcamos un número por teclado y este nos diga si es primo o no.
Solución:
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner ejercicio = new Scanner (System.in);
System.out.println("Introduce un número");
int num = ejercicio.nextInt();
//Un número primo es el que puede dividirse tan solo entre 1 y él mismo.
//Por lo tanto vamos a hacer un bucle con un int i, que vaya de uno en uno.
//Desde 1 hasta el propio número.
//Hacemos que cada vez nuestro número se divida entre i
//Creamos un int contador.
//Cada vez que nuestro número sea divisible entre i, el contador sumará 1.
//Si el contador es 2 significa que es divisible entre 1 y él mismo. Primo.
//Si el contador es mayor que dos entonces no será primo. int contador = 0;
for (int i = 1; i<=num; i++) {
if(num%i==0) {
contador++;
}
}
if (contador <=2) {
System.out.println ("Es primo");
} else System.out.println ("No es primo");
}
}
Ejercicio 13. Crea un programa que sume los siguientes 100 números a un número insertado por teclado.
Solución:
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner ejercicio = new Scanner (System.in);
System.out.println("Introduce un número");
int num = ejercicio.nextInt();
int suma= 0;
for (int i = num+1; i<=num+100;i++) {
System.out.println(i);
suma = suma+i;
}
System.out.println("La suma total es " + suma);
}
}💡Evita bucles infinitos: Verifica que la condición del bucle cambiará en algún momento para que el bucle no se ejecute indefinidamente.
Ejercicio 14. Crea un programa que pida dos números. Luego, que muestre los números entre ellos, comenzando por el primero y avanzando de 7 en 7.
Solución usando for:
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner ejercicio = new Scanner (System.in);
System.out.println("Introduce el número a");
int numA = ejercicio.nextInt();
System.out.println("Introduce el número b");
int numB = ejercicio.nextInt();
for (int i = numA; i<=numB;i+=7) {
System.out.println(i);
}
}
}Solución usando while:
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner ejercicio = new Scanner (System.in);
System.out.println("Introduce el número a");
int numA = ejercicio.nextInt();
System.out.println("Introduce el número b");
int numB = ejercicio.nextInt();
int datoActual=numA;
while (datoActual<=numB) {
System.out.println(datoActual); datoActual += 7;
}
}
}
💡Usa break y continue con moderación: Utiliza break para salir del bucle antes de tiempo y continue para saltar a la siguiente iteración, pero hazlo con cuidado para mantener tu código claro y comprensible.
Ejercicio 15. Introduce 10 números por teclado y calcula la media de los números impares y el mayor de los números pares.
Solución:
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner ejercicio = new Scanner (System.in);
int dato;
double sumaImpares = 0;
double cantidadImpares = 0;
int mayorPares = 0;
for (int i=1; i <=10;i++) {
System.out.println("Introduce el número " + i); dato = ejercicio.nextInt();
if (dato%2!=0) { cantidadImpares ++;
sumaImpares = sumaImpares +dato;
} else
if (dato>mayorPares ) { mayorPares = dato;
}
}
System.out.println("El mayor de los pares es " + mayorPares);
System.out.println("La media de los imapres es " + (sumaImpares/cantidadImpares));
}
} Ejercicio 16. Programa que pida números hasta que la suma sea 1000. Después, muestra dicha suma en la pantalla.
Solución:
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner ejercicio = new Scanner (System.in);
int suma = 0;
while (suma <1000) {
System.out.println("Introduce un número");
int dato = ejercicio.nextInt();
suma = suma + dato;
}
System.out.print("La cifra final es de " + suma);
}
}Ejercicio 17. Creamos un programa en el que introduzcamos un número por teclado. Después, el programa calcula todos los múltiplos de 3 hasta llegar a esa cifra, los suma y muestra el resultado en la pantalla.
Solución:
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner ejercicio = new Scanner (System.in);
System.out.println("Introduce un número");
int num = ejercicio.nextInt(); int suma = 0;
for (int i=1;i<=num;i++){
if (i%3==0) {
System.out.println(i);
suma = suma+i;
}
}
System.out.println("La suma total es " + suma);
}
}Ejercicio 18. Crea un programa que muestre todos los números del 1 al 1000 que no son múltiplos del número introducido por teclado.
Solución:
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner ejercicio = new Scanner (System.in);
System.out.println("Ingrese el multiplo");
int multiplo = ejercicio.nextInt();
for (int i=1;i<=1000;i++) {
if (i%multiplo!=0) {
System.out.println(i + " no es multiplo de " + multiplo );
}
}
}
}
Ejercicio 19. Escribe un programa que solicite al usuario una cadena de texto y un carácter específico, luego cuente y muestre cuántas veces aparece ese carácter en la cadena.
Solución:
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner ejercicio = new Scanner (System.in);
System.out.print("Ingrese una cadena de texto: ");
String frase = ejercicio.nextLine();
System.out.print("Ingrese el carácter a contar: ");
char letra = ejercicio.next().charAt(0);
int contador = 0;
for (int i = 0; i < frase.length(); i++) {
if (frase.charAt(i) == letra) {
contador++;
}
}
System.out.print("El n'umero de veces repetido es " + contador);
}
}
Ejercicio 20. Crea un programa que cuente las vocales de una frase introducida por teclado.
Solución:
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner ejercicio = new Scanner (System.in);
System.out.println("Ingrese la frase");
String cadena = ejercicio.nextLine(); int contador = 0;
for (int i = 0; i < cadena.length(); i++) {
char caracter = Character.toLowerCase(cadena.charAt(i));
if (caracter == 'a' || caracter == 'e' || caracter == 'i' || caracter == 'o' || caracter == 'u') {
contador++;
}
}
System.out.println(contador);
}
}💡Define una condición de salida clara: Establece una condición que permita al bucle terminar en un momento adecuado para evitar bucles infinitos.