Ciao a tutti,
Sto facendo un esercizio che mi chiede di creare una matrice ed inserire numeri interi a zig-zag, come vi mostro qui sotto partendo dal basso con lo zero:


 9 10 17 18 22 23
 3  8 11 16 19 21
 2  4  7 12 15 20
 0  1  5  6 13 14


Ho creato la matrice con un vettore in quanto prende dati dall'utente e ho realizzato una normale matrice che se fosse 4X4 sarebbe:

12 13 14 15
 8  9 10 11
 4  5  6  7
 0  1  2  3


ma non riesco proprio a capire il ragionamento dello zig zag.
Vi posto il poco codice che ho scritto:


Avete qualche idea???
Grazie a tutti!!

Purtoppo non riesco a trovare un algoritmo adatto, prima di tutto non riesco a capire se è più facile cercare di risolverla tramite dei cicli FOR il che credo sia abbastanza complicato, oppure attraverso ricorsione ed includere tutte le diverse soluzioni ma viene una cosa lunghissima e quasi sicuramente non corretta.

Se procediamo per ricorsione:
parto dalla prima cella:

if ((r==0) && (c==0)) {
        matrix[c*cols+r]=n+=1;
        step=true;
        return GetFunction(r,c+1);
}

step è una variabile booleana che mi dice se prima ho fatto un passo orizzontale o verticale perchè se l'ho fatto allora devo andare in diagonale, e da qui comincio a fare tutte le ipotesi con la clausola IF.

Cosa ne pensi?

Aspetta, prima di arrivare al codice. Sai riempire la matrice che ti ho dato coi numeri da 0 a 14, scrivendoli manualmente?

Esatto: come hai fatto?

1) Parto dall'angolo in basso a sinistra e scrivo 0.
2) Mi sposto a destra. Scrivo 1.

....

passi 3, 4,  5 e 6?

Formalizzala meglio, e con più chiarezza e calma: devi pensare ad un algoritmo che dovrai descrivere al computer. Traccia base:

1) Parto dall'angolo in basso a sinistra. Scrivo 0.
2) Si può andare a destra?
    * Se sì vado lì e scrivo numero dopo.
    * Se no: si può andare in alto?
          * Se sì vado in alto e scrivo il numero dopo
          * Se no ho finito
3) Si può andare in alto a sinistra?
    * Se sì:
          * vado lì e scrivo il numero dopo.
          * Ripeto il punto (3)
4) ...?

Sfortunatamente non ho molto tempo, ma vi lascio almeno questo fondamentale suggerimento col quale giocare un po'.


Eccone l'output:


 0  1  2  3  4  5  6  7  8
 1  2  3  4  5  6  7  8  9
 2  3  4  5  6  7  8  9 10
 3  4  5  6  7  8  9 10 11
 4  5  6  7  8  9 10 11 12
 5  6  7  8  9 10 11 12 13
 6  7  8  9 10 11 12 13 14
 7  8  9 10 11 12 13 14 15
 8  9 10 11 12 13 14 15 16


Vedete qualcosa di interessante?
Per ogni antidiagonale, quale che sia la dimensione della matrice (anche rettangolare), la somma degli indici è costante e identifica univocamente l'antidiagonale stessa (e perfino la sua lunghezza, con un minimo di riflessione). Fatto banale, ma forse non ovvio di primo acchito.
Da qui, tutto il resto è in discesa. Non occorre perdere tempo a gestire tutte le combinazioni di casi particolari per tenere gli indici "dentro" la struttura, o ricorrere al solito operatore modulo tuttofare. Si tratta semplicemente di popolare ciascuna antidiagonale, seguendo direzioni adeguatamente alternate, per poi ruotare o specchiare, secondo la specifica istanza del problema, l'intera matrice al termine del lavoro.


EDIT: Prima di fornire ulteriori spunti per una soluzione in C (in fondo non credo ne abbiate bisogno), voglio sottolineare ancora una volta perché APL e J sono i miei linguaggi preferiti per questo genere di cose. Ricordo che pochi anni fa un thread del genere è stato lanciato nella mailing list di J: ne sono scaturite diverse soluzioni di grande fascino, oltre all'occasione di conoscere uno dei tanti episodi meno noti sull'eccezionale figura di Kenneth Iverson, creatore del linguaggio.

Una delle migliori soluzioni generali si configura come segue:

Dove 7 e 8 sono dei parametri esemplificativi, e rappresentano le dimensioni della matrice generata. Non male, eh?