Implementación de Algoritmos Fundamentales en Java: Polimorfismo, Series y Secuencia de Padovan

Programación Orientada a Objetos (POO) y Polimorfismo en Java

Considere la siguiente estructura de clases e interfaces, donde las clases Ave y Mamifero implementan la interfaz Animal. El siguiente código demuestra el uso de polimorfismo al inicializar un array de tipo Animal y llamar a métodos específicos mediante casting e inspección de tipo (instanceof).

Demostración de Polimorfismo

public static void main(String[] args) {
    Animal [] a = new Animal[10];
    for (int i = 0; i < 10; i++){
        if (Math.random() > 0.5){
            a[i] = new Ave();
        }
        else{
            a[i] = new Mamifero();
        }
        a[i].nacer();
        
        // Uso de instanceof para llamar a métodos específicos
        if (a[i] instanceof Ave){
            ((Ave)a[i]).empollar();
        }
        if (a[i] instanceof Mamifero){
            ((Mamifero)a[i]).amamantar();
        }
    }
}

Cálculo de Series Matemáticas

Implementación de un programa en Java para calcular la suma de los primeros n términos de una serie (la serie armónica alternada), solicitando el valor de n al usuario y asegurando que sea positivo.

Implementación de la Suma de la Serie

public static void main(String[] args) {
    int n;
    do{
        System.out.println("Introduzca n:");
        // Se asume la existencia de una clase Teclado para la entrada de datos
        n = Teclado.readInt();
    }
    while (n < 1);
    
    double suma = 0;
    // La serie es: Suma(i=1 hasta n) [ (-1)^(i+1) / i ]
    for (int i = 1; i <= n; i++){
        suma += Math.pow(-1, i + 1) / i;
    }
    
    System.out.println("La suma es: " + suma);
}

Implementación de la Secuencia de Padovan

La secuencia de Padovan $P(n)$ se define por los valores iniciales $P(0)=P(1)=P(2)=1$ y la relación de recurrencia $P(n) = P(n-2) + P(n-3)$ para $n \ge 3$. A continuación, se presentan implementaciones recursivas e iterativas.

a) Función Recursiva para Padovan(n)

Escriba una función recursiva en Java que calcule $P(n)$. Si $n$ es negativo, debe devolver $-1$.

public static int padovanR(int n){
    if (n < 0) return -1;
    if (n == 0 || n == 1 || n == 2) return 1;
    return padovanR(n - 2) + padovanR(n - 3);
}

b) Función Iterativa para Padovan(n)

Escriba una función iterativa en Java que calcule $P(n)$. Si $n$ es negativo, debe devolver $-1$.

public static int padovanI(int n){
    if (n < 0) return -1;
    if (n == 0 || n == 1 || n == 2) return 1;
    
    int p_1 = 1, p_2 = 1, p_3 = 1; 
    int p = 0;
    
    for (int i = 3; i <= n; i++){
        p = p_2 + p_3;
        p_3 = p_2;
        p_2 = p_1;
        p_1 = p;
    }
    return p;
}

Manipulación de Arrays y Estructuras de Datos

a) Búsqueda del Primer Elemento Repetido (Array Unidimensional)

Implementar una función hayRepetido que tome como argumento un array de enteros positivos y devuelva el primer elemento que aparezca repetido en el array. Si no hay repetidos o el array es inválido, devuelve $-1$.

public static int hayRepetido(int a []){
    if (a == null || a.length == 0 || a.length == 1)
        return -1;
        
    // Búsqueda por fuerza bruta (O(n^2))
    for (int i = 0; i < a.length; i++)
        for (int j = i + 1; j < a.length; j++)
            if (a[i] == a[j]){
                return a[i];
            }
    return -1;
}

b) Conteo de Ocurrencias en Array Bidimensional

Implementar una función numeroOcurrencias que tome como argumento un array bidimensional de números enteros y devuelva el número de veces que aparece un elemento específico.

public static int numeroOcurrencias (int a [][], int elemento){
    if (a == null || a.length == 0)
        return -1; 
        
    int contador = 0;
    for (int i = 0; i < a.length; i++)
        for (int j = 0; j < a[i].length; j++)
            if (a[i][j] == elemento)
                contador++;
                
    return contador;
}

c) Obtención de Posiciones de un Elemento (Array Bidimensional)

Implementar una función devuelvePosicion que tome como argumentos un array bidimensional de números enteros y un número entero, y devuelva otro array bidimensional con las posiciones (fila, columna) donde se encuentra dicho número.

public static int [][] devuelvePosicion(int [][] a, int elemento){
    if (a == null || a.length == 0)
        return null;
        
    // 1. Determinar cuántas ocurrencias hay para dimensionar el array de resultados
    int numero = numeroOcurrencias(a, elemento);
    
    if (numero == 0)
        return new int [0][0]; // Devuelve un array vacío si no hay ocurrencias
        
    int [][] b = new int [numero][2]; // Array de resultados: [ocurrencia][fila, columna]
    int indice = 0;
    
    // 2. Recorrer y almacenar las posiciones
    for (int i = 0; i < a.length; i++)
        for (int j = 0; j < a[i].length; j++)
            if (a[i][j] == elemento){
                b[indice][0] = i; // Fila
                b[indice][1] = j; // Columna
                indice++;
            }
            
    return b;
}