somma += array[i-j][i];
xchè fai i-j?
Sfutto una sorta di proprietà delle matrici che mi è venuta in mente osservando le coordinate degli elementi:
[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]
[3][0] [3][1] [3][2] [3][3] [3][4]
[4][0] [4][1] [4][2] [4][3] [4][4]
1. Guarda la diagonale principale, gli elementi sono:
[0][0] [1][1] [2][2] [3][3] [4][4]
2. di quella immediatamente sopra sono:
[0][1] [1][2] [2][3] [3][4]
3. poi:
[0][2] [1][3] [2][4]
4. poi:
[0][3] [1][4]
5. infine:
[0][4]
Ho voluto implementare questo algoritmo affinché conducesse la somma degli elementi diagonale per diagonale (e utilizzando due sole variabili).
Se osservi, la differenza tra le due coordinate [x][y] degli elementi aumenta di uno per ogni diagonale mano a mano che risaliamo a quella più in alto a destra. Va da un minimo di zero ad un massimo di N-1. Facciamo quindi un ciclo for appropriato:
codice:
for(j=0; j<N; j++) {
...
}
Questo for quindi, che strutturiamo come ciclo maggiore, quello più esterno, regola questa differenza e di conseguenza stabilisce la diagonale sulla quale lavoriamo.
Abbiamo posto quindi che la variabile j indichi la differenza tra le due coordinate.
Fatto ciò, stabiliamo che un'altra variabile (i) debba indicare una delle due coordinate, in modo tale che da questa, tenendo conto della differenza (e quindi o sottraendo j da i oppure sommandola, a seconda che della coordinata che indichiamo con i), riusciamo a ricavarci l'altra. Io gli ho fatto indicare la y (ma anche con la x le cose cambiano di poco).
Ora dobbiamo scrivere un ciclo interno che, all'interno di una diagonale, determini quindi la colonna y sulla quale ci troviamo. Osserviamo che le coordinate delle colonne partono per la prima diagonale da zero, per la seconda da uno, per la terza da 2, ecc... La y, diagonale dopo diagonale, varia nell'intervallo che va da 0 a N-1, allo stesso modo della differenza. Possiamo quindi porla uguale a j all'inizio di ognuno di questi cicli minori. Però, nell'elaborazione di una diagonale, assume dei valori che hanno come estremità superiore sempre N-1, ma l'estremità inferiore appunto varia al variare della diagonale e quindi della differenza e quindi di j.
Scriviamo quindi il ciclo interno:
codice:
for(i=j; i<N; i++)
somma += array[i-j][i];
Ricapitolando, il primo ciclo stabilisce la diagonale sulla quale lavoriamo, il secondo ne stabilisce dapprima la colonna e quindi (sottraendo a questa la differenza) ne individua la riga.
Per rendertene meglio conto esegui questo ciclo:
codice:
...
for(j=0; j<N; j++) {
for(i=j; i<N; i++) {
somma += array[i-j][i];
/**/ printf("\narray[%d][%d] = %d - Somma = %d", i-j, i, array[i-j][i], somma);
}
}
...
Come ho già detto può sembrare un po' criptico, ma visto che me lo hai chiesto ho cercato di spiegarlo.
Se non hai capito qualcosa sono qua.
ps: scusa se mi sono spiegato un po' male ma sono le 11 si sera!!