/**
 * Questa classe collezione tutti i metodi per gli esercizi 1, 2 e 3 della
 * lezione di laboratorio del 21/11/2022.
 */

public class Metodi {

    /** Esercizio 1 */
    public static int massimo(int[] a) {
        // Attenzione.. se inizializzo max con il numero 0, il metodo non funziona
        // se l'array a ha solo numeri negativi, perché chiaramente 0 è maggiore di
        // tutti i numeri negativi e viene restituito come risultato anche se è
        // sbagliato. Devo inizializzarlo con un valore presente nell'array. Il testo
        // del compito dice chiaramente che possiamo assumere che l'array non è vuoto,
        // quindi a[0] esiste.

        int max = a[0];

        // In questo ciclo parto ad esaminare l'array a dalla posizione 1. Comunque
        // funzionerebbe anche partendo da i=0, sebbene farebbe una iterazione in più
        // inutile.
        for (int i = 1; i < a.length; i++) {
            // in alternativa all'if, potremmo usare il metodo Math.max che calcola
            // il massimo tra due numeri con:
            // max = Math.max(max, a[i]);
            if (a[i] > max)
                max = a[i];
        }
        return max;
    }

    /** Esercizio 2 */
    public static int[] creaPieno(int n, int v) {
        // Caso speciale quando n è negativo. Senza questo controllo, l'istruzione
        // "new int[n]" genererebbe un errore (un array di lunghezza negativa non ha
        // senso).
        if (n < 0)
            return new int[0];
        int[] a = new int[n];
        for (int i = 0; i < n; i++) {
            a[i] = v;
        }
        return a;
    }

    /** Esercizio 3 */
    public static boolean confronta(int[] a1, int[] a2) {
        // Prima di tutto controlla se le lunghezze sono diverse. Se sono diverse, i due
        // array non possono contenere gli stessi elementi nello stesso ordine, e quindi
        // restituiamo subito false.
        if (a1.length != a2.length)
            return false;

        // Ora scorriamo tutte le posizioni dei due array, alla ricerca di una posizione
        // i in cui a1[i] e a2[i] differiscono. Notare che come estremo del for usiamo
        // a1.length. Avremmo potuto usare anche a2.length, tanto se siamo arrivato qui
        // vuol dire che la condizione dell'if di prima era falsa, ovvero che
        // "a1.length == a2.length".
        for (int i = 0; i < a1.length; i++) {
            if (a1[i] != a2[i])
                // Non appena troviamo una posizione i in cui a1[i] e a2[i] differiscono, siamo
                // sicuri che a1 e a2 non posono essere uguali, e restituitamo subito false
                // (questo
                // termina anche subito il ciclo for... è come se avesse il break integrato!)
                return false;
        }
        // Se siamo arrivati a questo punto senza uscire prima, vuol dire che tutti gli
        // elementi di a1 sono uguali ai corrispettivi elementi di a2. Possiamo
        // restituire false.
        return true;
    }

    /** Esercizio 4 */
    public static int[] sommaVettori(int a1[], int a2[]) {
        // Creo il nuovo vettore di lunghezza a1.length. Notare che il testo
        // dell'esercizio dice che possiamo assumere che la lunghezza di a1 e di a2 è
        // uguale. Questo vuol dire che ci basta che il programma funzioni sotto queste
        // condizioni. Se quando le lunghezze il programma non funziona non è un
        // problema.
        var r = new int[a1.length];
        for (int i = 0; i < a1.length; i++) {
            r[i] = a1[i] + a2[i];
        }
        return r;
    }
}