Scarica Dispensa di Informatica - JAVA programmazione e più Dispense in PDF di Elementi di Informatica solo su Docsity!
Fondamenti di informatica, corso A
Appunti sulle matrici in java
Ing. Alessia Amelio
Il nostro obiettivo consiste nell’analizzare il modo in cui è possibile accedere a varie porzioni di una matrice in java, soffermandoci sulle variazioni degli indici di riga e di colonna e su come ciò consentirà di realizzare l’output desiderato.
Come sappiamo, data una matrice in java, è possibile accedere ai suoi elementi utilizzando un indice di riga e uno di colonna. Ad esempio, data la matrice M in figura:
i numeri in rosso rappresentano gli indici di riga e di colonna. Dati i campi istanza M.length e M[0].length, che identificano rispettivamente il numero delle righe e il numero delle colonne della matrice M, gli indici variano sempre da 0 a M.length-1 per le righe e da 0 a M[0].length-1 per le colonne.
Nel caso in cui la matrice dovesse essere quadrata, come nell’esempio, il numero delle righe è uguale al numero delle colonne, pertanto M[0].length = M.length.
Accesso agli elementi lungo la diagonale principale
Gli elementi posti lungo la diagonale principale della matrice (quelli segnati in verde) hanno la caratteristica di avere sempre uguali l’indice di riga e quello di colonna.
i
j
Per accedere dunque a tali elementi, è sufficiente utilizzare un unico ciclo di for in questo modo:
for(int i=0; i<M.length; i++) M[i][i] //usa come vuoi gli elementi cui accedi La traccia del frammento di codice, considerando la matrice M nell’esempio, è la seguente: 1° iterazione i = 0 M[0][0]=
2° iterazione i = 1 M[1][1]=
3° iterazione i = 2 M[2][2]=8 end
Accesso agli elementi lungo la diagonale secondaria
Gli elementi posti lungo la diagonale secondaria sono segnati in blu all’interno della matrice.
Vogliamo accedere a tali elementi da destra verso sinistra, quindi in questo caso l’ordine è 5,3,6.
Possiamo farlo anche in questo caso utilizzando un unico ciclo di for che scandisce le colonne della matrice a partire dall’ultima (M[0].length-1) fino alla prima (indice 0) e sfruttando tale indice per fare avanzare anche la riga.
for(int j=M[0].length-1; j>=0;j--) M[M[0].length-1-j][j] //usa gli elementi acceduti
L’indice di riga corrente può essere ottenuto sottraendo dall’indice dell’ultima riga M.length-1 (o colonna, è analogo in quanto la matrice è quadrata) il corrente indice di colonna j, in quanto stiamo considerando le colonne in ordine inverso mentre dobbiamo scandire le righe dalla prima all’ultima.
Il linguaggio java risolverà per prima cosa l’espressione racchiusa nelle parentesi quadre al fine di calcolare il corrente indice di riga e poi accederà alla locazione in cui si trova l’elemento corrente.
La traccia del frammento di codice considerando la matrice M nell’esempio è la seguente:
per i=2 l’indice di colonna dovrà spaziare da 0 a 2.
Il codice java che consente di ottenere un tale risultato è il seguente.
//senza gli elementi della diagonale principale for(int i=1; i<M.length;i++) for(int j=0; j<i; j++) //usa M[i][j] //con gli elementi della diagonale principale for(int i=0; i<M.length;i++) for(int j=0; j<=i; j++) //usa M[i][j] La traccia di esecuzione dei due frammenti di codice rispetto alla matrice di esempio risulta pertanto:
caso 1) senza elementi diagonale i= j=0 j<i? M[1][0] stop i= j=0 j<i? M[2][0] j=1 j<i? M[2][1] stop i= j=0 j<i? M[3][0] j=1 j<i? M[3][1] j=2 j<i? M[3][2] stop end
caso 2) con elementi diagonale i= j=0 j<=i? M[1][0] j=1 j<=1? M[1][1] stop
i= j=0 j<=i? M[2][0] j=1 j<=i? M[2][1] j=2 j<=i? M[2][2] stop i= j=0 j<=i? M[3][0] j=1 j<=i? M[3][1] j=2 j<=i? M[3][2] j=3 j<=i? M[3][3] stop end
Accesso al triangolo superiore della matrice
Al fine di accedere agli elementi posti nella parte triangolare superiore della matrice, occorre osservare la variazione degli indici di riga e di colonna e la loro eventuale dipendenza.
E’ possibile subito notare che l’indice di riga dovrà variare da 0 a M.length-1, mentre l’indice di colonna dovrà assumere un valore dipendente da quello assunto dall’indice di riga.
In particolare, l’indice di colonna dovrà spaziare dal valore i, che di volta in volta assume l’indice di riga, fino a M[0].length-1.
Nel caso in cui volessimo escludere dal conteggio gli elementi della diagonale principale (ovvero prendere solo gli elementi segnati in blu nell’esempio), dato i l’indice di riga, quello di colonna dovrà spaziare di volta in volta da i+1 a M[0].length-1. Ad esempio, per i=0, si può facilmente vedere che l’indice di colonna dovrà spaziare da 1 a 3.
Nel caso in cui, invece, volessimo considerare l’intero triangolo superiore della matrice (con inclusi gli elementi della diagonale principale), dovremmo consentire all’indice di colonna di variare da i incluso a M[0].length-1. Ad esempio, per i=2 l’indice di colonna dovrà spaziare da 2 a 3.
Il codice java che consente di ottenere un tale risultato è il seguente.
j=3 j<4? M[0][3] stop i= j=1 j<4? M[1][1] j=2 j<4? M[1][2] j=3 j<4? M[1][3] stop i= j=2 j<4? M[2][2] j=3 j<4? M[2][3] stop i= j=3 j<4? M[3][3] stop end
Divisione della matrice tramite la diagonale secondaria
La diagonale secondaria divide la matrice in due parti: una triangolare inferiore (in verde) e una triangolare superiore (in blu).
0 1 2 3 0 4 5 6 2 1 3 8 4 3 2 5 6 9 2 3 1 0 6 7
Accesso al triangolo inferiore della matrice
Al fine di accedere agli elementi posti nella parte triangolare inferiore della matrice, occorre osservare la variazione degli indici di riga e di colonna e la loro eventuale dipendenza.
E’ possibile subito notare che l’indice di riga dovrà variare fino a M.length-1, mentre l’indice di colonna dovrà assumere un valore dipendente da quello assunto dall’indice di riga.
Vogliamo accedere agli elementi in ordine inverso rispetto alle colonne, partendo quindi dall’ultima colonna e andando man mano a ritroso.
Pertanto, l’indice di colonna dovrà spaziare da M[0].length-1 a (M[0].length-1-i) che dipenderà dal valore assunto di volta in volta dall’indice di riga i.
Nel caso in cui volessimo escludere dal conteggio gli elementi della diagonale secondaria (ovvero prendere solo gli elementi segnati in verde nell’esempio), l’indice di riga dovrà spaziare da 1 a M.length-1 mentre l’indice di colonna dovrà spaziare da M[0].length-1 a (M[0].length-1-i) escluso e andare man mano a ritroso decrementando il proprio valore. Ad esempio, per i=2, si può facilmente vedere che l’indice di colonna dovrà partire da 3 e andare a ritroso fino a (M[0].length-1-i) che equivale al valore 1 (escluso).
Nel caso in cui, invece, volessimo considerare l’intero triangolo inferiore della matrice (con inclusi gli elementi della diagonale secondaria), dovremmo consentire all’indice di riga di variare da 0 a M.length-1 (al fine di includere l’elemento in posizione 0,0) e all’indice di colonna di variare da M[0].length-1 a (M[0].length-1-i) incluso. Ad esempio, per i=2, l’indice di colonna dovrà partire da 3 e andare a ritroso fino a 1 ( questa volta incluso).
Il codice java che consente di ottenere un tale risultato è il seguente.
//senza gli elementi della diagonale secondaria for(int i=1; i<M.length;i++) for(int j=M[0].length-1; j>M[0].length-1-i; j--) //accedi a M[i][j];
//con gli elementi della diagonale secondaria for(int i=0; i<M.length;i++) for(int j=M[0].length-1; j>=M[0].length-1-i; j--) //accedi a M[i][j];
La traccia di esecuzione dei due frammenti di codice rispetto alla matrice di esempio risulta pertanto:
caso 1) senza elementi diagonale i= j=3 j>(M[0].length-1-i)=2? M[1][3]
j=0 j>=(M[0].length-1-i)=0? M[3][0] end
Accesso al triangolo superiore della matrice
Al fine di accedere agli elementi posti nella parte triangolare superiore della matrice, occorre osservare la variazione degli indici di riga e di colonna e la loro eventuale dipendenza.
E’ possibile subito notare che l’indice di riga deve variare da 0 a M.length-1, mentre l’indice di colonna dovrà assumere un valore dipendente da quello assunto dall’indice di riga.
Pertanto, l’indice di colonna dovrà spaziare da 0 a (M[0].length-1-i) che dipenderà dal valore assunto di
volta in volta dall’indice di riga i.
Nel caso in cui volessimo escludere dal conteggio gli elementi della diagonale secondaria (ovvero prendere solo gli elementi segnati in blu nell’esempio), l’indice di colonna dovrà spaziare da 0 a (M[0].length-1-i) escluso, dato un generico valore di i. Ad esempio, per i=0, si può facilmente vedere che l’indice di colonna dovrà partire da 0 e andare avanti fino a (M[0].length-1-i) che equivale al valore 3 (escluso).
Nel caso in cui, invece, volessimo considerare l’intero triangolo inferiore della matrice (con inclusi gli elementi della diagonale secondaria), dovremmo consentire all’indice di colonna di variare da 0 a (M[0].length-i) escluso, per ogni dato valore di i. Ad esempio, per i=1 l’indice di colonna dovrà partire da 0 e andare avanti fino a (M[0].length-i) escluso che equivale a 3, ovvero dovrà essere compreso tra 0 e 2.
Il codice java che consente di ottenere un tale risultato è il seguente.
//senza gli elementi della diagonale secondaria for(int i=0; i<M.length;i++) for(int j=0; j<M[0].length-1-i; j++) //accedi a M[i][j];
//con gli elementi della diagonale secondaria for(int i=0; i<M.length;i++) for(int j=0; j<M[0].length-i; j++) //accedi a M[i][j];
La traccia di esecuzione dei due frammenti di codice rispetto alla matrice di esempio risulta pertanto:
caso 1) senza elementi diagonale
i= j=0 j<(M[0].length-1-i)=3? M[0][0] j=1 j<(M[0].length-1-i)=3? M[0][1] j=2 j<(M[0].length-1-i)=3? M[0][2] j=3 j<(M[0].length-1-i)=3? no stop
i= j=0 j<(M[0].length-1-i)=2? M[1][0] j=1 j<(M[0].length-1-i)=2? M[1][1] j=2 j<(M[0].length-1-i)=2? no stop i= j=0 j<(M[0].length-1-i)=1? M[2][0] j=1 j<(M[0].length-1-i)=1? no stop end
caso 2) con elementi diagonale
i= j=0 j<(M[0].length-i)=4? M[0][0] j=1 j<(M[0].length-i)=4? M[0][1] j=2 j<(M[0].length-i)=4? M[0][2]
distinguendo i vari casi in base al punto in cui ci si trova. Nel caso in cui l’indice di riga dovesse essere pari a 0 oppure a M.length-1, vuol dire che siamo in corrispondenza della prima o dell’ultima riga della matrice, per cui dobbiamo scandire l’intera riga indipendentemente dal valore dell’indice di colonna. Nel caso in cui, invece, l’indice di riga dovesse assumere un valore intermedio, occorrerà considerare solamente l’elemento corrispondente alla colonna 0 e quello corrispondente alla colonna M[0].length-1, ovvero gli elementi posti lungo la riga ma in corrispondenza della prima e dell’ultima colonna. Nella matrice di esempio, quando l’indice di riga assumerà il valore 0, bisognerà prendere tutti gli elementi della riga, ovvero 4,5,6,2. Quando l’indice di riga assumerà, invece, il valore 1 e 2, bisognerà prendere i soli elementi 3,3 e 5,2. Infine, quando l’indice di riga assumerà un valore pari a M[0].length-1 (ovvero 3), bisognerà considerare tutti gli elementi posti lungo la riga, ovvero 1,0,6,7. A questo punto l’accesso alla cornice della matrice sarà completato. Il frammento di codice seguente mostra un’implementazione dell’algoritmo appena descritto.
for(int i=0;i<m.length;i++) if(i==0||i==m.length-1){ for(int j=0;j<m[0].length;j++) //accedi a m[i][j] }else if(i<m.length-1){ //accedi a m[i][0] //accedi a m[i][m[0].length-1] }
La traccia di esecuzione del frammento di codice rispetto alla matrice di esempio risulta pertanto:
i=0 (i==0||i==M.length-1)? j=0 M[0][0] j=1 M[0][1] j=2 M[0][2] j=3 M[0][3] stop
i=1 (i==0||i==M.length-1)? no M[1][0] M[1][3]
i=2 (i==0||i==M.length-1)? no M[2][0] M[2][3]
i=3 (i==0||i==M.length-1)?
j=0 M[3][0] j=1 M[3][1] j=2 M[3][2] j=3 M[3][3] stop
end
Esercizio
Dato il seguente codice in java:
public static int eleDispariCornice (int[][]m, int p){
int contaDispari=0; for(int i=p;i<m.length-p;i++) if(i==p||i==m.length-1-p){ for(int j=p;j<m[0].length-p;j++) if(m[i][j]%2!=0)contaDispari++; }else if(i<m.length-1-p){ if(m[i][p]%2!=0)contaDispari++; if(m[i][m[0].length-1-p]%2!=0)contaDispari++; } return contaDispari; }//eleDispariCornice
spiegare cosa risolve il metodo e impostare la traccia di esecuzione dell’algoritmo.
