En esta entrada te ofrecemos una serie de ejercicios resueltos para que puedas comprender mejor el uso de estructuras de control en Java
Ejercicios con estructuras selectivas y repetitivas
- Diseña un programa que solicite 3 números por teclado e imprima cuál es mayor de los tres.
import java.util.Scanner;
public class NumeroMayor {
public static void main (String [] args) {
Scanner leer = new Scanner(System.in);
System.out.println("Introduzca el primer número: ");
double n1 = leer.nextDouble();
System.out.println("Introduzca el segundo número: ");
double n2 = leer.nextDouble();
System.out.println("Introduzca el tercer número: ");
double n3 = leer.nextDouble();
double mayor = calcularMayor (n1,n2,n3);
System.out.println("El número mayor es "+mayor);
leer.close();
}
public static double calcularMayor (double numero1, double numero2, double numero3) {
double mayor=0;
if (numero1 > numero2) {
mayor = numero1;
}else if(numero2 > numero3) {
mayor = numero2;
}else {
mayor = numero3;
}
return mayor;
}
}
- Diseña un programa que dado una base y exponente calcule el valor de una potencia.
import java.util.Scanner;
public class UsoPotencia {
public static void main (String [] args) {
Scanner leer = new Scanner (System.in);
System.out.println("Introduce la base: ");
int base = leer.nextInt();
int exponente = leerPositivo(leer);
int potencia = calcularPotencia (base, exponente);
mostrarPotencia (potencia);
}
public static int leerPositivo (Scanner leer) {
System.out.println("Introduce el exponente: ");
int numero = leer.nextInt();
while (numero < 0) {
System.out.println("Error. Introduce un exponente con valor positivo: ");
numero = leer.nextInt();
}
return numero;
}
public static int calcularPotencia (int b, int e) {
if (e == 0)
return 1;
int resultado = b;
for ( int i = 1; i < e; i++) {
resultado = resultado * b;
}
return resultado;
}
public static void mostrarPotencia(int p) {
System.out.println("El resultado es: "+p);
}
}
- Diseña un programa que intercambie los valores de dos variables A y B. Por ejemplo si A = 2 y B = 5 el programa debe devolver A = 5 y B = 2.
import java.util.Scanner;
public class Intercambio {
public static void main (String [] args) {
Scanner leer = new Scanner (System.in);
System.out.println("Introduce el valor de la variable A: ");
String A = leer.next();
System.out.println("Introduce el valor de la variable B: ");
String B = leer.next();
intercambiarVariables(A,B);
leer.close();
}
public static void intercambiarVariables(String a, String b) {
String c="";
c = a;
a = b;
b = c;
System.out.println ("El valor de A es "+a+" El valor de B es "+b);
}
}
- Diseña un programa para adivinar un número de un solo dígito, teniendo en cuenta la siguiente información:
- Si el número es par o impar.
- Resto de la división entre 5.
import java.util.Scanner;
public class AdivinaNumero {
public static void main (String [] args) {
Scanner leer = new Scanner(System.in);
char par = leerPar (leer);
int resto = leerResto (leer);
int resultado = calcularNumero(par, resto);
System.out.println("El número es: "+resultado);
leer.close();
}
public static char leerPar (Scanner leer) {
System.out.println ("¿El número es par? s/n");
char p = leer.next().charAt(0);
while (p != 's' && p != 'n') {
System.out.println ("Error. Debes responder s para Sí o n para No ");
p = leer.next().charAt(0);
}
return p;
}
public static int leerResto (Scanner leer) {
System.out.println("Introduce el resto de la división por 5: ");
int n = leer.nextInt();
while (n < 0 || n > 4) {
System.out.println("Error, el resto debe ser un número entre 0 y 4. Introduce de nuevo el número: ");
n = leer.nextInt();
}
return n;
}
public static int calcularNumero (char p, int r) {
int numero=0;
//La estructura switch es utilizada para evaluar un valor y ejecutar un bloque de código correspondiente al valor evaluado.
switch (r) {
case 0:
return numero = (p =='s')? 0 : 5;
case 1:
return numero = (p =='s')? 6 : 1;
case 2:
return numero = (p =='s')? 2 : 7;
case 3:
return numero = (p =='s')? 8 : 3;
case 4:
return numero = (p =='s')? 4 : 9;
}
return numero;
}
}
- Diseña un programa que muestre un mensaje «Contratado», si al introducir una edad y dos calificaciones, en total, el individuo posee los siguientes requisitos:
- Al menos 18 años.
- Más de 85 puntos en una de las calificaciones.
import java.util.Scanner;
public class Contratado {
public static void main (String [] args) {
Scanner leer = new Scanner (System.in);
int edad = leerEdad (leer);
int calificacion = leerCalificacion (leer);
String resultado = calcularResultado (edad, calificacion);
System.out.println(""+resultado);
}
public static int leerEdad (Scanner leer) {
System.out.println ("Introduzca la edad: ");
int numero = leer.nextInt();
while (numero < 0) {
System.out.println ("Error. El número debe ser positivo");
System.out.println ("Introduzca un número: ");
numero = leer.nextInt();
}
return numero;
}
public static int leerCalificacion (Scanner leer) {
System.out.println ("Introduzca la calificacion: ");
int numero = leer.nextInt();
while (numero < 0) {
System.out.println ("Error. El número debe ser positivo");
System.out.println ("Introduzca un número: ");
numero = leer.nextInt();
}
return numero;
}
public static String calcularResultado (int e, int c) {
String resultado ="";
if (e >= 18 && c > 85 ) {
resultado = "Contratado";
}else {
resultado = "No Contratado";
}
return resultado;
}
}
- Diseña un programa que sea una calculadora. De tal forma que pidiendo 2 números y un operador (*,/,+,-,%), realice la operación asignada al operador con los números anteriores, siempre que sea posible.
import java.util.Scanner;
public class Calculadora{
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("Calculadora Básica");
double numero1 = solicitarDouble(scanner, "Ingrese el primer número: ");
double numero2 = solicitarDouble(scanner, "Ingrese el segundo número: ");
char operador = solicitarOperador(scanner);
double resultado = calcularOperacion(numero1, numero2, operador);
if (Double.isNaN(resultado)) {
System.out.println("Operación no válida. Por favor, asegúrese de que la división no sea por cero.");
} else {
System.out.println("El resultado de la operación es: " + resultado);
}
scanner.close();
}
public static double solicitarDouble(Scanner scanner, String mensaje) {
System.out.print(mensaje);
return scanner.nextDouble();
}
public static char solicitarOperador(Scanner scanner) {
char operador;
do {
System.out.print("Ingrese el operador (+, -, *, /, %): ");
operador = scanner.next().charAt(0);
} while (operador != '+' && operador != '-' && operador != '*' && operador != '/' && operador != '%');
return operador;
}
public static double calcularOperacion(double numero1, double numero2, char operador) {
switch (operador) {
case '+':
return numero1 + numero2;
case '-':
return numero1 - numero2;
case '*':
return numero1 * numero2;
case '/':
if (numero2 == 0) {
return Double.NaN; // Representación de "Not-a-Number" para división por cero
}
return numero1 / numero2;
case '%':
if (numero2 == 0) {
return Double.NaN; // Representación de "Not-a-Number" para módulo por cero
}
return numero1 % numero2;
default:
return Double.NaN; // Operador no válido
}
}
}
- Diseña un programa cuya salida sea un mensaje indicando si un número es o no primo.
import java.util.Scanner;
public class Primo {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
// Solicitar al usuario el número a verificar
System.out.print("Ingrese un número para verificar si es primo: ");
int numero = leerNumero(scanner);
// Verificar si el número es primo
if (esPrimo(numero)) {
System.out.println(numero + " es primo.");
} else {
System.out.println(numero + " no es primo.");
}
scanner.close();
}
// Método para verificar que el número introducido es mayor que 0
public static int leerNumero (Scanner scanner) {
int n=scanner.nextInt();
while(n<=0) {
System.out.println("Error, el número debe ser positivo. Ingrese otro número: ");
n=scanner.nextInt();
}
return n;
}
// Método para verificar si un número es primo
public static boolean esPrimo(int numero) {
if (numero <= 1) {
return false; // Los números menores o iguales a 1 no son primos
}
for (int i = 2; i <= Math.sqrt(numero); i++) {
if (numero % i == 0) {
return false; // Si el número es divisible por algún número entre 2 y su raíz cuadrada, no es primo
}
}
return true; // Si el número no es divisible por ningún número entre 2 y su raíz cuadrada, es primo
}
}
- Genera los K primeros términos de la serie de Fibonacci, siendo K un valor introducido por teclado.
import java.util.Scanner;
public class Fibonacci {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
// Solicitar al usuario el número de términos de Fibonacci a generar
int k = leerNumero(scanner);
// Mostrar los primeros k términos de la serie de Fibonacci
System.out.println("Los primeros " + k + " términos de la serie de Fibonacci son:");
for (int i = 0; i < k; i++) {
System.out.print(fibonacci(i) + " ");
}
scanner.close();
}
// Método para leer números mayores que 0
public static int leerNumero (Scanner leer) {
System.out.println ("Introduce el numero de términos que tendrá la serie de Fibonacci: ");
int numero = leer.nextInt();
while (numero <= 0) {
System.out.println("Error. El número debe ser mayor que 0");
System.out.println("Introduce otro número: ");
numero = leer.nextInt();
}
return numero;
}
// Método para calcular el término de Fibonacci en la posición n
public static int fibonacci(int n) {
if (n <= 1) {
return n;
} else {
return fibonacci(n - 1) + fibonacci(n - 2);
}
}
}
- Calcula la nota media de un grupo de alumnos si tenemos N alumnos y C notas por cada alumno.
import java.util.Scanner;
// calcula la nota media de un grupo de alumnos, donde el usuario proporciona el número de alumnos (N) y el número de notas por cada alumno (C)
public class NotaMedia {
public static void main (String [] args) {
Scanner leer = new Scanner (System.in);
System.out.println("Introduzca el número de alumnos: ");
int N = leerNumero(leer);
System.out.println("Introduzca el número de notas por alumno: ");
int C = leerNumero(leer);
double notaMedia = calcularNotas(leer,N,C);
System.out.println("La nota media de todos los alumnos es: "+notaMedia);
leer.close();
}
public static int leerNumero (Scanner leer) {
int n = leer.nextInt();
while (n < 0) {
System.out.println("Error, el número introducido debe ser positivo. Introduzca otro número: ");
n = leer.nextInt();
}
return n;
}
public static double calcularNotas(Scanner leer, int numAlumnos, int numNotas) {
double sumaNotasMedias=0;
double sumaNotasAlumno;
double nota=0;
double notaMediaAlumno=0;
for (int i = 1; i <= numAlumnos; i++) {
System.out.println("Alumno "+i+ ":");
sumaNotasAlumno = 0;
for (int j = 1; j <= numNotas; j++) {
System.out.println("Introduzca la nota "+j+" del alumno "+i+" :");
nota=leer.nextDouble();
sumaNotasAlumno+=nota;
}
notaMediaAlumno=sumaNotasAlumno/numNotas;
System.out.println("La nota media del alumno " +i+ " es de: "+notaMediaAlumno);
sumaNotasMedias+=notaMediaAlumno;
}
return sumaNotasMedias/numAlumnos;
}
}
- Programa que imprima en pantalla la sucesión de Ulam:
- La conjetura de Ulam dice: Sea cualquier numero entero positivo, si es par divida entre 2 y si es impar multiplica por 3 y se suma 1. Al aplicar sucesivamente esta ley de formación se obtendrá finalmente el número 1.
import java.util.Scanner;
//Sea cualquier nº entero positivo. Si es par, dividiremos entre 2. Si es impar, se multiplica por 3 y se le suma 1.
//Al aplicar sucesicamente esta ley de formación se obtendrá finalmente el número 1.
public class SucesionUlam {
public static void main (String [] args) {
Scanner leer = new Scanner (System.in);
System.out.println("Introduzca un número positivo: ");
int numero = leerNumero(leer);
System.out.println("La sucesión de Ulam para "+numero+" es:");
calcularUlam(numero);
leer.close();
}
public static int leerNumero (Scanner leer) {
int n = leer.nextInt();
while (n<=0) {
System.out.println("Error. Introduce un número mayor que 0: ");
n = leer.nextInt();
}
return n;
}
public static boolean comprobarNumero (int numero) {
boolean par = true;
if (numero % 2 ==0) {
return par;
}else {
return par=false;
}
}
public static void calcularUlam (int numero) {
boolean par = comprobarNumero(numero);
int contador=numero;
while (contador != 1) {
if(par==true) {
contador = contador / 2;
System.out.println (" "+contador+" ");
par = comprobarNumero(contador);
}else {
contador = (contador*3) + 1;
System.out.println (" "+contador+" ");
par = comprobarNumero(contador);
}
}
}
}