public class ArrayDiArray {

    /**
     * Metodo che prende in input un array 2d di interi e restituisce la somma di tutti gli
     * elementi.
     */
    public static int somma(int[][] a) {
        int somma = 0;
        for (int i = 0; i < a.length; i++)
            // notare l'uso di a[i].length come estremo superiore del for interno. a[i].length
            // è la lunghezza della riga i-esima di a (se pensiamo a come una tabella).
            for (int j = 0; j < a[i].length; j++)
                somma = somma + a[i][j];
        return somma;
    }

    /**
     * Variante del metodo somma che utilizza il for-each invece del for normale.
     */
    public static int somma2(int[][] a) {
        int somma = 0;
        // Il ciclo esterno seleziona un elemento alla volta di a. Ricordiamo che gli elementi di
        // a sono array, ognuno corrispondente ad una riga.
        for (int[] riga : a)
            // Il ciclo interno scorre gli elementi della riga selezionata dal ciclo esterno.
            for (int v : riga)
                somma = somma + v;
        return somma;
    }

    /**
     * Scrivere un metodo che, preso un array 2d di interi a, restituisca un array 1d di interi che
     * contiene lo somme delle righe di a. Esempio: se l'input è l'array { { 1 2 3 }, { 4 5 6 } }
     * restituisce l'array { 6, 15 }.
     */
    public static int[] sommaPerRighe(int[][] a) {
        int[] risultato = new int[a.length];
        // qui facciamo con i for classici, ma ovviamente si può fare con i for-each come in somma2.
        for (int i = 0; i < a.length; i++) {
            for (int j = 0; j < a[i].length; j++)
                risultato[i] += a[i][j];
        }
        return risultato;
    }

    /**
     * Metodo che prende in input un array 1d di interi e restituisce la somma di tutti gli
     * elementi. L'abbiamo visto nelle lezioni precedenti, e qui lo usiamo per semplificare il
     * metodo sommaPerRighe.
     *
     * Notare che abbiamo già un metodo somma in questa classe, ma i due metodi prendono parametri
     * diversi: il metodo somma alla riga 7 prende un array 2d di interi, questo prende un array 1d.
     * Java capisce quale volete chiamare dal tipo dei parametri passati.
     */
    public static int somma(int[] a) {
        int somma = 0;
        for (int v : a)
            somma += v;
        return somma;
    }

    /**
     * Variabile di sommaPerRighe che utilizza il metodo somma qui sopra per semplificare il codice.
     */
    public static int[] sommaPerRighe2(int[][] a) {
        int[] risultato = new int[a.length];
        // qui facciamo con il for classico, ma ovviamente si può fare con i for-each
        for (int i = 0; i < a.length; i++)
            // invece di scorrere gli elementi di a[i] uno alla volta, chiamo direttamente
            // sommaArray che si occupa di calcolare il risultato.
            risultato[i] = somma(a[i]);
        return risultato;
    }

    /**
     * Metodo che prende in input due vettori 2d e somma al primo vettore gli elementi del 2° nella
     * stessa posizione. Supponiamo che i due array 2d abbiano la stessa "forma" (cioè stesso numero
     * di righe e colonne).
     */
    public static void sommaMatriciSulPosto(int[][] a, int[][] b) {
        // Qui dobbiamo necessariamente usare i for tradizionali. I for-each non andrebbero bene
        // perché non ci consentono di mettere in corrispondenza gli elementi di a e b nella stessa
        // posizione.
        for (int i = 0; i < a.length; i++)
            for (int j = 0; j < a[i].length; j++)
                a[i][j] = a[i][j] + b[i][j];
    }

    /**
     * Variante di sommaMatriciSulPost che che restituisce la somma dei due array senza modificare
     * il primo parametro. In questo metodo supponiamo che la struttura di a e b sia regolare, nel
     * senso che ogni riga ha lo stesso numero di colonne.
     */
    public static int[][] sommaMatrici(int[][] a, int[][] b) {
        // numero di righe del risultato uguale al numero di righe di a
        int nrighe = a.length;
        // Numero di colonne del risultato, uguale al nuero di colonne della prima riga di a.
        // Funziona perché abbiamo detto che ci limitiamo al caso in cui la struttura di a e b è
        // regolare. In realtà, stiamo anche supponendo che a abbia almeno una riga, altrimenti a[0]
        // fallisce con un errore.
        int ncolonne = a[0].length;
        // Creo l'array risultato, il resto procede quasi come sommaArray2D
        int[][] risultato = new int[nrighe][ncolonne];
        for (int i = 0; i < nrighe; i++)
            for (int j = 0; j < ncolonne; j++)
                risultato[i][j] = a[i][j] + b[i][j];
        return risultato;
    }

    /**
     * Variante di sommaArray2Doutput che funziona anche se a e b hanno una struttura irregolare
     * (righe diverse hanno lunghezza diversa).
     */
    public static int[][] sommaMatrici2(int[][] a, int[][] b) {
        // Creo l'array risultato, inizializzato parzialmente. Non posso fare altro perché righe
        // diverse potrebbero avere lunghezze diverse. In questo modo ogni elemento di a è "null",
        // e creerò i vettori corrispondenti alle righe durante il ciclo for esterno.
        int nrighe = a.length;
        int[][] risultato = new int[nrighe][];
        for (int i = 0; i < nrighe; i++) {
            // L'elemento i-esimo di risultato dovrebbe contenere la somma delle righe i-esima di
            // a e di b. Al momento, però, risultato[i] è null. La prima cosa da fare è quindi
            // creare la riga risultato[i] con la lunghezza opportuna.
            int ncolonne = a[i].length;
            risultato[i] = new int[ncolonne];
            // A questo punto risultato[i] esiste e possiamo riempirlo con i valori corretti.
            for (int j = 0; j < ncolonne; j++)
                risultato[i][j] = a[i][j] + b[i][j];
        }
        return risultato;
    }

}