/* *************************************************************************
 * Ora tratteremo gli array a 2 dimensioni. Un array a 2 dimensioni si puo'
 * considerare un array di array monodimensionali, o in altri termini una
 * matrice righe-colonne, molto simile ad una scacchiera o al reticolo
 * della battaglia navale. La tabellina pitagorica puo' essere considerata
 * un'array, ad esempio.
 * In realta' Java non gestisce array multidimensionali "veri" come il C,
 * ma array di array, che pero' nella pratica funzionano come quelli C.
 * La differenza sta anche nel fatto che le dimensioni si possono allocare
 * separatamente, anziche' tutte insieme.
 * Ecco come si definisce e alloca un array a 2 dimensioni:
 *
 *      tipo[] nome = new tipo[dimensione1] [dimensione2];
 *
 * Come esempio, definiamo un array con 3 righe e 5 colonne, ossia 3*5=15
 * elementi:
 *
 *      int[] tabelluccia = new int[3][5];
 *
 * In questo modo creeremo una tabella del genere:
 *
 *	[0][0]	[0][1]	[0][2]	[0][3]	[0][4]
 *
 *	[1][0]	[1][1]	[1][2]	[1][3]	[1][4]
 *
 *	[2][0]	[2][1]	[2][2]	[2][3]	[2][4]
 *
 * Con [0][0] si intende il primo elemento, e per raggiungere gli altri si
 * devono variare i 2 indici opportunamente.
 * Per scrivere un valore nell'elemento [1][2], si fa cosi':
 *
 *	tabelluccia[1][2]=10;		* Scrivo nell'elemento [1][2] *
 *
 * Il primo indice e' quello che corrisponde alle righe, mentre il secondo
 * corrisponde alle colonne. Ora stamperemo una tabellina pitagorica.
 * Nel corso di questo programma vedremo dei loop for nidificati; un loop
 * e' nidificato quando si trova all'interno di un altro ciclo, ad es:
 *
 * for (i=0; i<10; i++)		* Loop esterno per fare tutte le righe *
 *  {
 *     for (j=0; j<10; j++) tabba[i][j]=5; * Loop interno che fa una riga *
 *  }
 *
 * Questi 2 loop nidificati riempiono l'array tabba con valori 5.
 * Il loop for interno, la prima volta che e' eseguito, ha i che vale 0
 * e j varia da 0 a 9:
 *
 * [0][0] [0][1] [0][2] [0][3] [0][4] [0][5] [0][6] [0][7] [0][8] [0][9]
 *
 * La seconda volta che e' eseguito, i vale 1:
 *
 * [1][0] [1][1] [1][2] [1][3] [1][4] [1][5] [1][6] [1][7] [1][8] [1][9]
 *
 * E cosi' via, finche' il loop esterno non termina con i=9.
 * SI possono usare array a 3 o piu' dimensioni:
 *
 *      int[][][] prova = new int[4][4][4];
 *
 * Vediamo il programmino pitagorico.
 ************************************************************************* */

import java.io.*;         // Include le funzioni I/O standard di base.


class Jlez3d {            // Da qua inizia la classe Jlez3d

 public static void main(String args[])  // Definiamo il metodo Main.
 {                                       // Inizio del main()

    int  i,j;            // Due variabili intere che mi servono come
                         // contatori per righe e colonne dell'array

    int[][] tabba = new int[10][10];  // Tabella di 10*10=100 elementi

/* ------------------------------------------------------------------------
 * Con questi 2 loop nidificati creiamo la tabella pitagorica, ossia
 * diamo come valore di ogni elemento dell'array la moltiplicazione del
 * suo indice i per l'indice j, ossia il risultato di riga*colonna, infatti
 * nella tabella pitagorica all'incrocio di righe e colonne si trova proprio
 * il risultato della moltiplicazione di riga*colonna.
 * Occorrono 2 loop nidificati perche' con il loop interno si fa una riga,
 * il quale e' ripetuto per il numero delle righe i, in modo da farle tutte.
 * ---------------------------------------------------------------------- */

    for (i=0; i<10; i++)         // Loop esterno... numero righe: 10
    {
       for (j=0; j<10; j++) tabba[i][j]=i*j; /* Facciamo la moltiplicazione
                                              * i*j per tutta la riga col
                                              * loop for nidificato. */
    }

/* ------------------------------------------------------------------------
 * Ora con altri 2 loop for nidificati stampiamo tutti i valori della
 * tabella a video nell'ordine giusto, lo stesso della scrittura.
 * Da notare che saltiamo gli indici 0, che essendo sempre zero non ci
 * interessano.
 * ---------------------------------------------------------------------- */

    for (i=1; i<10; i++)         // Loop esterno per fare tutte le righe
    {
       for (j=1; j<10; j++)      // Loop interno che stampa una riga
       {
          System.out.print("  " + tabba[i][j]);  // Stampiamo un valore
       }
       System.out.println();     // a capo ad ogni incremento di i
    }


 }               // Fine del metodo principale Main()

}            // Fine della classe Jlez3d

/* *************************************************************************
 * Purtroppo il System.out.print() non ha i parametri di formattazione
 * del printf() del C, per cui le prime righe risultano piu' corte delle
 * ultime, avendo queste ultime numeri a 2 cifre.
 * Questo problema e' solo estetico, e lo sapremo risolvere piu' avanti,
 * qundo conosceremo piu' classi di package.
 ************************************************************************* */