/*
 * Click nbfs://nbhost/SystemFileSystem/Templates/Licenses/license-default.txt to change this license
 * Click nbfs://nbhost/SystemFileSystem/Templates/Classes/Class.java to edit this template
 */
package repaso4.pkg5;

import java.util.Arrays;
import java.util.Random;

/**
 *
 * @author mario
 */
public class Ex4y5 {

    public static void main(String[] args) {
        calcularAryVol(5, 10);

        System.out.println(Arrays.toString(puntoMedio(2, 4, 2, 4)));

        System.out.println(conversionMetros(52.5, 500));

        int num = lucas(3);
        System.out.println(num);

        System.out.println(esCapicua(5445));

        System.out.println(Arrays.toString(rellenaMultiplos(250, 2)));

        int t[] = {4, 7, 2, 9, 5, 1};

        System.out.println(Arrays.toString(maximos(t, 2)));

        int[][] t2 = 
        {
            {1, 2, 3},
            {4, 5, 6},
            {7, 8, 9}
        };
        System.out.println(Arrays.toString(sumaArrayBid(t2)));
    }

    //Ejercicio 1.
    /*
    Diseña una función que reciba como parámetro el radio de un cilindro y su altura, y muestre por pantalla el área total y el volumen del cilindro.
    Fórmulas:
    •         Área total = 2 · π · radio · (radio + altura)
    •         Volumen = π · radio² · altura
     */
    //Como va a imprimir, no devuelve nada.
    public static void calcularAryVol(double radio, double altura) {
        //IMPORTANTE:
        //- Clase Math
        //- Determinar que devuelve.

        double area = 2 * Math.PI * radio * (radio + altura);
        double volumen = Math.PI * Math.pow(radio, 2);

        System.out.println("Imprimiendo área: " + area);
        System.out.println("Imprimiendo volumen: " + volumen);
    }

    /*
    Ejercicio 2.
    Implementa la función:
    double[] puntoMedio(double x1, double y1, double x2, double y2)
    que devuelva las coordenadas del punto medio entre los puntos (x1, y1) y (x2, y2).
    Fórmula:
    •         x = (x1 + x2) / 2
    •         y = (y1 + y2) / 2
     */
    public static double[] puntoMedio(double x1, double y1, double x2, double y2) {
        //Devuelve un array de dos posiciones double[0]=x, double[1]=y
        double[] posiciones = new double[2];

        posiciones[0] = (x1 + x2) / 2; //Posición x.
        posiciones[1] = (y1 + y2) / 2; //Posición y.

        //Siempre devuelve un valor del tipo definido en la cabecera.
        return posiciones;
    }

    /*
    Ejercicio 3 (1 punto)
    Escribe una función que reciba una distancia expresada en kilómetros y metros, y 
    devuelva la distancia total expresada únicamente en metros.
     */
    public static double conversionMetros(double km, double metros) {
        return km * 1000 + metros;
    }

    /*
    Ejercicio 4 (1 punto)
    
    Diseña una función recursiva que calcule el n-ésimo número de la sucesión de Lucas. La sucesión de Lucas se define como:
    •         lucas(n) = lucas(n − 1) + lucas(n − 2)
    •         lucas(0) = 2
    •         lucas(1) = 1
     */
    public static int lucas(int n) {
        //Cuando defines una función de recursividad, es imprescindible determinar cual es su finalización.
        if (n > 1) {
            return lucas(n - 1) + lucas(n - 2);
        } else if (n == 1) {
            return 1;
        } else { //Se supone que n==0
            return 2;
        }
    }

    /*
    Ejercicio 5 (1 punto)
    Escribe una función que determine si un número es un número capicúa. 
    La función devolverá true si el número se lee igual de izquierda a derecha que de derecha a izquierda, y false en caso contrario.
    Ejemplos:
    •         121 → capicúa
    •         3443 → capicúa
    •         123 → no capicúa
     */
    public static boolean esCapicua(int num) {
        String numeroIzqADer = String.valueOf(num); //Izquierda a derecha.

        //De derecha a izquierda
        String numeroDerAIzq = "";

        for (int i = numeroIzqADer.length() - 1; i >= 0; i--) {
            numeroDerAIzq += numeroIzqADer.charAt(i);
        }

        return numeroDerAIzq.equals(numeroIzqADer);

    }

    /*
   Ejercicio 7 (1,5 puntos)
    Escribe la función:
    int[] rellenaMultiplos(int longitud, int num)
    que cree y devuelva un array de la longitud indicada, rellenado con números aleatorios que sean múltiplos de num, comprendidos entre 1 y 100 (inclusive).
    El array devuelto deberá estar ordenado de menor a mayor.
    Usa la función en el main e imprime por pantalla el array resultante.
     */
    public static int[] rellenaMultiplos(int longitud, int num) {
        Random rd = new Random();
        int[] numeros = new int[0];

        while (numeros.length < longitud) {
            int aleatorio = rd.nextInt(1, 101);

            if (aleatorio % num == 0) {
                numeros = Arrays.copyOf(numeros, numeros.length + 1);
                numeros[numeros.length - 1] = aleatorio;
            }
        }
        Arrays.sort(numeros);
        return numeros;
    }

    /*
    Ejercicio 8 (1,5 puntos)
    Implementa la función:
    int[] maximos(int t[], int numElementos)
    que cree y devuelva un array con el valor máximo de cada grupo de numElementos consecutivos del array t.
    Ejemplo:
    Si t = [4, 7, 2, 9, 5, 1] y numElementos = 3, se obtendrán:
    •         max(4, 7, 2) → 7
    •         max(7, 2, 9) → 9
    •         max(2, 9, 5) → 9
    •         max(9, 5, 1) → 9
    Resultado: [7, 9, 9, 9]
     */
    public static int[] maximos(int t[], int numElementos) {
        int[] maximos = new int[0];

        //Bucle Doble
        //Bucle principal mide donde empieza y termina la "regla".
        for (int i = 0; i < t.length - numElementos + 1; i++) {
            //System.out.println("Primer Elmemento: "+t[i]);

            System.out.println("Calculando máximos:");
            int max = 0;
            for (int j = i; j < i + numElementos; j++) {
                if (t[j] > max) {
                    max = t[j];
                }

                if (j == i) {
                    max = t[j];
                }
                System.out.println(t[j] + "");
            }
            System.out.println("Fin Máximo: " + max);
            maximos = Arrays.copyOf(maximos, maximos.length + 1);
            maximos[maximos.length - 1] = max;
        }

        return maximos;

    }

    /*
    Ejercicio 9 (1 punto)
    Dado un array bidimensional de enteros que representa una tabla de números, recorre la matriz y construye un array unidimensional que contenga la suma de cada fila del array bidimensional.
    Imprime por pantalla el array resultante. Ejemplo:
    •         Si la matriz es:
    1  2  3
    4  5  6
    7  8  9
    •   El array resultante será: [6, 15, 24]
     */
    public static int[] sumaArrayBid(int[][] t) {
        int[] sumas = new int[t.length];

        for (int i = 0; i < t.length; i++) {
            int suma = 0;

            for (int j = 0; j < t[i].length; j++) {
                suma += t[i][j];
            }
            sumas[i] = suma;
        }
        return sumas;

    }
}
