Ejercicios Resueltos de Programación Java: Arrays, Matrices y Algoritmos Fundamentales

Este documento presenta una colección de ejercicios de programación resueltos, enfocados en el manejo de arrays y matrices en Java. Cada ejercicio incluye una descripción clara del problema y su implementación en código, ideal para estudiantes y profesionales que buscan reforzar sus habilidades en estructuras de datos y algoritmos fundamentales.

Ejercicio 1 (2017): Conteo de Elementos Diferentes en un Array

Implemente un método llamado elementosDiferentes que tome como argumento un array de números enteros y devuelva el número de elementos diferentes. Es importante destacar que este método también verifica si el array está desordenado; si encuentra que los elementos no están en orden ascendente, devuelve -1.

public static int elementosDiferentes (int [] m){
    // No hay array o no tiene elementos
    if (m == null || m.length == 0) return 0;

    // Cuenta diferentes y comprueba si está desordenado
    int cuenta = 1;
    for (int i = 0; i < m.length - 1; i++){
        if (m[i] != m[i+1]){
            cuenta++;
            if (m[i] > m[i+1]) {
                return -1; // Array desordenado
            }
        }
    }
    return cuenta;
}

Ejercicio 2 (2017): Suma de Factoriales de Elementos de un Array

Implemente el método getSumaFactoriales que devuelve la suma de los factoriales de los elementos del array unidimensional pasado como argumento. Si algún elemento del array es negativo, se utilizará su valor absoluto para calcular el factorial.

static int getSumaFactoriales(int [] m){
    if (m == null) return -1; // Manejo de array nulo

    int total = 0;
    for (int i = 0; i < m.length; i++){
        int fact = 1;
        int inicial = m[i];
        if (inicial < 0) inicial = -inicial; // Usar valor absoluto para negativos

        // Cálculo del factorial
        for (int j = inicial; j > 0; j--){
            fact *= j;
        }
        total += fact;
    }
    return total;
}

Ejercicio 3 (2017): Generación de Matriz desde un Array Unidimensional

Implemente el método generarMatriz que tome como argumento un array unidimensional de números enteros y devuelva una matriz de números enteros, utilizando el número de columnas pasado también como argumento. Este método organiza los elementos del array unidimensional en una estructura matricial.

static int [][] generarMatriz(int [] s, int nCols){
    // Validación de argumentos: array nulo, número de columnas no positivo o longitud no divisible
    if (s == null || nCols <= 0 || s.length % nCols != 0) return null;

    int [][] m = new int [s.length / nCols][nCols];
    int indice = 0;
    for(int i = 0; i < m.length; i++){
        for (int j = 0; j < m[0].length; j++){
            m[i][j] = s[indice];
            indice++;
        }
    }
    return m;
}

Ejercicio 4 (2017): Gestión de Notas en la ETSIT

Se desea gestionar un sistema de notas en la Escuela Técnica Superior de Ingeniería de Telecomunicación (ETSIT). Este ejercicio se divide en dos partes:

4.1. Cálculo de Medias de Estudiantes

Implementar una función mediasEstudiantes que reciba como argumento una referencia al sistema de notas (representado como una matriz donde cada fila es un estudiante y cada columna una nota) y devuelva un array con la media de las notas de cada estudiante.

public static double [] mediasEstudiantes(double [][] a){
    if (a == null || a.length == 0) return null; // Manejo de matriz nula o vacía

    double resultado [] = new double [a.length];
    // Inicializar resultados a 0 (opcional, ya que se sobrescriben)
    for (int i = 0; i < a.length; i++) {
        resultado[i] = 0;
    }

    // Calcular la suma de notas por estudiante y luego la media
    for (int i = 0; i < a.length; i++){
        for (int j = 0; j < a[i].length; j++) {
            resultado[i] += a[i][j];
        }
        resultado[i] /= a[i].length; // Dividir por el número de notas para obtener la media
    }
    return resultado;
}

4.2. Obtención de Estudiantes Suspensos

Implementar una función obtenerEstudiantesSuspensos que reciba como argumento una referencia al sistema de notas y devuelva un array con los índices de los estudiantes cuyas medias son inferiores a 5.0.

public static double [] obtenerEstudiantesSuspensos(double [][] a){
    if (a == null || a.length == 0) return null; // Manejo de matriz nula o vacía

    double medias [] = mediasEstudiantes(a); // Reutilizar la función de medias
    int contador = 0;
    for (int i = 0; i < medias.length; i++) {
        if (medias[i] < 5.0) contador++; // Contar estudiantes con media inferior a 5.0
    }

    double [] resultado = new double [contador];
    int j = 0;
    for (int i = 0; i < medias.length; i++){
        if (medias[i] < 5.0) {
            resultado[j] = i; // Almacenar el índice del estudiante suspenso
            j++;
        }
    }
    return resultado;
}

Ejercicio 5 (2017): Inserción de Fila en una Matriz

Dada una matriz de números enteros representada por un array de dos dimensiones, se pide implementar una función insertarFila que reciba como argumentos una referencia a la matriz original (a), un array unidimensional (b) con los elementos de la nueva fila a insertar, y la posición (n) donde se desea insertar esta nueva fila. La función debe devolver una nueva matriz con la fila insertada.

public static int [][] insertarFila(int [][] a, int [] b, int n){
    // Se asume que 'a' no es nula y 'b' tiene la longitud correcta.
    // Se podría añadir validación para 'n' (0 <= n <= a.length) y 'b.length == a[0].length'
    int [][] resultado = new int [a.length + 1][a[0].length];

    for (int i = 0; i < resultado.length; i++) {
        for (int j = 0; j < resultado[i].length; j++){
            if (i < n) {
                resultado[i][j] = a[i][j]; // Copiar filas anteriores a la posición 'n'
            } else if (i == n) {
                resultado[i][j] = b[j]; // Insertar la nueva fila en la posición 'n'
            } else {
                resultado [i][j] = a[i-1][j]; // Desplazar filas posteriores
            }
        }
    }
    return resultado;
}

Ejercicio 6 (2016): Elemento Más Ocurrente en un Array

Implemente una función masOcurrente que tome como argumento una referencia a un array unidimensional de números enteros positivos cuyos valores deberán estar entre 0 y 99 (ambos incluidos) y devuelva el elemento que aparece más veces en el array. En caso de empate, devuelve el de menor índice.

public static int masOcurrente(int [] a){
    // Validación de array nulo o vacío
    if (a == null || a.length == 0) return -1;

    // Validación de rango de valores (0-99)
    for (int i = 0; i < a.length; i++) {
        if (a[i] < 0 || a[i] > 99) {
            return -1; // Valor fuera de rango
        }
    }

    // Array para almacenar la frecuencia de cada número (0-99)
    int [] frecuencia = new int[100];
    // Inicializar frecuencias a 0 (opcional, Java lo hace por defecto para int arrays)
    for (int i = 0; i < frecuencia.length; i++) {
        frecuencia[i] = 0;
    }

    // Contar ocurrencias de cada número
    for (int i = 0; i < a.length; i++) {
        frecuencia[a[i]]++;
    }

    // Encontrar el elemento con más ocurrencias
    int masOcurrencias = frecuencia[0];
    int indice = 0; // Índice del elemento más ocurrente (el menor en caso de empate)

    for (int i = 1; i < frecuencia.length; i++) {
        if (frecuencia[i] > masOcurrencias){
            masOcurrencias = frecuencia[i];
            indice = i;
        }
    }
    return indice;
}