problema comprensione ciclo for innestato

[pianca90]

Buongiorno a tutti,
ho un problema di comprensione in merito a una soluzione di un tema d'esame.

In particolare devo creare una struttura di questo tipo:

Cattura.JPG

La soluzione proposta è la seguente:

public String toString() {
char campo[][] = new char[8][8];
String output = "|";
for (int i=0; i<8; i++)
output += "-";
output += "|\n";
for (int j=0; j<8; j++)
for (int i=0; i<8; i++)
campo[i][j] = ’ ’;
for (int j=0; j<8; j++) {
output += "|";
for (int i=0; i<8; i++)
output += campo[i][j];
output += "|\n";
}
output += "|";
for (int i=0; i<8; i++)
output += "-";
output += "|\n";

L'uso degli indici (i,j) mi pare non sia corretto per formare quanto richiesto.

In particolare non riesco a comprendere bene questo ciclo for evidenziato.

Qualcuno riesce a darmi delucidazioni?

Grazie

SPOSTARE PER CORTESIA IN SOTTOSEZIONE JAVA. GRAZIE

[KillerWorm]

Ciao, hai provato quel codice per vedere cosa ne salta fuori?

Da quel che ho provato io, mi pare sia corretto. Non comprendo la tua perplessità sugli indici di quel particolare ciclo.

Potrebbe tuttalpiù esserci un errore sintattico in riferimento a questa riga:

campo[i][j] = ’ ’;

Gli apici obliqui (o virgolette inglesi o come si chiamano) penso non siano utilizzabili per quello scopo.

Per definire una variabile di tipo char, come il carattere "spazio" in questo caso, si usano gli apici singoli (' ').

Questa riga sta dentro un doppio ciclo:

for (int j=0; j<8; j++)
for (int i=0; i<8; i++)
campo[i][j] = ' ';

attraverso il quale sarà popolato l'array campo (array bidimensionale 8x8 di tipo char, come definito inizialmente) che conterrà dei singoli caratteri "spazio".

Il ciclo da te evidenziato non fa altro che recuperare questi singoli elementi (eseguendo un altro doppio ciclo analogo al precedente) e aggiungerli quindi alla stringa output.

Probabilmente andrà sviluppata la parte dove devi definire gli elementi "1" e "2" (come da tua immagine).
Questi elementi li puoi definire dopo che l'array campo è stato popolato. In sostanza puoi sovrascrivere i valori indicati andando a specificare i due indici per campo, deducibili attraverso l'immagine della struttura.

Forse per leggere e comprendere meglio il codice può essere utile aggiungere le parentesi graffe là dove sono state omesse e indentare opportunamente il tutto:

char campo[][] = new char[8][8];
String output = "|";
for (int i=0; i<8; i++) {
    output += "-";
}
output += "|\n";
for (int j=0; j<8; j++) {
    for (int i=0; i<8; i++) {
        campo[i][j] = ' ';
    }
}

// qui si potrebbero definire gli altri valori nelle specifice posizioni dell'array campo

for (int j=0; j<8; j++) {
    output += "|";
    for (int i=0; i<8; i++) {
        output += campo[i][j];
    }
    output += "|\n";
}
output += "|";
for (int i=0; i<8; i++) {
    output += "-";
}
output += "|\n";

Spero di averti delucidato opportunamente.

[pianca90]

for (int j=0; j<8; j++) {
output += "|";
for (int i=0; i<8; i++) {
output += campo[i][j];
}
output += "|\n";
}
output += "|";
for (int i=0; i<8; i++) {
output += "-";
}
output += "|\n";[/code]

Grazie della risposta,
effettivamente ho provato ad eseguire il codice e funziona alla perfezione. Il problema è mio che mi manca un passaggio di comprensione molto probabilmente.

Cerco di spiegarmi così magari mi dite dove sbaglio:

Il FOR esterno con variabile j prende valore 0 e in output viene aggiunta la stringa "|" poi il controllo passa al FOR interno con variabile i=0.
Ora in output tramite filed[i][j] viene aggiunto il contenuto dell'array in quelle posizioni in particolare in

field[0][0]
field[1][0]
field[2][0]

e così via finchè non si arriva al limite del LATO = 8.

Ma sbaglio o l'array bidimensionale viene riempito "verticalmente" e non "orizzontalmente"?
Come si inserisce quindi nei giusti punti il carattere di bordo riquadro "|" e poi si va a capo?


Spero di essermi spiegato abbastanza bene.

Grazie

[KillerWorm]

Ma sbaglio o l'array bidimensionale viene riempito "verticalmente" e non "orizzontalmente"?

Non sbagli, a livello programmatico potrebbe essere inteso in quel modo se per "verticalmente" intendi il fatto che la matrice sia definita (e letta) scorrendola prima per il primo indice e quindi per il secondo.
Non farti però trarre in inganno; presumo sia stato impostato in questo modo per un motivo ben preciso: facendo riferimento alla struttura indicata dall'immagine, il primo indice identifica le colonne, mentre il secondo identifica le righe.
Se ci riferissimo ad un sistema cartesiano, puoi notare che i due indici corrisponderebbero agli assi [x][y], che vengono convenzionalmente indicati proprio in questo preciso ordine per l'identificazione delle coordinate.
Nel tuo caso il sistema è costituito da [colonna][riga]. Il primo indice fa quindi riferimento agli elementi, letti in orizzontale, da sinistra verso destra (cioè la posizione delle colonne per ogni singola riga) mentre, il secondo, fa riferimento alle righe, lette quindi in verticale, dall'alto verso il basso (cioè la posizione delle righe).
Se ne deduce che per ottenere questa lettura sia necessario scorrere la matrice prima per il primo indice e quindi per il secondo.

Come si inserisce quindi nei giusti punti il carattere di bordo riquadro "|" e poi si va a capo?

Nel tuo caso, considera che i due indici della matrice fanno riferimento alle posizioni dei singoli spazi contenuti all'interno della cornice. La struttura in output occupa uno spazio complessivo 10x10, compresi i caratteri che costituiscono la cornice stessa, per cui il contenuto (rappresentato dall'array) è una matrice 8x8; considerando quindi che campo[0][0] costituisce il primo carattere "spazio", all'interno della cornice, nell'angolo in alto a sinistra.

I caratteri che costituiscono la cornice non stanno quindi dentro l'array campo (o field o quel che è), in cui sono invece definiti solo i caratteri contenuti all'interno del riquadro (come già detto), ma il bordo, e relativi ritorno a capo, sono man mano aggiunti alla stringa output attraverso i vari cicli, andando sempre a costruirla da sinistra verso destra e dall'alto verso il basso.

Spero sia più chiaro adesso, o quantomeno spero di non averti confuso maggiormente le idee

[pianca90]

Non sbagli, a livello programmatico potrebbe essere inteso in quel modo se per "verticalmente" intendi il fatto che la matrice sia definita (e letta) scorrendola prima per il primo indice e quindi per il secondo.
Non farti però trarre in inganno; presumo sia stato impostato in questo modo per un motivo ben preciso: facendo riferimento alla struttura indicata dall'immagine, il primo indice identifica le colonne, mentre il secondo identifica le righe.
Se ci riferissimo ad un sistema cartesiano, puoi notare che i due indici corrisponderebbero agli assi [x][y], che vengono convenzionalmente indicati proprio in questo preciso ordine per l'identificazione delle coordinate.
Nel tuo caso il sistema è costituito da [colonna][riga]. Il primo indice fa quindi riferimento agli elementi, letti in orizzontale, da sinistra verso destra (cioè la posizione delle colonne per ogni singola riga) mentre, il secondo, fa riferimento alle righe, lette quindi in verticale, dall'alto verso il basso (cioè la posizione delle righe).
Se ne deduce che per ottenere questa lettura sia necessario scorrere la matrice prima per il primo indice e quindi per il secondo.


Nel tuo caso, considera che i due indici della matrice fanno riferimento alle posizioni dei singoli spazi contenuti all'interno della cornice. La struttura in output occupa uno spazio complessivo 10x10, compresi i caratteri che costituiscono la cornice stessa, per cui il contenuto (rappresentato dall'array) è una matrice 8x8; considerando quindi che campo[0][0] costituisce il primo carattere "spazio", all'interno della cornice, nell'angolo in alto a sinistra.

I caratteri che costituiscono la cornice non stanno quindi dentro l'array campo (o field o quel che è), in cui sono invece definiti solo i caratteri contenuti all'interno del riquadro (come già detto), ma il bordo, e relativi ritorno a capo, sono man mano aggiunti alla stringa output attraverso i vari cicli, andando sempre a costruirla da sinistra verso destra e dall'alto verso il basso.

Spero sia più chiaro adesso, o quantomeno spero di non averti confuso maggiormente le idee

Ma quindi non é una regola generale che la prima coppia di parentesi rappresenta l indice di riga e la seconda coppia l indice di colonna?

Grazie

[KillerWorm]

Ma quindi non é una regola generale che la prima coppia di parentesi rappresenta l indice di riga e la seconda coppia l indice di colonna?

Non ne ho idea, ma in questo caso è esattamente il contrario.
I dati dentro una matrice (un array o quel che è) potresti definirli come meglio ti pare; l'importante è sapere come sono organizzati per poterli poi prelevare correttamente.
Non so dirti se esistono regole generali o altre convenzioni.

[andbin]

Ma quindi non é una regola generale che la prima coppia di parentesi rappresenta l indice di riga e la seconda coppia l indice di colonna?

Negli array multi-dimensionali, l'accesso espresso con array[a][b][c] ..... [n] l'indice a è la prima dimensione, b è la seconda dimensione, ecc...
Nel caso di array bidimensionali (2 dimensioni), quindi l'indice a è la "riga" e l'indice b è la "colonna". A due dimensioni è così ed è anche facile da pensare. Per più dimensioni, è chiaramente più difficile immaginare idealmente la struttura. A 3 dimensioni è un "cubo" di dati, a 4 è .... un array di cubi (o un cubo di array ;P ).

[pianca90]

Nel caso di array bidimensionali (2 dimensioni), quindi l'indice a è la "riga" e l'indice b è la "colonna".

Non sembra essere così però nel problema da me postato....eppure l'esercizio viene eseguito correttamente.


Andbin riesci a dare una motivazione per questo?


Grazie

[pianca90]

E il bello è che funziona anche invertendo gli indici i e j all'interno dei cicli....anzi, secondo me è così che dovrebbe funzionare...solo così...

[andy_concept]

La risposta è questa:

Nel tuo caso, considera che i due indici della matrice fanno riferimento alle posizioni dei singoli spazi contenuti all'interno della cornice. La struttura in output occupa uno spazio complessivo 10x10, compresi i caratteri che costituiscono la cornice stessa, per cui il contenuto (rappresentato dall'array) è una matrice 8x8; considerando quindi che campo[0][0] costituisce il primo carattere "spazio", all'interno della cornice, nell'angolo in alto a sinistra.

I caratteri che costituiscono la cornice non stanno quindi dentro l'array campo (o field o quel che è), in cui sono invece definiti solo i caratteri contenuti all'interno del riquadro (come già detto), ma il bordo, e relativi ritorno a capo, sono man mano aggiunti alla stringa output attraverso i vari cicli, andando sempre a costruirla da sinistra verso destra e dall'alto verso il basso.

Prova a rendere il contenuto leggibile, es:

int c = 47;
for (int i = 0; i < 8; i++) {
    for (int j = 0; j < 8; j++)
        campo[i][j] = (char) ++c;
}

e ad invertire gli indici (non dappertutto, ovviamente)