Matrice diagonale

[5t4rdu5t]

Mi sn incasinato in un esercizio per farlo devo scorrere la matrice diagonalmente in teoria dovrei: per ogni riga partire dalla prima colonna e con un altro ciclo interno, ad ogni iterazione aumentare la colonna e diminuire la riga e fare dei controlli ma nn capisco cm metterlo in pratica .... il primo for si capisce ma l' altro?come dovrei farlo partire??!

[desa]

Ciclo più interno (con "riga1" indice del ciclo più esterno):

int riga2 = riga1;
int colonna = 0;

while (riga2 >= 0 && colonna < matrice[riga2].length)
{
// CONTROLLI CHE DEVI FARE
. . .
  riga2--;
  colonna++;
}

La stessa cosa, naturalmente, si può realizzare anche con un ciclo for

[5t4rdu5t]

in pratica dovrei fare una cosa del genere???

byte [][] A={{1,3,3},  
            {2,0,6}
            {7,8,9}};
int numRighe = A.length;
int numColonne=A[0].length;
while(numRighe>=0 && numColonne<A.[numRighe].length){

numRighe--;
numColonne++;
				
}

[desa]

Come avevi correttamente detto tu, i cicli sono due: uno sulle righe (e avevi scritto che ti era chiaro) e un altro, interno al primo, che è quello che ti ho postato.
Avevi detto che il procedimento diagonale deve, per ogni riga, partire dalla prima colonna: qui invece lo inizializzi all'ultima (e, oltretutto, sono sbagliate sia l'inizializzazione che l'incremento dell'indice sulle colonne).

In realtà, ti era sufficiente definire l'array di byte e implementare il ciclo più esterno...

[5t4rdu5t]

mmm sarà che ho fatto confusione io scusa... visto che il while è il 2 ciclo il primo che sarebbe il for che indici usa??? è fino ad A.length???

[desa]

In base alla traccia che hai scritto nel primo post, è una semplicissima iterazione sulle righe: parti da indice 0 (la prima riga) e cicli fino a A.length (escluso); un for va più che bene. Nel codice che ti avevo postato, avevo chiamato questo indice "riga1"

[5t4rdu5t]

allora ho fatto delle correzioni sul ragionamento il primo ciclo cioè il for nn va fino ad A.length ma fino a righeteoriche= numRow - numColum(

for(int i=0; i<righeteoriche; i++){

) poi mi creo altre due variabili in metto il ragionamento di prima aumenta la colonna e diminuisco la riga:

int R; int C;
			if(i < NumRow){
				R=i;
				C=0;
			}
			else {
				R= NumRow-1;
			        C= i-NumRow+1;
			}

dopo qst parte metto il while ma qst lo vediamo dopo! Di più vorrei sapere passo dopo passo cosa succedde? Ammettiamo una matrice 3x3... Io provando nel foglio faccio:
all' inizio i è zero ho la prima locazione 0-0;
i=1 e va alla locazione 1-0 fin qui ok.. dopo fa 0-1
e poi ho la locazione 2-0.... MA prima alla 0-1 come arriva?? la C=0 fa si che scorre diagonalmente???

[5t4rdu5t]

Forse ho capito perchè si arriva alla locazione 1-0 grz al ciclo while:

while(R >= 0 && C < NumColum){
				
	//......
                       R--;
                          C++;
}

[desa]

Allora, sempre in base a quello che hai detto tu, provo a farti un esempio.
Ipotizziamo di avere la matrice 3x3:
1 2 3
4 5 6
7 8 9

Le diagonali che devi considerare sono:
1
4-2
7-5-3

Ciclo 1:
Consideri la prima riga (indice 0).
Entri nel ciclo interno con indici (0,0) e analizzi quindi l'elemento "1".
Alla successiva iterazione decrementi la riga e incrementi la colonna e devi considerare l'elemento con indici (-1,1). Poichè questo non esiste, esci dal ciclo.

Ciclo 2:
Consideri la seconda riga (indice 1).
Entri nel ciclo interno con indici (1,0) e analizzi quindi l'elemento "4".
Alla successiva iterazione decrementi la riga e incrementi la colonna e devi considerare l'elemento con indici (0,1). Analizzi quindi l'elemento "2".
Alla successiva iterazione decrementi la riga e incrementi la colonna e devi considerare l'elemento con indici (-1,2). Poichè questo non esiste, esci dal ciclo.

Ciclo 3:
Consideri la terza riga (indice 2).
Entri nel ciclo interno con indici (2,0) e analizzi quindi l'elemento "7".
Alla successiva iterazione decrementi la riga e incrementi la colonna e devi considerare l'elemento con indici (1,1). Analizzi quindi l'elemento "5".
Alla successiva iterazione decrementi la riga e incrementi la colonna e devi considerare l'elemento con indici (0,2). Analizzi quindi l'elemento "3".
Alla successiva iterazione decrementi la riga e incrementi la colonna e devi considerare l'elemento con indici (-1,3). Poichè questo non esiste, esci dal ciclo.

[5t4rdu5t]

Originariamente inviato da desa
Allora, sempre in base a quello che hai detto tu, provo a farti un esempio.
Ipotizziamo di avere la matrice 3x3:........

Questa spiegazione sarebbe il for cn gli if ed in fine il while compreso??!!