PROYECTO “CODIFICACIONES EN JAVA”

1. LEER LOS COEFICIENTES DE UNA ECUACIÓN DE SEGUNDO GRADO Y MOSTRAR SUS SOLUCIONES REALES, SI NO
EXISTEN DEBE INDICARLO.

import [Link];

public class EJER1 {

public static void main(String[] args) {

Scanner scanner = new Scanner([Link]);

[Link]("--- Ecuación de Segundo Grado (ax^2 + bx + c = 0) ---");

[Link]("Ingrese el coeficiente 'a': ");

double a = [Link]();

[Link]("Ingrese el coeficiente 'b': ");

double b = [Link]();

[Link]("Ingrese el coeficiente 'c': ");

double c = [Link]();

double discriminante = b * b - 4 * a * c;

if (a == 0) {

if (b == 0) {

if (c == 0) {

[Link]("La ecuación tiene infinitas soluciones.");

} else {

[Link]("La ecuación no tiene solución (0 = " + c + ").");

} else {

// Ecuación lineal: bx + c = 0

double x = -c / b;

[Link]("Es una ecuación lineal. La solución es x = " + x);

} else if (discriminante > 0) {

double x1 = (-b + [Link](discriminante)) / (2 * a);

double x2 = (-b - [Link](discriminante)) / (2 * a);

[Link]("Las soluciones reales son:");

[Link]("x1 = " + x1);

[Link]("x2 = " + x2);

} else if (discriminante == 0) {

double x = -b / (2 * a);

[Link]("La ecuación tiene una única solución real:");

[Link]("x = " + x);

} else {

[Link]("La ecuación no tiene soluciones reales (las soluciones son complejas).");

}
 }

[Link] DOS NÚMEROS Y VERIFICAR SI UNO ES MÚLTIPLO DEL OTRO O NO LO ES.

import [Link];

public class EJER2 {

public static void main(String[] args) {

Scanner scanner = new Scanner([Link]);

[Link]("--- Verificar si un número es múltiplo del otro ---");

[Link]("Ingrese el primer número entero: ");

int num1 = [Link]();

[Link]("Ingrese el segundo número entero: ");

int num2 = [Link]();

if (num1 == 0 && num2 == 0) {

[Link]("Ambos números son cero, la relación de múltiplo no es clara en este caso.");

} else if (num2 != 0 && num1 % num2 == 0) {

[Link](num1 + " es múltiplo de " + num2);

} else if (num1 != 0 && num2 % num1 == 0) {

[Link](num2 + " es múltiplo de " + num1);

} else {

[Link]("Ninguno de los números es múltiplo del otro.");

[Link] TRES NÚMEROS ENTEROS Y SON DISTINTOS, MOSTRARLOS ORDENADOS DE MAYOR A MENOR.

import [Link];

public class EJER3 {

public static void main(String[] args) {

Scanner scanner = new Scanner([Link]);

 [Link]("--- Ordenar tres números distintos de mayor a menor ---");

[Link]("Ingrese el primer número entero: ");

int num1 = [Link]();

[Link]("Ingrese el segundo número entero: ");

int num2 = [Link]();

[Link]("Ingrese el tercer número entero: ");

int num3 = [Link]();

if (num1 == num2 || num1 == num3 || num2 == num3) {

[Link]("Error: Los números deben ser distintos. Por favor, intente de nuevo.");

} else {

[Link]("Números ordenados de mayor a menor: ");

if (num1 > num2 && num1 > num3) {

[Link](num1 + ", ");

if (num2 > num3) {

[Link](num2 + ", " + num3);

} else {

[Link](num3 + ", " + num2);

} else if (num2 > num1 && num2 > num3) {

[Link](num2 + ", ");

if (num1 > num3) {

[Link](num1 + ", " + num3);

} else {

[Link](num3 + ", " + num1);

} else {

[Link](num3 + ", ");

if (num1 > num2) {

[Link](num1 + ", " + num2);

} else {

[Link](num2 + ", " + num1);

4. LEER UN NÚMERO ENTERO Y MOSTRAR CUANTOS DÍGITOS TIENE.

import [Link];

public class EJER4 {

public static void main(String[] args) {

Scanner scanner = new Scanner([Link]);

[Link]("--- Contar dígitos de un número entero ---");

[Link]("Ingrese un número entero: ");

int numero = [Link]();

int contador = 0;

int numeroAbsoluto = [Link](numero);

if (numeroAbsoluto == 0) {

contador = 1;

} else {

while (numeroAbsoluto > 0) {

numeroAbsoluto /= 10;

contador++;

[Link]("El número " + numero + " tiene " + contador + " dígitos.");

5. LEER UN NÚMERO ENTERO Y MOSTRARLO CON LAS CIFRAS AL REVÉS.

import [Link];

public class EJER5 {

public static void main(String[] args) {

Scanner scanner = new Scanner([Link]);

[Link]("--- Mostrar un número con las cifras al revés ---");

[Link]("Ingrese un número entero: ");

int numero = [Link]();

int numeroOriginal = numero;

int numeroInvertido = 0;
 if (numeroOriginal == 0) {

[Link]("El número " + numeroOriginal + " al revés es: 0");

} else {

boolean esNegativo = false;

if (numero < 0) {

esNegativo = true;

numero = [Link](numero);

while (numero > 0) {

int digito = numero % 10;

numeroInvertido = numeroInvertido * 10 + digito;

numero /= 10;

if (esNegativo) {

numeroInvertido *= -1;

[Link]("El número " + numeroOriginal + " con las cifras al revés es: " + numeroInvertido);

6. UN SUPERMERCADO DECIDE EFECTUAR UNA PROMOCIÓN DE DESCUENTOS... LEER LAS COMPRAS EFECTUADAS
POR N CLIENTES Y APLICAR LOS DESCUENTOS PARA OBTENER EL TOTAL DE VENTAS EFECTUADAS Y EL TOTAL DE
VENTAS CON EL DESCUENTO RESPECTIVO.

import [Link];

public class EJER6 {

public static void main(String[] args) {

Scanner scanner = new Scanner([Link]);

[Link]("--- Promoción de Descuentos en Supermercado ---");

[Link]("Ingrese la cantidad de clientes a procesar (n): ");

int numClientes = [Link]();

double totalVentasSinDescuento = 0;

double totalVentasConDescuento = 0;
 for (int i = 1; i <= numClientes; i++) {

[Link]("\n--- Cliente " + i + " ---");

[Link]("Ingrese el total de la compra del cliente " + i + " (Bs.): ");

double totalCompra = [Link]();

double descuentoAplicado = 0;

if (totalCompra >= 500) {

descuentoAplicado = totalCompra * 0.08;

[Link]("Se aplica un 8% de descuento.");

} else if (totalCompra >= 100) {

descuentoAplicado = totalCompra * 0.05;

[Link]("Se aplica un 5% de descuento.");

} else {

[Link]("No se aplica ningún descuento.");

double totalConDescuento = totalCompra - descuentoAplicado;

[Link]("Total de la compra (sin descuento): " + [Link]("%.2f", totalCompra) + " Bs.");

[Link]("Descuento aplicado: " + [Link]("%.2f", descuentoAplicado) + " Bs.");

[Link]("Total a pagar (con descuento): " + [Link]("%.2f", totalConDescuento) + "

Bs.");

totalVentasSinDescuento += totalCompra;

totalVentasConDescuento += totalConDescuento;

[Link]("\n--- Resumen de Ventas ---");

[Link]("Total de ventas efectuadas (sin descuento): " + [Link]("%.2f",

totalVentasSinDescuento) + " Bs.");

[Link]("Total de ventas con el descuento respectivo: " + [Link]("%.2f",

totalVentasConDescuento) + " Bs.");

}
7. PEDIR NÚMEROS ENTEROS HASTA QUE SE DIGITE UN 0, MOSTRAR LA SUMA DE TODOS LOS NÚMEROS
INTRODUCIDOS.

import [Link];

public class EJER7 {

public static void main(String[] args) {

Scanner scanner = new Scanner([Link]);

[Link]("--- Suma de números hasta digitar 0 ---");

[Link]("Ingrese números enteros (ingrese 0 para finalizar):");

int suma = 0;

int numero;

do {

[Link]("Ingrese un número: ");

numero = [Link]();

suma += numero;

} while (numero != 0);

[Link]("La suma de todos los números introducidos es: " + suma);

}
8. DADAS LAS EDADES Y ALTURAS DE N ALUMNOS, MOSTRAR LA EDAD Y LA ESTATURA MEDIA, LA CANTIDAD DE
ALUMNOS MAYORES DE 18 AÑOS, Y LA CANTIDAD DE ALUMNOS QUE MIDEN MÁS DE 1.75 CM.

import [Link];

public class EJER8 {

public static void main(String[] args) {

Scanner scanner = new Scanner([Link]);

[Link]("--- Análisis de Edades y Alturas de Alumnos ---");

[Link]("Ingrese la cantidad de alumnos (n): ");

int numAlumnos = [Link]();

if (numAlumnos <= 0) {

[Link]("No hay alumnos para procesar.");

[Link]();

return;

double sumaEdades = 0;

double sumaAlturas = 0;

int alumnosMayores18 = 0;

int alumnosMas175cm = 0;

for (int i = 1; i <= numAlumnos; i++) {

[Link]("\n--- Alumno " + i + " ---");

[Link]("Ingrese la edad del alumno " + i + ": ");

int edad = [Link]();

[Link]("Ingrese la altura del alumno " + i + " (en metros, ej. 1.75): ");

double altura = [Link]();

sumaEdades += edad;

sumaAlturas += altura;

if (edad > 18) {

alumnosMayores18++;

if (altura > 1.75) {

alumnosMas175cm++;

double edadMedia = sumaEdades / numAlumnos;

double estaturaMedia = sumaAlturas / numAlumnos;

[Link]("\n--- Resultados ---");

 [Link]("Edad media: " + [Link]("%.2f", edadMedia) + " años");

[Link]("Estatura media: " + [Link]("%.2f", estaturaMedia) + " metros");

[Link]("Cantidad de alumnos mayores de 18 años: " + alumnosMayores18);

[Link]("Cantidad de alumnos que miden más de 1.75 cm: " + alumnosMas175cm);

9. DISPONEMOS DE UNA MÁQUINA QUE PUEDE DAR CAMBIOS CON 5 TIPOS DE MONEDAS DISTINTAS: 5 BS., 1
BS., 0.50 BS., 0.20 BS. Y 0.10 BS. REALIZAR EL PROGRAMA EN EL QUE, DADO EL PRECIO DEL ARTÍCULO Y LA
CANTIDAD EN BOLIVIANOS ENTREGADA POR EL CONSUMIDOR, SE INDIQUE EL CAMBIO A ENTREGAR EMPLEANDO
EL MENOR NÚMERO POSIBLE DE MONEDAS

import [Link];

public class EJER9 {

public static void main(String[] args) {

Scanner scanner = new Scanner([Link]);

[Link]("--- Máquina de Cambio de Monedas ---");

[Link]("Ingrese el precio del artículo (Bs.): ");

double precio = [Link]();

[Link]("Ingrese la cantidad de dinero entregada (Bs.): ");

double entregado = [Link]();

if (entregado < precio) {

[Link]("El dinero entregado es insuficiente.");

[Link]();

return;

double cambio = entregado - precio;

[Link]("\nCambio a entregar: " + [Link]("%.2f", cambio) + " Bs.");

[Link]("Desglose del cambio (menor número de monedas):");

int cambioEnCentavos = (int) [Link](cambio * 100);

int[] monedasValores = {500, 100, 50, 20, 10};

String[] monedasNombres = {"5 Bs.", "1 Bs.", "0.50 Bs.", "0.20 Bs.", "0.10 Bs."};
 for (int i = 0; i < [Link]; i++) {

int numMonedas = cambioEnCentavos / monedasValores[i];

if (numMonedas > 0) {

[Link]("- " + numMonedas + " moneda(s) de " + monedasNombres[i]);

cambioEnCentavos %= monedasValores[i];

if (cambioEnCentavos > 0) {

[Link]("Sobran " + [Link]("%.2f", (double)cambioEnCentavos / 100) + " Bs. que no

pueden ser entregados con las monedas disponibles.");

[Link] UNA GRANJA SE REQUIERE DETERMINAR EL PROMEDIO DE CALIDAD DE LAS N GALLINAS QUE HAY EN LA
GRANJA. LA CALIDAD DE CADA GALLINA SE OBTIENE SEGÚN LA FÓRMULA: CALIDAD = (PESO DE LA GALLINA *
ALTURA DE LA GALLINA) / NÚMERO DE HUEVOS QUE PONE.

import [Link];

public class EJER10 {

public static void main(String[] args) {

Scanner scanner = new Scanner([Link]);

[Link]("--- Promedio de Calidad de Gallinas ---");

[Link]("Ingrese la cantidad de gallinas (n): ");

int numGallinas = [Link]();

if (numGallinas <= 0) {

[Link]("No hay gallinas para procesar.");

[Link]();

return;

double sumaCalidadTotal = 0;

int gallinasValidas = 0;

for (int i = 1; i <= numGallinas; i++) {

[Link]("\n--- Gallina " + i + " ---");

[Link]("Ingrese el peso de la gallina " + i + " (kg): ");

 double peso = [Link]();

[Link]("Ingrese la altura de la gallina " + i + " (centimetro): ");

double altura = [Link]();

[Link]("Ingrese el número de huevos que pone la gallina " + i + ": ");

int numHuevos = [Link]();

if (numHuevos > 0) {

double calidad = (peso * altura) / numHuevos;

[Link]("Calidad de la gallina " + i + ": " + [Link]("%.2f", calidad));

sumaCalidadTotal += calidad;

gallinasValidas++;

} else {

[Link]("La gallina " + i + " puso 0 huevos. No se puede calcular su calidad individual para
el promedio.");

if (gallinasValidas > 0) {

double promedioCalidad = sumaCalidadTotal / gallinasValidas;

[Link]("\n--- Resultado General ---");

[Link]("El promedio de calidad de las gallinas es: " + [Link]("%.2f",

promedioCalidad));

} else {

[Link]("\nNo se pudo calcular un promedio de calidad ya que ninguna gallina puso

huevos.");

11. EN UNA TIENDA COMERCIAL, LAS AMAS DE CASA COMPRAN DIVERSOS ARTÍCULOS... AYUDE A ESTA AMA DE
CASA A OBTENER EL TOTAL DE SUS COMPRAR, LUEGO DE LLENAR EL CARRITO DE MANOS CON TODOS LOS
ARTÍCULOS DE PRIMERA NECESIDAD.

import [Link];

public class EJER11{

public static void main(String[] args) {

Scanner scanner = new Scanner([Link]);

 [Link]("--- Calculadora de Compras para Ama de Casa ---");

double totalCompra = 0;

boolean continuarComprando = true;

int numArticulo = 1;

while (continuarComprando) {

[Link]("\n--- Artículo " + numArticulo + " ---");

[Link]("Ingrese el precio del artículo: ");

double precio = [Link]();

[Link]("Ingrese la cantidad de este artículo: ");

int cantidad = [Link]();

double costoArticulo = precio * cantidad;

[Link]("Costo por este artículo: " + [Link]("%.2f", costoArticulo) + " Bs.");

totalCompra += costoArticulo;

[Link]("¿Desea agregar otro artículo? (s/n): ");

String respuesta = [Link]().toLowerCase();

if (![Link]("s")) {

continuarComprando = false;

numArticulo++;

[Link]("\n--- Resumen de la Compra ---");

[Link]("El total a pagar por todos los artículos es: " + [Link]("%.2f", totalCompra) + "
Bs.");

12. CREAR UN ALGORITMO QUE INDIQUE SI UN NÚMERO ES PERFECTO O NO. SE DICE QUE UN NÚMERO ES
PERFECTO SI LA SUMA DE SUS DIVISORES ES IGUAL AL NÚMERO.
import [Link];

public class EJER12{

public static void main(String[] args) {

Scanner scanner = new Scanner([Link]);

[Link]("--- Verificar si un número es perfecto ---");

[Link]("Ingrese un número entero positivo: ");

int numero = [Link]();

if (numero <= 0) {

[Link]("Por favor, ingrese un número entero positivo.");

} else {

int sumaDivisores = 1; // 1 siempre es divisor

[Link]("Divisores de " + numero + ": 1");

for (int i = 2; i <= numero / 2; i++) {

if (numero % i == 0) {

sumaDivisores += i;

[Link](", " + i);

[Link]();

if (sumaDivisores == numero) {

[Link]("El número " + numero + " es un número PERFECTO.");

} else {

[Link]("El número " + numero + " NO es un número perfecto (Suma de divisores: " +
sumaDivisores + ").");

13. LEER M NÚMEROS E IMPRIMIR CUÁNTOS SON POSITIVOS, CUÁNTOS NEGATIVOS Y CUÁNTOS NEUTROS.

import [Link];

public class EJER13{

public static void main(String[] args) {

 Scanner scanner = new Scanner([Link]);

[Link]("--- Clasificación de Números (Positivos, Negativos, Neutros) ---");

[Link]("¿Cuántos números desea ingresar (M)? ");

int M = [Link]();

int positivos = 0;

int negativos = 0;

int neutros = 0;

for (int i = 1; i <= M; i++) {

[Link]("Ingrese el número " + i + ": ");

int numero = [Link]();

if (numero > 0) {

positivos++;

} else if (numero < 0) {

negativos++;

} else {

neutros++;

[Link]("\n--- Resultados ---");

[Link]("Cantidad de números positivos: " + positivos);

[Link]("Cantidad de números negativos: " + negativos);

[Link]("Cantidad de números neutros (ceros): " + neutros);

14. REALIZAR UN ALGORITMO PARA CALCULAR: SUM_I=1 (2I+3)

import [Link];

public class EJER14 {

public static void main(String[] args) {

[Link]("--- Cálculo de Sumatoria: Σ(i+3) desde i=1 hasta 2 ---");

 int sumatoria = 0;

for (int i = 1; i <= 2; i++) {

sumatoria += (i + 3);

[Link]("El resultado de la sumatoria es: " + sumatoria);

15. REALIZAR UN ALGORITMO PARA CALCULAR: PROD_J=2, j3+PROD_K-3, k /3

public class EJER15 {

public static void main(String[] args) {

[Link]("--- Cálculo de Productos: (Π j de j=2 a 3) + (Π k/3 de k=3 a 7) ---");

// Primer producto: Π j de j=2 a 3

double producto1 = 1;

for (int j = 2; j <= 3; j++) {

producto1 *= j;

[Link]("Primer producto (Π j de j=2 a 3): " + producto1);

// Segundo producto: Π k/3 de k=3 a 7

double producto2 = 1.0; // Usar double para la división

for (int k = 3; k <= 7; k++) {

producto2 *= ((double) k / 3);

[Link]("Segundo producto (Π k/3 de k=3 a 7): " + producto2);

double resultadoFinal = producto1 + producto2;

[Link]("El resultado final es: " + resultadoFinal);

16. LEER 25 NÚMEROS Y MOSTRAR CUÁNTOS DE ELLOS SON NÚMEROS PRIMOS.

import [Link];
public class EJER16 {

public static boolean esPrimo(int num) {

if (num <= 1) {

return false;

for (int i = 2; i * i <= num; i++) {

if (num % i == 0) {

return false;

return true;

public static void main(String[] args) {

Scanner scanner = new Scanner([Link]);

[Link]("--- Contar números primos entre 25 números ---");

int cantidadPrimos = 0;

final int TOTAL_NUMEROS = 25;

for (int i = 1; i <= TOTAL_NUMEROS; i++) {

[Link]("Ingrese el número " + i + ": ");

int numero = [Link]();

if (esPrimo(numero)) {

[Link](numero + " es un número primo.");

cantidadPrimos++;

} else {

[Link](numero + " NO es un número primo.");

[Link]("\n--- Resumen ---");

[Link]("De los " + TOTAL_NUMEROS + " números ingresados, " + cantidadPrimos + " son
primos.");

}
17. REALIZAR UN ALGORITMO PARA CALCULAR: sum_k=2, k i=1, 2i

import [Link];

public class EJER17{

public static void main(String[] args) {

int suma = 0;

for (int k = 2; k <= 6; k++) {

int producto = 1;

for (int i = 1; i <= 4; i++) {

producto *= 2 * i;

suma += producto;

[Link]("El resultado de la suma es: " + suma);

18. SUPONGA QUE SE TIENE UN CONJUNTO DE CALIFICACIONES DE UN GRUPO DE 40 ALUMNOS. REALIZAR UN

ALGORITMO PARA CALCULAR LA CALIFICACIÓN MEDIA Y LA CALIFICACIÓN MÁS BAJA DE TODO EL GRUPO.

import [Link];

public class EJER18{

public static void main(String[] args) {

Scanner scanner = new Scanner([Link]);

[Link]("--- Análisis de Calificaciones de Alumnos ---");

final int NUM_ALUMNOS = 40;

 double sumaCalificaciones = 0;

double calificacionMasBaja = Double.MAX_VALUE;

for (int i = 1; i <= NUM_ALUMNOS; i++) {

[Link]("Ingrese la calificación del alumno " + i + " (0-100): ");

double calificacion = [Link]();

if (calificacion < 0 || calificacion > 100) {

[Link]("Calificación inválida. Por favor, ingrese un valor entre 0 y 100.");

i--;

continue;

sumaCalificaciones += calificacion;

if (calificacion < calificacionMasBaja) {

calificacionMasBaja = calificacion;

double calificacionMedia = sumaCalificaciones / NUM_ALUMNOS;

[Link]("\n--- Resultados del Grupo ---");

[Link]("Calificación media del grupo: " + [Link]("%.2f", calificacionMedia));

[Link]("Calificación más baja del grupo: " + [Link]("%.2f", calificacionMasBaja));

19. GENERAR LA TABLA DE MULTIPLICACIÓN DEL 1 AL 9.

import [Link];

public class EJER19 {

public static void main(String[] args) {

[Link]("--- Tabla de Multiplicar del 1 al 9 ---");

for (int i = 1; i <= 9; i++) {

 [Link]("\n--- Tabla del " + i + " ---");

for (int j = 1; j <= 10; j++) { // Generalmente hasta 10 para tablas

[Link](i + " x " + j + " = " + (i * j));

20. DADO UN NÚMERO N ENTERO POSITIVO, CONTAR EL NÚMERO DE DÍGITOS IMPARES, PARES, PRIMOS,
MÚLTIPLOS DE 3 Y MÚLTIPLOS DE 4 QUE ESTE CONTIENE.

import [Link];

public class EJER20 {

public static boolean esPrimoDigito(int digito) {

if (digito <= 1) return false;

if (digito == 2 || digito == 3 || digito == 5 || digito == 7) return true;

return false;

public static void main(String[] args) {

Scanner scanner = new Scanner([Link]);

[Link]("--- Análisis de Dígitos de un Número Entero Positivo ---");

[Link]("Ingrese un número entero positivo (N): ");

int N = [Link]();

if (N < 0) {

[Link]("Por favor, ingrese un número entero POSITIVO.");

[Link]();

return;

if (N == 0) {

[Link]("El número 0 tiene 1 dígito par, 0 impares, 0 primos, 1 múltiplo de 3, 1 múltiplo de

4.");

[Link]();

return;
 }

int tempN = N;

int pares = 0;

int impares = 0;

int primos = 0;

int mul3 = 0;

int mul4 = 0;

while (tempN > 0) {

int digito = tempN % 10;

if (digito % 2 == 0) {

pares++;

} else {

impares++;

if (esPrimoDigito(digito)) {

primos++;

if (digito != 0 && digito % 3 == 0) {

mul3++;

} else if (digito == 0) {

if (digito != 0 && digito % 4 == 0) {

mul4++;

tempN /= 10;

[Link]("\n--- Resultados para N = " + N + " ---");

[Link]("Pares = " + pares);

[Link]("Impares = " + impares);

[Link]("Primos = " + primos);

[Link]("Mul3 = " + mul3);

[Link]("Mul4 = " + mul4);

}
21. DISEÑE UN ALGORITMO PARA DETERMINAR EL MAYOR DE N NÚMEROS LEÍDOS DESDE TECLADO.

import [Link];

public class EJER21 {

public static void main(String[] args) {

Scanner scanner = new Scanner([Link]);

[Link]("--- Encontrar el Mayor de N Números ---");

[Link]("¿Cuántos números desea ingresar (N)? ");

int N = [Link]();

if (N <= 0) {

[Link]("Debe ingresar al menos un número.");

[Link]();

return;

double mayor = Double.MIN_VALUE;

for (int i = 1; i <= N; i++) {

[Link]("Ingrese el número " + i + ": ");

double numero = [Link]();

if (numero > mayor) {

mayor = numero;

[Link]("\nEl número mayor ingresado es: " + mayor);

}
22. CALCULAR Y VISUALIZAR LA SUMA Y EL PRODUCTO DE LOS NÚMEROS PARES COMPRENDIDOS ENTRE 200 Y
4000 (AMBOS INCLUSIVE).

import [Link];

public class EJER22 {

public static void main(String[] args) {

[Link]("--- Suma y Producto de Números Pares entre 200 y 4000 ---");

long sumaPares = 0;

long productoPares = 1;

for (int i = 200; i <= 4000; i++) {

if (i % 2 == 0) {

sumaPares += i;

productoPares *= i;

[Link]("La suma de los números pares es: " + sumaPares);

[Link]("El producto de los números pares es: " + productoPares);

23. DADO UN NÚMERO N, DETERMINAR EL DÍGITO MAYOR Y EL DÍGITO MENOR, Y LUEGO INTERCAMBIARLOS.

import [Link];

public class EJER23 {

public static void main(String[] args) {

Scanner scanner = new Scanner([Link]);

[Link]("--- Intercambiar el dígito mayor y menor de un número ---");

[Link]("Ingrese un número entero positivo (n): ");

int n = [Link]();
if (n < 0) {

[Link]("Por favor, ingrese un número entero POSITIVO.");

[Link]();

return;

if (n < 10) {

[Link]("El número tiene un solo dígito. No hay nada que intercambiar.");

[Link]("Nuevo número = " + n);

[Link]();

return;

int tempN = n;

int mayorDigito = -1;

int menorDigito = 10;

while (tempN > 0) {

int digito = tempN % 10;

if (digito > mayorDigito) {

mayorDigito = digito;

if (digito < menorDigito) {

menorDigito = digito;

tempN /= 10;

if (mayorDigito == menorDigito) {

[Link]("Todos los dígitos son iguales. Nuevo número = " + n);

[Link]();

return;

[Link]("Dígito Mayor = " + mayorDigito + ", Dígito Menor = " + menorDigito);

int nuevoNumero = 0;

int potenciaDiez = 1;

tempN = n;

while (tempN > 0) {

int digito = tempN % 10;

if (digito == mayorDigito) {

nuevoNumero += (menorDigito * potenciaDiez);

} else if (digito == menorDigito) {

nuevoNumero += (mayorDigito * potenciaDiez);

} else {

nuevoNumero += (digito * potenciaDiez);

 }

potenciaDiez *= 10;

tempN /= 10;

String numStr = [Link](n);

String nuevoNumStr = "";

char charMayor = (char)(mayorDigito + '0');

char charMenor = (char)(menorDigito + '0');

for (int i = 0; i < [Link](); i++) {

char c = [Link](i);

if (c == charMayor) {

nuevoNumStr += charMenor;

} else if (c == charMenor) {

nuevoNumStr += charMayor;

} else {

nuevoNumStr += c;

nuevoNumero = [Link](nuevoNumStr);

[Link]("Nuevo número = " + nuevoNumero);

24. GENERAR LA SIGUIENTE SERIE: 1,2,2,3,3,3,4,4,4,4,5,5,5,5,5…………………….

import [Link];

public class EJER24 {

public static void main(String[] args) {

Scanner scanner = new Scanner([Link]);

[Link]("--- Generar Serie Numérica (1,2,2,3,3,3...) ---");

[Link]("Ingrese hasta qué número desea generar la serie: ");

int limiteNumero = [Link]();

[Link]("Serie generada: ");

for (int i = 1; i <= limiteNumero; i++) {

for (int j = 1; j <= i; j++) {

[Link](i);
 if (!(i == limiteNumero && j == i)) {

[Link](",");

[Link]();

25. DISEÑE UN ALGORITMO PARA DETERMINAR EL PROMEDIO, EL NÚMERO MAYOR, EL MENOR, CUÁNTOS
NÚMEROS SON MÚLTIPLOS DE 2 Y 3 DE N NÚMEROS LEÍDOS DESDE TECLADO.

import [Link];

public class EJER25 {

public static void main(String[] args) {

Scanner scanner = new Scanner([Link]);

[Link]("--- Análisis Completo de N Números ---");

[Link]("¿Cuántos números desea ingresar (N)? ");

int N = [Link]();

if (N <= 0) {

[Link]("Debe ingresar al menos un número.");

[Link]();

return;

double suma = 0;

double mayor = Double.MIN_VALUE;

double menor = Double.MAX_VALUE;

int multiplos2y3 = 0;

[Link]("Ingrese los " + N + " números:");

for (int i = 1; i <= N; i++) {

[Link]("Número " + i + ": ");

double numero = [Link]();

suma += numero;
 if (numero > mayor) {

mayor = numero;

if (numero < menor) {

menor = numero;

if (numero % 2 == 0 && numero % 3 == 0) {

multiplos2y3++;

}double promedio = suma / N;

[Link]("\n--- Resultados del Análisis ---");

[Link]("Promedio = " + [Link]("%.3f", promedio));

[Link]("Mayor: " + mayor);

[Link]("Menor: " + menor);

[Link]("Múltiplos de 2 y 3: " + multiplos2y3);

26. DISEÑE UN ALGORITMO QUE IMPRIMA: 0, 2, 1, 3, 1, 5, 2, 7, 3, 11, 5, 13, 8, 17, 13 ..............

import [Link];

public class EJER26 {

public static boolean esPrimo(int num) {

if (num <= 1) {

return false;

for (int i = 2; i * i <= num; i++) {

if (num % i == 0) {

return false;

return true;
}

public static void main(String[] args) {

Scanner scanner = new Scanner([Link]);

[Link]("--- Generar Serie Mixta (Fibonacci y Primos) ---");

[Link]("¿Cuántos elementos de la serie desea generar? ");

int numElementos = [Link]();

if (numElementos <= 0) {

[Link]("Por favor, ingrese un número positivo de elementos.");

[Link]();

return;

long a = 0, b = 1;

int contFib = 0;

int numPrimo = 2;

int contPrimo = 0;

[Link]("Serie: ");

for (int i = 0; i < numElementos; i++) {

if (i % 2 == 0) {

if (contFib == 0) {

[Link](a);

} else if (contFib == 1) {

[Link](b);

} else {

long nextFib = a + b;

[Link](nextFib);

a = b;

b = nextFib;

contFib++;

} else {

while (!esPrimo(numPrimo)) {

numPrimo++;

[Link](numPrimo);

numPrimo++;

if (i < numElementos - 1) {

[Link](", ");
 }

[Link]();

27. DADO UN RANGO (A Y B) DE NÚMEROS ENTEROS, OBTENER LA CANTIDAD DE NÚMEROS PARES QUE
CONTIENE DICHO RANGO.

import [Link];

public class EJER27{

public static void main(String[] args) {

Scanner scanner = new Scanner([Link]);

[Link]("--- Contar números pares en un rango ---");

[Link]("Ingrese el inicio del rango (A): ");

int A = [Link]();

[Link]("Ingrese el final del rango (B): ");

int B = [Link]();

if (A > B) {

[Link]("El inicio del rango no puede ser mayor que el final. Intercambiando valores...");

int temp = A;

A = B;

B = temp;

[Link]("Nuevo rango: [" + A + ", " + B + "]");

int contadorPares = 0;

for (int i = A; i <= B; i++) {

if (i % 2 == 0) {

contadorPares++;

[Link]("En el rango de [" + A + ", " + B + "], hay " + contadorPares + " números pares.");

}
28. CONVERTIR UN NÚMERO DE BASE N A BASE 10 (EMPLEAR EL TEOREMA FUNDAMENTAL DE LA NUMERACIÓN).

import [Link];

public class EJER28{

public static void main(String[] args) {

Scanner scanner = new Scanner([Link]);

[Link]("--- Conversor de Base N a Base 10 ---");

[Link]("Ingrese el número en base N (como cadena de texto, ej. 1A para hexadecimal): ");

String numeroEnBaseN = [Link]().toUpperCase();

[Link]("Ingrese la base N (ej. 2 para binario, 16 para hexadecimal): ");

int baseN = [Link]();

if (baseN < 2 || baseN > 36) {

[Link]("La base debe estar entre 2 y 36.");

[Link]();

return;

long numeroEnBase10 = 0;

long potencia = 1;

for (int i = [Link]() - 1; i >= 0; i--) {

char caracter = [Link](i);

int valorDigito;

if (caracter >= '0' && caracter <= '9') {

valorDigito = caracter - '0';

} else if (caracter >= 'A' && caracter <= 'Z') {

valorDigito = caracter - 'A' + 10;

} else {

[Link]("Carácter inválido en el número para la base " + baseN + ": " + caracter);

[Link]();

return;

if (valorDigito >= baseN) {

 [Link]("El dígito '" + caracter + "' no es válido para la base " + baseN + ".");

[Link]();

return;

numeroEnBase10 += (valorDigito * potencia);

potencia *= baseN;

[Link]("El número " + numeroEnBaseN + " en base " + baseN + " es " + numeroEnBase10 + "
en base 10.");

29. ESCRIBE UNA FUNCION QUE TOME 3 PARAMETROS: 2 DE TIPO ENTEROS Y 1 DE TIPO CARÁCTER. LA FUNCION
DEBERA SUMAR, RESTAR, MULTIPLICAR O DIVIDIRLOS VALORES DE LOS 2 PRIMEROS PARAMETROS DEPENDIENDO
DEL CODIGO INDICADO EN EL TERCER PARAMETRO, Y DEVOLVER EL RESULTADO.

import [Link];

public class EJER29 {

public static void main(String[] args) {

Scanner sc = new Scanner([Link]);

[Link]("Ingrese el primer número entero: ");

int num1 = [Link]();

[Link]("Ingrese el segundo número entero: ");

int num2 = [Link]();

[Link]("Ingrese la operación (+, -, *, /): ");

char operacion = [Link]().charAt(0);

double resultado = calcular(num1, num2, operacion);

[Link]("Resultado: " + resultado);

public static double calcular(int a, int b, char operador) {

switch (operador) {

case '+':

return a + b;

case '-':
 return a - b;

case '*':

return a * b;

case '/':

if (b != 0) {

return (double) a / b;

} else {

[Link]("Error: División por cero.");

return 0;

default:

[Link]("Operación no válida.");

return 0;

30. DADOS 2 NUMEROS ENTEROS, REALIZAR EL ALGORITMO QUE CALCULE EL COCIENTE Y EL RESTO. EL METODO
PARA OBTENER EL COCIENTE Y EL RESTO ES POR RESTAS SUCESIVAS.

import [Link];

public class EJER30 {

public static void main(String[] args) {

Scanner sc = new Scanner([Link]);

[Link]("Ingrese el dividendo (número entero): ");

int dividendo = [Link]();

[Link]("Ingrese el divisor (número entero positivo): ");

int divisor = [Link]();

if (divisor <= 0) {

[Link]("El divisor debe ser mayor que cero.");

} else if (dividendo < 0) {

[Link]("Este algoritmo solo funciona con valores positivos.");

} else {

calcularCocienteYResto(dividendo, divisor);

public static void calcularCocienteYResto(int dividendo, int divisor) {

int cociente = 0;
 while (dividendo >= divisor) {

dividendo -= divisor;

cociente++;

[Link]("Cociente: " + cociente);

[Link]("Resto: " + dividendo);

31. ESCRIBA UN PROGRAMA QUE PERMITA AL USUARIO OBTENER LOS VALORES DE LAS FUNCIONES
TRIGONOMÉTRICAS

import [Link];

public class EJER31{

public static void main(String[] args) {

Scanner scanner = new Scanner([Link]);

[Link]("--- Calculadora de Funciones Trigonométricas ---");

[Link]("Ingrese el ángulo: ");

double angulo = [Link]();

[Link]("¿El ángulo está en GRADOS o RADIANES? (G/R): ");

String unidad = [Link]().toUpperCase();

double anguloEnRadianes;

if ([Link]("G")) {

anguloEnRadianes = [Link](angulo);

[Link]("Ángulo en grados: " + angulo);

[Link]("Ángulo en radianes: " + [Link]("%.4f", anguloEnRadianes));

} else if ([Link]("R")) {

anguloEnRadianes = angulo;

[Link]("Ángulo en radianes: " + angulo);

[Link]("Ángulo en grados: " + [Link]("%.2f", [Link](anguloEnRadianes)));

} else {

[Link]("Unidad de ángulo inválida. Se asumirán radianes.");

anguloEnRadianes = angulo;

}
 [Link]("\n--- Resultados ---");

[Link]("Seno (sin): " + [Link]("%.4f", [Link](anguloEnRadianes)));

[Link]("Coseno (cos): " + [Link]("%.4f", [Link](anguloEnRadianes)));

[Link]("Tangente (tan): " + [Link]("%.4f", [Link](anguloEnRadianes)));

32. GENERAR LAS SECUENCIAS: 1 2 3 4 .............. N, 1 2 3 4 ..... N-1, 1 2 3 ...... N-2, ........., 1

import [Link];

public class EJER32 {

public static void main(String[] args) {

Scanner scanner = new Scanner([Link]);

[Link]("---Generar Secuencias Numéricas Descendentes");

[Link]("Ingrese un número entero positivo (n) para la secuencia inicial: ");

int n = [Link]();

if (n <= 0) {

[Link]("Por favor, ingrese un número entero positivo.");

return;

for (int i = n; i >= 1; i--) {

for (int j = 1; j <= i; j++) {

[Link](j + " ");

[Link]();

}
33. HALLAR NUMEROS AMIGOS EN EL RANGO 1 A N, NUMEROS AMIGOS (2 NUMEROS SON AMIGOS SI LA SUMA
DE SUS DIVISORES DEL PRIMERO ES IGUAL AL SEGUNDO Y VICEVERSA). IMPRIMIR UN MENSAJE EN CADA CASO.

import [Link];

public class EJER33{

public static void main(String[] args) {

Scanner sc = new Scanner([Link]);

[Link]("Ingrese el valor de N: ");

int N = [Link]();

encontrarNumerosAmigos(N);

public static void encontrarNumerosAmigos(int limite) {

for (int i = 1; i <= limite; i++) {

int sumaDiv1 = sumaDivisores(i);

if (sumaDiv1 > i && sumaDiv1 <= limite) {

int sumaDiv2 = sumaDivisores(sumaDiv1);

if (sumaDiv2 == i) {

[Link]("Los números " + i + " y " + sumaDiv1 + " son amigos.");

public static int sumaDivisores(int num) {

int suma = 0;

for (int i = 1; i <= num / 2; i++) {

if (num % i == 0) {

suma += i;

return suma;

}
34. ENCONTRAR CUADRADOS PERFECTOS EN EL RANGO 1 A N.

import [Link];

public class EJER34 {

public static void main(String[] args) {

Scanner scanner = new Scanner([Link]);

[Link]("--- Encontrar Cuadrados Perfectos en un Rango ---");

[Link]("Ingrese el límite superior del rango (n): ");

int n = [Link]();

if (n <= 0) {

[Link]("Por favor, ingrese un número entero positivo.");

[Link]();

return;

[Link]("Cuadrados perfectos en el rango de 1 a " + n + ":");

boolean encontrado = false;

for (int i = 1; i * i <= n; i++) {

[Link](i * i);

encontrado = true;

if (!encontrado) {

[Link]("No se encontraron cuadrados perfectos en el rango especificado.");

35. GENERAR: 121, 12321, 1234321, ...

PARTE 1: GENERACIÓN DE PATRONES NUMÉRICOS

import [Link];
public class EJER35 {

public static void main(String[] args) {

Scanner scanner = new Scanner([Link]);

[Link]("--- Generar Patrones Numéricos (121, 12321, ...) ---");

[Link]("Ingrese el número de filas a generar (ej. 4 para 1234321): ");

int filas = [Link]();

if (filas <= 0) {

[Link]("Ingrese un número positivo de filas.");

[Link]();

return;

for (int i = 1; i <= filas; i++) {

StringBuilder sb = new StringBuilder();

for (int j = 1; j <= i; j++) {

[Link](j);

for (int j = i - 1; j >= 1; j--) {

[Link](j);

[Link]([Link]());

PARTE 2: N PRIMEROS CUBOS USANDO LA PROPIEDAD DE SUMA DE IMPARES

import [Link];

public class EJER35.1 {

public static void main(String[] args) {

Scanner scanner = new Scanner([Link]);

[Link]("--- Calcular N Cubos Usando Suma de Impares ---");

[Link]("Ingrese cuántos cubos desea calcular (n): ");

int n = [Link]();

if (n <= 0) {

[Link]("Ingrese un número entero positivo.");

return;

}
 long currentOdd = 1;

for (int i = 1; i <= n; i++) {

long sumOfOdds = 0;

[Link](i + "^3 = ");

for (int j = 0; j < i; j++) {

sumOfOdds += currentOdd;

[Link](currentOdd);

if (j < i - 1) {

[Link](" + ");

currentOdd += 2;

[Link](" = " + sumOfOdds);

36. SEAN LOS DATOS M Y N ENETEROS POSITIVOS. ELABORE UN DIAGRAMA DE FLUJO PARA CALCULAR EL
MAXIMO COMUN DIVISOR Y EL MINIMO COMUN MULTIPLO DE M Y N. EL ALGORITMO DE EUCLIDES ESTABLECE
QUE, SI M>N, MCD(M,N)=MCD(N,M MOD N).

import [Link];

public class EJER36 {

public static void main(String[] args) {

Scanner sc = new Scanner([Link]);

// Entrada de datos

[Link]("Ingrese el valor de M (entero positivo): ");

int M = [Link]();

[Link]("Ingrese el valor de N (entero positivo): ");

int N = [Link]();

if (M <= 0 || N <= 0) {

[Link]("Ambos números deben ser enteros positivos.");

} else {

int mcd = calcularMCD(M, N);

int mcm = calcularMCM(M, N, mcd);

[Link]("Máximo Común Divisor (MCD): " + mcd);

[Link]("Mínimo Común Múltiplo (MCM): " + mcm);

 }

public static int calcularMCD(int a, int b) {

while (b != 0) {

int resto = a % b;

a = b;

b = resto;

return a;

public static int calcularMCM(int a, int b, int mcd) {

return (a * b) / mcd;

37. LEER UN VALOR NUMERICO Y CONVERTIRLO A UN NUMERO ROMANO (1-9999).

import [Link];

public class EJER37 {

public static void main(String[] args) {

Scanner sc = new Scanner([Link]);

[Link]("Ingrese un número entre 1 y 9999: ");

int numero = [Link]();

if (numero < 1 || numero > 9999) {

[Link]("El número debe estar entre 1 y 9999.");

} else {

String romano = convertirARomano(numero);

[Link]("Número romano: " + romano);

public static String convertirARomano(int numero) {

String[] unidades = {

"", "I", "II", "III", "IV", "V", "VI", "VII", "VIII", "IX"

};

String[] decenas = {

"", "X", "XX", "XXX", "XL", "L", "LX", "LXX", "LXXX", "XC"

};
 String[] centenas = {

"", "C", "CC", "CCC", "CD", "D", "DC", "DCC", "DCCC", "CM"

};

String[] miles = {

"", "M", "MM", "MMM", "MMMM", "MMMMM", "MMMMMM", "MMMMMMM", "MMMMMMMM",

"MMMMMMMMM"

};

int u = numero % 10;

int d = (numero / 10) % 10;

int c = (numero / 100) % 10;

int m = (numero / 1000) % 10;

return miles[m] + centenas[c] + decenas[d] + unidades[u];

38. LEER UN NÚMERO ENTERO POSITIVO Y ORDENE SUS DÍGITOS DEL MENOR AL MAYOR, EL RESULTADO ES OTRO
NÚMERO ENTERO.

import [Link];

import [Link];

public class EJER38{

public static void main(String[] args) {

Scanner scanner = new Scanner([Link]);

[Link]("--- Ordenar Dígitos de un Número ---");

[Link]("Ingrese un número entero positivo: ");

int numero = [Link]();

if (numero < 0) {

[Link]("Por favor, ingrese un número entero positivo.");

[Link]();

return;

if (numero == 0) {

[Link]("El número con sus dígitos ordenados es: 0");

[Link]();

return;
 }

String numeroStr = [Link](numero);

char[] digitos = [Link]();

[Link](digitos);

StringBuilder numeroOrdenadoStr = new StringBuilder();

for (char digitoChar : digitos) {

[Link](digitoChar);

long nuevoNumero = [Link]([Link]());

[Link]("El número " + numero + " con sus dígitos ordenados es: " + nuevoNumero);

39. LEA UN VECTOR DESORDENADO A, COMPUESTO DE N NUMEROS ENETEROS E IMPRIMASE ESTE VECTOR EN LA
MISMA SECUENCIA, PERO IGNORANDO LOS VALORES DUPLICADOS QUE SE ENCUENTREN EN EL. TAMBIEN SE
NECESITA SABER EL NUMERO DE ELEMENTOS QUE PERMANECEN (M).

import [Link];

public class EJER39 {

public static void main(String[] args) {

Scanner sc = new Scanner([Link]);

[Link]("Ingrese la cantidad de elementos del vector: ");

int n = [Link]();

int[] A = new int[n];

leerVector(A, sc);

int[] M = eliminarDuplicados(A);

imprimirVectorSinDuplicados(M);

public static void leerVector(int[] vector, Scanner sc) {

[Link]("Ingrese los elementos del vector:");

for (int i = 0; i < [Link]; i++) {

[Link]("A[" + i + "] = ");

vector[i] = [Link]();

public static int[] eliminarDuplicados(int[] original) {

int[] temp = new int[[Link]];

 int count = 0;

for (int i = 0; i < [Link]; i++) {

if (!existeEnArreglo(temp, count, original[i])) {

temp[count] = original[i];

count++;

int[] resultado = new int[count];

for (int i = 0; i < count; i++) {

resultado[i] = temp[i];

return resultado;

public static boolean existeEnArreglo(int[] arreglo, int longitud, int valor) {

for (int i = 0; i < longitud; i++) {

if (arreglo[i] == valor) {

return true;

return false;

public static void imprimirVectorSinDuplicados(int[] vector) {

[Link]("Vector sin duplicados: ");

for (int val : vector) {

[Link](val + " ");

[Link]("\nCantidad de elementos sin duplicados: " + [Link]);

MODULAR

40. CALCULAR EL VALOR DE S PARA N TERMINOS: S=nx + (n-1)x^2 + (n-2)x^4 + (n-3)x^7 +….

import [Link];

public class EJERMOD40{

public static double calcularS(int n, double x) {

 double S = 0.0;

double potenciaX = 1.0;

for (int i = 0; i < n; i++) {

S += (n - i) * potenciaX;

potenciaX *= x;

return S;

public static void main(String[] args) {

int n = 4;

double x = 2.0;

double resultado = calcularS(n, x);

[Link]("El valor de S para n=" + n + " y x=" + x + " es: " + resultado);

41. CALCULAR EL VALOR DE S PARA N TERMINOS: S=X^0/2! + X^1/3! + X^1/5! +X^2/7! +X^3/11! +X^5/13! +….

import [Link];

public class EJERMOD41{

public static double calcularS(int n, double x) {

double s = 0;

for (int i = 0; i < n; i++) {

int numeradorExponente;

int denominadorFactorial;

if (i == 0) {

numeradorExponente = 0;

denominadorFactorial = 2;

} else if (i == 1) {

numeradorExponente = 1;

denominadorFactorial = 3;

} else if (i == 2) {

numeradorExponente = 1;

denominadorFactorial = 5;

} else if (i == 3) {

numeradorExponente = 2;

denominadorFactorial = 7;
 } else if (i == 4) {

numeradorExponente = 3;

denominadorFactorial = 11;

} else if (i == 5) {

numeradorExponente = 5;

denominadorFactorial = 13;

} else {

numeradorExponente = i + (i - 1);

denominadorFactorial = (i + (i - 1)) + 2;

double potenciaX = potencia(x, numeradorExponente);

double term = potenciaX / factorial(denominadorFactorial);

s += term;

return s;

public static double potencia(double base, int exponente) {

double resultado = 1;

for (int i = 0; i < exponente; i++) {

resultado *= base;

return resultado;

public static long factorial(int n) {

long fact = 1;

for (int i = 2; i <= n; i++) {

fact *= i;

return fact;

public static void main(String[] args) {

Scanner sc = new Scanner([Link]);

[Link]("Ingrese el número de términos (n): ");

int n = [Link]();

[Link]("Ingrese el valor de x: ");

double x = [Link]();

double resultado = calcularS(n, x);

[Link]("El valor de S para " + n + " términos es: " + resultado);

}
42. CALCULAR EL VALOR DE S PARA N TERMINOS: (X+1)!/X^N + (X+2)!/X^N-1 + (X+3)!/X^XN-2 +…..

import [Link];

public class EJERMOD42{

public static void main(String[] args) {

Scanner scanner = new Scanner([Link]);

[Link]("Ingrese el valor de n (número de términos): ");

int n = [Link]();

[Link]("Ingrese el valor de x: ");

double x = [Link]();

double suma = 0;

for (int i = 1; i <= n; i++) {

double numerador = factorial(x + i);

double denominador = potencia(x, n - (i - 1));

suma += numerador / denominador;

[Link]("El valor de S para " + n + " términos es: " + suma);

public static double potencia(double base, int exponente) {

double resultado = 1;

for (int i = 0; i < exponente; i++) {

resultado *= base;

return resultado;

public static double factorial(double n) {

if (n == 0) {

return 1;

} else {

double resultado = 1;

for (int i = 1; i <= (int) n; i++) {

resultado *= i;

return resultado;

}
}

43. CALCULAR EL VALOR DE S PARA N TERMINOS: S=X^0/2! + X^1/3! + X^1/5! +X^2/7! +X^3/11! +X^5/13! +…

import [Link];

public class EJERMOD43{

public static double calcularS(int n, double x) {

double s = 0;

for (int i = 0; i < n; i++) {

int numeradorExponente;

int denominadorFactorial;

if (i == 0) {

numeradorExponente = 0;

denominadorFactorial = 2;

} else if (i == 1) {

numeradorExponente = 1;

denominadorFactorial = 3;

} else if (i == 2) {

numeradorExponente = 1;

denominadorFactorial = 5;

} else if (i == 3) {

numeradorExponente = 2;

denominadorFactorial = 7;

} else if (i == 4) {

numeradorExponente = 3;

denominadorFactorial = 11;

} else if (i == 5) {

numeradorExponente = 5;

denominadorFactorial = 13;

} else {

numeradorExponente = i + (i - 1);

denominadorFactorial = (i + (i - 1)) + 2;

double potenciaX = potencia(x, numeradorExponente);

double term = potenciaX / factorial(denominadorFactorial);

s += term;

return s;

}
 public static double potencia(double base, int exponente) {

double resultado = 1;

for (int i = 0; i < exponente; i++) {

resultado *= base;

return resultado;

public static long factorial(int n) {

long fact = 1;

for (int i = 2; i <= n; i++) {

fact *= i;

return fact;

public static void main(String[] args) {

Scanner sc = new Scanner([Link]);

[Link]("Ingrese el número de términos (n): ");

int n = [Link]();

[Link]("Ingrese el valor de x: ");

double x = [Link]();

double resultado = calcularS(n, x);

[Link]("El valor de S para " + n + " términos es: " + resultado);

ESTATICAS “VECTORES”

44. DADOS 2 VECTORES A Y B ORDENADOS ASCENDENTEMENTE LLEVAR TODOS SUS ELEMENTOS A UN NUEVO
VECTOR C QUE TAMBIEN DEBERA SER ORDENADO ASCENDENTEMENTE.

import [Link];

public class EJERVEC44 {

public static void main(String[] args) {

Scanner sc = new Scanner([Link]);

[Link]("Ingrese el tamaño del vector A: ");

int nA = [Link]();

int[] A = new int[nA];

[Link]("Ingrese los elementos del vector A:");

 for (int i = 0; i < nA; i++) {

A[i] = [Link]();

[Link]("Ingrese el tamaño del vector B: ");

int nB = [Link]();

int[] B = new int[nB];

[Link]("Ingrese los elementos del vector B:");

for (int i = 0; i < nB; i++) {

B[i] = [Link]();

int[] C = new int[nA + nB];

int i = 0, j = 0, k = 0;

while (i < nA && j < nB) {

if (A[i] < B[j]) {

C[k] = A[i];

i++;

} else {

C[k] = B[j];

j++;

k++;

while (i < nA) {

C[k] = A[i];

i++;

k++;

while (j < nB) {

C[k] = B[j];

j++;

k++;

[Link]("Vector C:");

for (int elemento : C) {

[Link](elemento + " ");

}
45. DADO UN VECTOR A DE N ELEMENTOS HACER ROTAR HACIA LA DERECHA EN K ELEMENTOS.

import [Link];

public class EJERVEC45{

public static void main(String[] args) {

Scanner sc = new Scanner([Link]);

[Link]("Ingrese el tamaño del vector A: ");

int n = [Link]();

int[] A = new int[n];

[Link]("Ingrese los elementos del vector A:");

for (int i = 0; i < n; i++) {

A[i] = [Link]();

[Link]("Ingrese el número de posiciones a rotar hacia la derecha: ");

int k = [Link]();

k = k % n;

int[] temp = new int[k];

for (int i = 0; i < k; i++) {

temp[i] = A[n - k + i];

for (int i = n - k - 1; i >= 0; i--) {

A[i + k] = A[i];

for (int i = 0; i < k; i++) {

A[i] = temp[i];

[Link]("Vector A rotado:");

for (int elemento : A) {

[Link](elemento + " ");

}
46. REALIZAR EL PRODUCTO DE 2 VECTORES CONSIDERANDO QUE SON DE DISTINTA LONGITUD.

import [Link];

public class EJERVEC46 {

public static void main(String[] args) {

Scanner sc = new Scanner([Link]);

[Link]("Ingrese la longitud del vector 1: ");

int n1 = [Link]();

[Link]("Ingrese la longitud del vector 2: ");

int n2 = [Link]();

int[] vector1 = new int[n1];

int[] vector2 = new int[n2];

[Link]("Ingrese los elementos del vector 1:");

for (int i = 0; i < n1; i++) {

[Link]("Elemento " + (i + 1) + ": ");

vector1[i] = [Link]();

[Link]("Ingrese los elementos del vector 2:");

for (int i = 0; i < n2; i++) {

[Link]("Elemento " + (i + 1) + ": ");

vector2[i] = [Link]();

int longitud;

if (n1 < n2) {

longitud = n1;

} else {

longitud = n2;

int[] resultado = new int[longitud];

for (int i = 0; i < longitud; i++) {

resultado[i] = vector1[i] * vector2[i];

[Link]("Vector resultante: ");

for (int i = 0; i < [Link]; i++) {

[Link](resultado[i] + " ");

 }

47. GENERAR LOS PRIMEROS N NUMEROS PRIMOS Y ALMACENARLOS EN UN VECTOR P.

import [Link];

public class EJERVEC47 {

public static void main(String[] args) {

Scanner scanner = new Scanner([Link]);

[Link]("Ingrese el número de primos a generar: ");

int N = [Link]();

int[] primos = generarPrimos(N);

[Link]("P = ");

for (int i = 0; i < [Link]; i++) {

[Link](primos[i] + " ");

[Link]();

for (int i = 0; i < [Link]; i++) {

[Link](i + " ");

public static int[] generarPrimos(int n) {

int[] primos = new int[n];

int contadorPrimos = 0;

int numero = 2; // Comenzamos con el primer número primo

while (contadorPrimos < n) {

if (esPrimo(numero)) {

primos[contadorPrimos] = numero;

contadorPrimos++;

numero++;

}
 return primos;

public static boolean esPrimo(int numero) {

if (numero <= 1) {

return false;

for (int i = 2; i * i <= numero; i++) {

if (numero % i == 0) {

return false;

return true;

ESTATICAS “MATRICES”

[Link] UNA MATRIZ A DEL ORDEN MxN Y UN NUMERO K. MULTIPLICAR TODOS LOS ELEMENTOS DE LA MATRIZ
POR EL NUMERO K. MOSTRAR LA MATRIZ RESULTANTE.

import [Link];

public class EJERMAT48{

public static void multiplicarPorK(int[][] matriz, int K) {

int M = [Link];

int N = matriz[0].length;

for (int i = 0; i < M; i++) {

for (int j = 0; j < N; j++) {

matriz[i][j] *= K;

public static void main(String[] args) {

Scanner scanner = new Scanner([Link]);

[Link]("Ingrese el número de filas (M): ");

int M = [Link]();

[Link]("Ingrese el número de columnas (N): ");

int N = [Link]();
 int[][] matriz = new int[M][N];

for (int i = 0; i < M; i++) {

for (int j = 0; j < N; j++) {

[Link]("Ingrese el elemento A[%d][%d]: ", i, j);

matriz[i][j] = [Link]();

[Link]("Ingrese el valor de K: ");

int K = [Link]();

multiplicarPorK(matriz, K);

[Link]("Matriz resultante:");

for (int i = 0; i < M; i++) {

for (int j = 0; j < N; j++) {

[Link](matriz[i][j] + " ");

[Link]();

49. LEER UNA MATRIZ C DE ORDEN P (MATRIZ CUADRADA). MOSTRAR LOS ELEMENTOS DE LA DIAGONAL
PRINCIPAL ,SECUNDARIA,DE LA MATRIZ TRIANGULAR SUPERIOS Y DE LA MATRIZ TRIANGILAR INFERIOR.

import [Link];

public class EJERMAT49{

public static void main(String[] args) {

Scanner scanner = new Scanner([Link]);

[Link]("Ingrese el orden de la matriz (P): ");

int P = [Link]();

int[][] matriz = new int[P][P];

 // Leer la matriz

[Link]("Ingrese los elementos de la matriz:");

for (int i = 0; i < P; i++) {

for (int j = 0; j < P; j++) {

matriz[i][j] = [Link]();

mostrarDiagonalPrincipal(matriz);

mostrarDiagonalSecundaria(matriz);

mostrarMatrizTriangularSuperior(matriz);

mostrarMatrizTriangularInferior(matriz);

public static void mostrarDiagonalPrincipal(int[][] matriz) {

[Link]("Diagonal principal: ");

for (int i = 0; i < [Link]; i++) {

[Link](matriz[i][i] + " ");

[Link]();

public static void mostrarDiagonalSecundaria(int[][] matriz) {

[Link]("Diagonal secundaria: ");

int P = [Link];

for (int i = 0; i < P; i++) {

[Link](matriz[i][P - 1 - i] + " ");

[Link]();

public static void mostrarMatrizTriangularSuperior(int[][] matriz) {

[Link]("Matriz triangular superior:");

for (int i = 0; i < [Link]; i++) {

for (int j = 0; j < [Link]; j++) {

if (j >= i) {

[Link](matriz[i][j] + " ");

} else {

[Link]("0 ");

[Link]();

}
 }

public static void mostrarMatrizTriangularInferior(int[][] matriz) {

[Link]("Matriz triangular inferior:");

for (int i = 0; i < [Link]; i++) {

for (int j = 0; j < [Link]; j++) {

if (j <= i) {

[Link](matriz[i][j] + " ");

} else {

[Link]("0 ");

[Link]();

50. GENERAR LA SIGUIENTE MATRIZ DE ORDEN NxM (SOLO PARA VALORES IMPARES DE N Y MAYORES QUE 3.

import [Link];

public class EJERMAT50 {

public static void main(String[] args) {

int N = 5; // Cambia este valor por cualquier número impar mayor que 3

if (N > 3 && N % 2 != 0) {

int[][] matriz = generarMatriz(N);

imprimirMatriz(matriz);

} else {

[Link]("N debe ser un número impar mayor que 3.");

public static int[][] generarMatriz(int N) {

int[][] matriz = new int[N][N];

 for (int i = 0; i < N; i++) {

for (int j = 0; j < N; j++) {

if (i == j) {

matriz[i][j] = 4; // Diagonal principal

} else if (i + j == N - 1) {

matriz[i][j] = 4; // Diagonal secundaria

} else {

matriz[i][j] = 1; // Resto de la matriz

return matriz;

public static void imprimirMatriz(int[][] matriz) {

for (int[] fila : matriz) {

for (int valor : fila) {

[Link](valor + " ");

[Link]();

51. GENERAR LA SIGUIENTE MATRIZ DE ORDEN NxN (SOLO PARA VALORES IMPARES DE N Y MAYORES QUE 3).

import [Link];

public class EJERMAT51{

public static void main(String[] args) {

int N = 5;

int[][] matriz = new int[N][N];

llenarMatriz(matriz, N);

imprimirMatriz(matriz);

}
 public static void llenarMatriz(int[][] matriz, int N) {

int num = 1;

int capa = 0;

while (num <= N * N) {

for (int i = capa; i < N - capa; i++) {

matriz[capa][i] = num++;

for (int i = capa + 1; i < N - capa; i++) {

matriz[i][N - capa - 1] = num++;

for (int i = N - capa - 1; i >= capa; i--) {

matriz[N - capa - 1][i] = num++;

for (int i = N - capa - 2; i > capa; i--) {

matriz[i][capa] = num++;

capa++;

public static void imprimirMatriz(int[][] matriz) {

for (int[] fila : matriz) {

for (int valor : fila) {

[Link](valor + "\t");

[Link]();

52. GENERAR LA SIGUIENTE MATRIZ DE ORDEN NxN (SOLO PARA VALORES IMPARES DE N Y MAYORES QUE 3).

import [Link];

public class EJERMAT52 {

public static void main(String[] args) {

int[][] matriz = llenarZigZag(5, 5);

imprimirMatriz(matriz);
 }

public static int[][] llenarZigZag(int filas, int columnas) {

int[][] matriz = new int[filas][columnas];

int numero = 1;

for (int i = 0; i < filas; i++) {

if (i % 2 == 0) {

for (int j = 0; j < columnas; j++) {

matriz[i][j] = numero++;

} else {

for (int j = columnas - 1; j >= 0; j--) {

matriz[i][j] = numero++;

return matriz;

public static void imprimirMatriz(int[][] matriz) {

for (int[] fila : matriz) {

for (int num : fila) {

[Link]("%3d ", num);

[Link]();

53. GENERAR LA SIGUIENTE MATRIZ DE ORDEN NxN (SOLO PARA VALORES IMPARES DE N Y MAYORES QUE 3).

import [Link];

public class EJERMAT53{

public static void main(String[] args) {

int[][] matriz = new int[5][5];

int contador = 1;

for (int i = 0; i < 5; i++) {

matriz[i][i] = contador++;

for (int i = 0; i < 5; i++) {

 for (int j = 0; j < 5; j++) {

if (i < j) {

matriz[i][j] = contador++;

} else if (i > j) {

matriz[i][j] = 0;

for (int i = 0; i < 5; i++) {

for (int j = 0; j < 5; j++) {

[Link](matriz[i][j] + "\t");

[Link]();