Ejercicios de Java: Números Aleatorios, Condicionales y Arrays

Enunciado del Ejercicio de Programación

A continuación, se describen los requerimientos para desarrollar una solución en Java, divididos en varias partes.

Parte 1: Generación de un Número Aleatorio

Se debe generar un número aleatorio que cumpla las siguientes condiciones:

• Debe ser impar.
• Debe encontrarse en el intervalo (-75, 190).

Parte 2: Lógica Condicional

Una vez generado el número, se debe aplicar la siguiente lógica:

• Si el número es mayor que 1, se debe imprimir el mensaje: "Prueba Parcial 2".
• Si el número es menor o igual a 1, se debe invocar a un método específico, enviando como parámetro un número ingresado por teclado.

Parte 3: Desarrollo del Método

El método invocado en el punto anterior debe realizar las siguientes acciones:

1. Recibir un número como parámetro, el cual determinará la dimensión de un arreglo unidimensional.
2. Crear y poblar dicho arreglo con números aleatorios generados en el intervalo (60, 180).
3. Calcular el promedio de todos los números impares contenidos en el arreglo.
4. Retornar el promedio calculado.

Parte 4: Bloque Principal (main)

En el método main(), se debe visualizar el valor retornado por el método anterior mediante un mensaje claro que explique su significado (por ejemplo: "El promedio de los números impares es: [valor]").

Propuesta de Solución en Java

A continuación, se presenta un código en Java que implementa varias funcionalidades, incluyendo la manipulación de números aleatorios y arreglos. Se han corregido errores de sintaxis y se ha mejorado la legibilidad para asegurar su correcto funcionamiento.

import java.io.*;

public class Prueba_Parcial {

    public static void main(String args[]) throws IOException {
        BufferedReader dato = new BufferedReader(new InputStreamReader(System.in));
        int numero, impares, promedio;

        // 1. Solicita un número al usuario en un rango específico
        do {
            System.out.print("Ingrese un número entre [-10, 66]: ");
            numero = Integer.parseInt(dato.readLine());
        } while (numero < -10 || numero > 66);

        if (numero < 0) {
            impares = numero_negativo(numero);
            System.out.print("La cantidad de números que no son divisores es: " + impares);
        }

        // 2. Genera un número PAR aleatorio y realiza acciones basadas en su valor
        int x;
        do {
            x = (int) ((Math.random() * 201) - 50); // Rango [-50, 150]
        } while (x % 2 != 0); // Asegura que el número sea par
        
        System.out.print("\nEl número generado PAR es: " + x);

        if (x > 1) {
            // Llama a un método que trabaja con un arreglo
            promedio = arreglo(numero);
            System.out.print("\nEl promedio de los impares del arreglo es: " + promedio);
        } else { // La condición original era if(x < 1), se ajusta a la lógica opuesta
            // Imprime un mensaje si el número es menor o igual a 1
            System.out.print("\nPrueba Parcial 2");
        }

        // 3. Trabaja con un arreglo bidimensional
        int arregloBI[][] = new int[8][5];
        int f, c, menor, suma = 0, cont = 0;
        double promedioBI;
        
        System.out.print("\n\nLa tabla bidimensional es: ");
        for (f = 0; f < 8; f++) {
            System.out.print("\n");
            for (c = 0; c < 5; c++) {
                arregloBI[f][c] = (int) ((Math.random() * 1831) - 850); // Rango [-850, 980]
                System.out.print("\t" + arregloBI[f][c]);
            }
        }

        // 4. Calcula el menor elemento y el promedio de los pares del arreglo bidimensional
        menor = arregloBI[0][0];
        for (f = 0; f < 8; f++) {
            for (c = 0; c < 5; c++) {
                if (arregloBI[f][c] < menor) {
                    menor = arregloBI[f][c];
                }
                if (arregloBI[f][c] % 2 == 0) {
                    suma = suma + arregloBI[f][c];
                    cont++;
                }
            }
        }
        
        System.out.print("\n\nEl número menor del arreglo bidimensional es: " + menor);

        // Evita la división por cero si no hay números pares
        if (cont > 0) {
            promedioBI = (double) suma / cont;
            System.out.print("\nEl promedio de los números pares es: " + promedioBI);
        } else {
            System.out.print("\nNo se encontraron números pares en el arreglo bidimensional.");
        }
    }

    /**
     * Método que cuenta los números en el rango [-10, numero] que NO son divisores de 'numero'.
     * Nota: La lógica original podría ser poco común, se ha preservado pero corregido.
     */
    public static int numero_negativo(int numero) {
        int cont = 0;
        for (int i = -10; i <= numero; i++) {
            // Se evita la división por cero cuando i es 0
            if (i != 0 && numero % i != 0) {
                cont++;
            }
        }
        return cont;
    }

    /**
     * Método que crea un arreglo de tamaño fijo, lo llena con números aleatorios
     * y calcula el promedio de los impares.
     * Nota: El parámetro 'numero' no se utiliza para definir la dimensión del arreglo.
     */
    public static int arreglo(int numero) {
        int arreglo[] = new int[6]; // La dimensión es fija (6)
        int i, cont = 0, suma = 0, promedio = 0;
        
        for (i = 0; i < 6; i++) {
            arreglo[i] = (int) ((Math.random() * 121) + 60); // Rango [60, 180]
            if (arreglo[i] % 2 != 0) {
                suma = suma + arreglo[i];
                cont++;
            }
        }
        
        // Evita la división por cero si no hay números impares
        if (cont > 0) {
            promedio = suma / cont;
        }
        
        return promedio;
    }
}