Implementación Java de Arreglos Bidimensionales, Aleatorios y Verificación de Divisibilidad

Pregunta 1: Implementación de Lógica de Arreglos y Divisibilidad en Java

Requisitos del Ejercicio

Implemente en Java una solución que aborde el siguiente caso, utilizando estructuras de datos y manejo de entrada/salida:

1. Solicitud y Validación de Entrada (a): Solicite por teclado un número entero entre -110 y 230. Valide el ingreso y muestre el número por pantalla.
2. Creación del Arreglo Bidimensional (b): Cree un arreglo bidimensional (BI) de 9 filas y 5 columnas, inicializado con números aleatorios en el rango de -100 a 200 (inclusive).
3. Llamada al Método de Verificación (c): Llame a un método estático que reciba como parámetros el arreglo bidimensional (BI) y el número ingresado por teclado.
4. Lógica del Método (d): El método debe verificar si el número ingresado por teclado ($x$) es divisor de algún número dentro del arreglo bidimensional.
   • Si $x$ es divisor de algún elemento, el método debe retornar $x$.
   • De lo contrario, debe retornar 0. (Se debe manejar el caso de división por cero si $x=0$).
5. Interpretación del Resultado (e): En el bloque main(), visualice a través de un mensaje el significado del dato retornado por el método.
6. Extracción de Elementos Negativos (f): Coloque todos los elementos negativos del arreglo bidimensional (BI) en un arreglo unidimensional (UNI).
7. Visualización del Arreglo Unidimensional (g): Visualice el contenido del arreglo unidimensional (UNI).

Implementación en Java

A continuación, se presenta la solución corregida, incluyendo la clase principal Estudio y el método estático metodo.

Código Fuente Corregido

import java.io.*;

public class Estudio {

    /**
     * Método principal que ejecuta la lógica del programa.
     */
    public static void main(String args[]) throws Exception {
        BufferedReader dato = new BufferedReader(new InputStreamReader(System.in));
        int x; // (a) Número ingresado por teclado

        // 1. Solicitud y Validación de Entrada (a)
        do {
            System.out.print("\nIngrese un número entero entre -110 y 230: ");
            try {
                x = Integer.parseInt(dato.readLine());
            } catch (NumberFormatException e) {
                x = 231; // Fuerza la repetición si la entrada no es un número
            }
        } while (x < -110 || x > 230);
        
        System.out.print("\nEl número ingresado es: " + x);

        // 2. Creación del Arreglo Bidimensional (b)
        int[][] tabla = new int[9][5];
        int f, c, s;
        int k = 0; // Contador para el arreglo unidimensional

        System.out.print("\n\n--- Arreglo Bidimensional (9x5) ---");
        for (f = 0; f < 9; f++) {
            System.out.print("\n");
            for (c = 0; c < 5; c++) {
                // Genera números aleatorios entre -100 y 200
                tabla[f][c] = (int) (Math.random() * 301) - 100;
                System.out.print("\t" + tabla[f][c]);
            }
        }

        // 3. Llamada al Método de Verificación (c)
        s = metodo(tabla, x);

        // 5. Interpretación del Resultado (e)
        System.out.print("\n\n--- Verificación de Divisibilidad ---");
        if (x == 0) {
            System.out.print("\nEl número ingresado es 0. No puede ser utilizado como divisor.");
        } else if (s == x) {
            System.out.print("\nResultado: El número ingresado (" + x + ") ES divisor de al menos un elemento del arreglo BI.");
        } else { // s == 0
            System.out.print("\nResultado: El número ingresado (" + x + ") NO es divisor de ningún elemento del arreglo BI.");
        }

        // 6. Extracción de Elementos Negativos (f)
        // El tamaño máximo es 45 (9*5).
        int arregloUNI[] = new int[45]; 
        
        System.out.print("\n\n--- Arreglo Unidimensional (UNI) ---");
        System.out.print("\nElementos negativos extraídos: ");
        
        // Recorrido para extraer y visualizar (g)
        for (f = 0; f < 9; f++) {
            for (c = 0; c < 5; c++) {
                if (tabla[f][c] < 0) {
                    arregloUNI[k] = tabla[f][c];
                    System.out.print("\t" + arregloUNI[k]);
                    k++;
                }
            }
        }
        
        // Si k es 0, no hubo negativos
        if (k == 0) {
             System.out.print(" (Ninguno)");
        }
        System.out.print("\nTotal de elementos negativos encontrados: " + k);
    }

    /**
     * (d) Verifica si x es divisor de algún elemento en la tabla.
     * @param tabla Arreglo bidimensional de enteros.
     * @param x Número a verificar (divisor potencial).
     * @return x si es divisor de algún elemento, 0 en caso contrario o si x es 0.
     */
    public static int metodo(int[][] tabla, int x) {
        // Manejo de la división por cero
        if (x == 0) {
            return 0;
        }
        
        int f, c;
        for (f = 0; f < 9; f++) {
            for (c = 0; c < 5; c++) {
                // Si el elemento de la tabla es divisible por x
                if (tabla[f][c] % x == 0) {
                    return x;
                }
            }
        }
        return 0;
    }
}

Notas sobre las Correcciones

• Sintaxis y Estilo: Se corrigió la importación (java.io.*) y se ajustó el nombre de la clase a Estudio (convención PascalCase).
• Validación de Entrada (a): Se mejoró el mensaje de solicitud (mumero -> número) y se añadió un bloque try-catch básico para manejar entradas no numéricas, asegurando que el bucle do-while funcione correctamente.
• Rango Aleatorio (b): La fórmula utilizada es correcta para generar números en el rango [-100, 200].
• Lógica del Método (d): Se añadió una verificación explícita if (x == 0) al inicio del método metodo para prevenir la excepción ArithmeticException: / by zero.
• Interpretación del Resultado (e): Se corrigió la lógica en main() para interpretar correctamente el valor retornado (s), diferenciando si el número fue encontrado como divisor o no.
• Extracción de Negativos (f/g): Se corrigió la sintaxis rota en la condición de extracción a if (tabla[f][c] < 0).

-110