Ejercicios de Programación Java: Métodos, Arrays y Lógica Condicional

Ejercicios de Programación Java con Métodos

A continuación, se presentan tres ejercicios de programación en Java, cada uno enfocado en el uso de métodos, estructuras de control y manejo de entrada/salida. Se han corregido errores ortográficos, gramaticales y de sintaxis en el código, además de mejorar la legibilidad y añadir comentarios explicativos.

Ejercicio 1: Arreglo Bidimensional y Conteo de Impares

Descripción del Problema:

Escriba un programa que solicite dos números por teclado, entre 1 y 10. Estos números representarán el número de filas y columnas, respectivamente, para crear un arreglo bidimensional (matriz). El arreglo bidimensional debe contener números aleatorios entre 100 y 500.

El programa debe llamar a un método, enviando como parámetro el arreglo bidimensional. Este método calculará la cantidad de números impares presentes en el arreglo y retornará este valor. Finalmente, el resultado debe ser visualizado en el bloque main().

Código Java:

import java.io.*;

public class ArregloBi1 {
    public static void main(String[] args) throws Exception {
        BufferedReader dato = new BufferedReader(new InputStreamReader(System.in));
        int a, b, f, c, x;

        // Solicitar y validar el número de filas (entre 1 y 10)
        do {
            System.out.print("Ingrese número de filas (entre 1 y 10): ");
            a = Integer.parseInt(dato.readLine());
        } while (a < 1 || a > 10);

        // Solicitar y validar el número de columnas (entre 1 y 10)
        do {
            System.out.print("Ingrese número de columnas (entre 1 y 10): ");
            b = Integer.parseInt(dato.readLine());
        } while (b < 1 || b > 10);

        // Crea un arreglo bidimensional con 'a' filas y 'b' columnas.
        int[][] tabla = new int[a][b];

        System.out.print("\nArreglo bidimensional de " + a + " filas y " + b + " columnas:");

        // Ciclo que itera sobre las filas para llenar el arreglo con números aleatorios
        for (f = 0; f < a; f++) {
            System.out.print("\n");
            // Ciclo que itera sobre las columnas
            for (c = 0; c < b; c++) {
                tabla[f][c] = (int) (Math.random() * 401) + 100; // Números aleatorios entre 100 y 500
                System.out.print("\t" + tabla[f][c]);
            }
        }

        // Llama al método 'metodo1' y envía como parámetro el arreglo bidimensional
        x = metodo1(tabla, a, b);

        System.out.print("\nLa cantidad de números impares en el arreglo bidimensional es: " + x);
    } // Cierre del main

    // Método para calcular la cantidad de números impares en un arreglo bidimensional
    public static int metodo1(int[][] tabla, int a, int b) {
        int f, c, cont = 0;
        for (f = 0; f < a; f++) { // Ciclo que itera sobre las filas
            for (c = 0; c < b; c++) { // Ciclo que itera sobre las columnas
                if (tabla[f][c] % 2 != 0) { // Si el número es impar
                    cont++;
                }
            }
        }
        return cont;
    } // Cierre del metodo1
} // Cierre de la clase

Ejercicio 2: Operaciones con Números (Cubo y Factorial)

Descripción del Problema:

Escriba una implementación Java que utilice métodos para procesar un número ingresado por teclado. El número debe encontrarse en el intervalo [-66, 166] y su ingreso debe ser validado.

• Si el número ingresado es impar negativo, llame a un método impar_negativo() y envíe como parámetro el número. Este método debe calcular el cubo del parámetro recibido y retornar el resultado. El dato retornado debe ser visualizado en el bloque main().
• Si el número ingresado es positivo par, llame a un método par_positivo() y envíe como parámetro el número. Este método debe calcular el factorial del parámetro menos 1 (num - 1) y retornar el resultado. El dato retornado debe ser visualizado en el bloque main().

Código Java:

import java.io.*;

public class Ejercicio2 {
    public static void main(String[] args) throws IOException {
        BufferedReader entrada = new BufferedReader(new InputStreamReader(System.in));
        int num;
        double p;

        // Solicitar y validar el número (entre -66 y 166)
        do {
            System.out.print("\nIngrese un número entre -66 y 166: ");
            num = Integer.parseInt(entrada.readLine());
        } while (num < -66 || num > 166);

        // Si el número es impar negativo
        if (num % 2 != 0 && num < 0) {
            p = impar_negativo(num);
            System.out.print("\nEl cubo del número impar negativo es: " + p);
        }

        // Si el número es positivo par
        if (num % 2 == 0 && num > 0) {
            p = par_positivo(num);
            System.out.print("\nEl factorial de (número - 1) para el número par positivo es: " + p);
        }
    }

    // Método para calcular el cubo de un número
    public static double impar_negativo(int num) {
        double k;
        k = Math.pow(num, 3);
        return k;
    }

    // Método para calcular el factorial de (num - 1)
    public static double par_positivo(int num) {
        int i;
        double fact = 1; // Usar double para el factorial para evitar desbordamiento con números grandes

        // Calcular factorial de (num - 1)
        for (i = 1; i <= (num - 1); i++) {
            fact = i * fact;
        }
        return fact;
    }
}

Ejercicio 3: Pares en Intervalo y Promedio

Descripción del Problema:

Escriba una implementación Java que utilice métodos. Se solicitarán por teclado dos números, a y b, que deben estar entre 100 y 1500. El ingreso de ambos números debe ser validado.

• Si a es menor que b, llame a un método y envíe como parámetro las variables a y b. Este método debe imprimir los números pares que se encuentran entre a y b (inclusive). Si no hay números pares en el intervalo, el método debe retornar 0. En el bloque main(), a través de un mensaje, indique el significado del dato retornado (es decir, la cantidad de pares encontrados).
• Si a es mayor que b, llame a otro método y envíe los números a y b. Este método debe calcular el promedio entre todos los números del intervalo (desde b hasta a, inclusive) y retornar el resultado. En el bloque main(), a través de un mensaje, indique el significado del dato retornado.

Código Java:

import java.io.*;

public class Ejercicio3 {
    public static void main(String[] args) throws IOException {
        BufferedReader entrada = new BufferedReader(new InputStreamReader(System.in));
        int a, b, resultado;

        // Solicitar y validar el primer número 'a' (entre 100 y 1500)
        do {
            System.out.print("\nIngrese el primer número (entre 100 y 1500): ");
            a = Integer.parseInt(entrada.readLine());
        } while (a < 100 || a > 1500);

        // Solicitar y validar el segundo número 'b' (entre 100 y 1500)
        do {
            System.out.print("Ingrese el segundo número (entre 100 y 1500): ");
            b = Integer.parseInt(entrada.readLine());
        } while (b < 100 || b > 1500);

        // Condición: 'a' es menor que 'b'
        if (a < b) {
            resultado = pares(a, b);
            if (resultado == 0) {
                System.out.print("\nNo se encontraron números pares en el intervalo entre " + a + " y " + b + ".");
            } else {
                System.out.print("\nSe encontraron " + resultado + " números pares en el intervalo entre " + a + " y " + b + ".");
            }
        }

        // Condición: 'a' es mayor que 'b'
        if (a > b) {
            resultado = promedio(a, b);
            System.out.print("\nEl promedio de los números en el intervalo entre " + b + " y " + a + " es: " + resultado);
        }
        // Nota: Si a == b, ninguna de las condiciones se cumple y el programa termina sin realizar operaciones.
    }

    // Método para imprimir y contar números pares en un intervalo
    public static int pares(int a, int b) {
        int i, cont = 0;
        System.out.print("\nNúmeros pares entre " + a + " y " + b + ": ");
        for (i = a; i <= b; i++) {
            if (i % 2 == 0) {
                System.out.print(i + " ");
                cont++;
            }
        }
        if (cont == 0) {
            return 0; // No hay pares
        } else {
            return cont; // Retorna la cantidad de pares encontrados
        }
    }

    // Método para calcular el promedio de números en un intervalo
    public static int promedio(int a, int b) {
        int i, cont = 0, suma = 0;
        // El bucle debe ir desde el menor número (b) hasta el mayor (a)
        for (i = b; i <= a; i++) {
            suma = suma + i;
            cont++;
        }
        if (cont == 0) { // Evitar división por cero si el intervalo es inválido (aunque las condiciones lo previenen)
            return 0;
        }
        int promedio = (suma / cont);
        return promedio;
    }
}