esercizio di informatica

/*
#include <stdio.h>
#include <stdlib.h>
#define max 100


Dati r e c, caricare una matrive mat[r][c] in ordine a spirale destra con numeri
sequenziali partendo da 1 passo 1. per i piu' bravi caricare una seconda matrice uguale,
ma caricando la sequenza a spirale sinistra.



int main()
{
///inizializzazione variabili:
int r,co,i_r=0,i_c=0; ///Righe e colonne della matrice + indici da utilizzare per il loro spostamento.
int num=1; ///numeri da inserire all'interno della matrice.
int cont=0; ///Contatore da utilizzare per completare tutti i passaggi del caricamento.
int a,b,c,d,e,f,g,h; ///Indici che determinano il limite di movimento.
int mat[max][max]; ///Matrice a spirale da caricare.

///1) Inserimento delle righe e delle colonne.
printf("Inserisci il numero delle righe della matrice: \n");
do
{
scanf("%d", &r);
}
while(r<=0);

printf("\n\nInserisci il numero delle colonne della matrice: \n");
do
{
scanf("%d", &co);
}
while(co<=0);

///2) Inizializzazione matrice.
do
{
do
{
mat[i_r][i_c]=0;
i_c++; ///Incremento l'indice delle colonne
}
while(i_c<co);
i_c=0; ///Rimettiamo l'indice a 0 per un nuovo ciclo
i_r++; ///Incremeno l'indice delle righe per avanzare di livello nella matrice.
}
while(i_r<r);
cont=r*co; ///Definiamo il numero di celle presenti nella matrice.

///Rimettiamo gli indici a 0 per le operazioni successive.
i_r=0;
i_c=0;

///3) Definiamo gli indici di spostamento.
a=0; ///a è a 0 perchè si trova nella fase iniziale.
b=co; ///b assume la lunghezza delle colonne.
c=0; ///c assume lo stesso valore di a.
d=r; ///imposto d della stessa lunghezza delle righe per la fase finale.
e=co; ///imposto e alla fase iniziale
f=0; ///imposto f a 0.
g=r; ///g si trova alla fase finale.
h=0; ///h si trova a 0 per la fase iniziale.

///4) Caricamento della spirale.
///Con il primo ciclo controllo quando il procedimento è stato concluso con successo,
///con i 4 cicli al suo interno effettuo il caricamento della matrice grazie agli indici sopra scritti,
///caricandola fino all'ultima cella. I cicli si susseguiranno finchè gli indici di righe e colonne
///non saranno uguali ad i rispettivi indici di movimento, a seconda della posizione dove ci troviamo
///ad operare.
do
{
///1° CICLO: caricamento delle colonne;
///incremento la matrice con la variabile "num" che incremento attraverso il ciclo,
///per poi decrementare il cont in modo da sapere quante celle restano da riempire.
do
{
if(mat[i_r][i_c]==0)
{
mat[i_r][i_c]=num;
num++;
cont--;
}
i_c++; ///si incrementa le colonne.
}
while(i_c<b);
i_r=c;
i_c=b-1;

///2° CICLO: caricamento delle righe;
///incremento la matrice con la variabile "num" che incremento attraverso il ciclo,
///per poi decrementare il cont in modo da sapere quante celle restano da riempire.
do
{
if(mat[i_r][i_c]==0)
{
mat[i_r][i_c]=num;
num++;
cont--;
}
i_r++;
}
while(i_r<d);
i_r=g-1;
i_c=e-1;

///3° CICLO: caricamento delle colonne;
///incremento la matrice con la variabile "num" che incremento attraverso il ciclo,
///per poi decrementare il cont in modo da sapere quante celle restano da riempire.
///stavolta devo decrementare l'indice delle colonne per riempire le celle che stanno prima
///del suo valore.
do
{
if(mat[i_r][i_c]==0)
{
mat[i_r][i_c]=num;
num++;
cont--;
}
i_c--;
}
while(i_c>=f);
i_r=g-1;
i_c=a;

///4° CICLO: caricamento delle righe;
///incremento la matrice con la variabile "num" che incremento attraverso il ciclo,
///per poi decrementare il cont in modo da sapere quante celle restano da riempire.
///stavolta devo decrementare l'indice delle righe per riempire le celle che stanno prima
///del suo valore.
do
{
if(mat[i_r][i_c]==0)
{
mat[i_r][i_c]=num;
num++;
cont--;
}
i_r--;
}
while(i_r>=h);

///Una volta terminati i cicli, incrementiamo gli indici di partenza (a,c,f,h) e decrementiamo invece
///quelli di arrivo (b,d,e,g), in modo che al giro successivo l'operazione si ripeta ma fermandosi
///di un posto prima.
a++;
b--;
c++;
d--;
e--;
f++;
g--;
h++;
///Rimettiamo gli indici ai valori delle rispettive partenze:
///le righe assumeranno il valore di "h" e le colonne di "a".
i_r=h;
i_c=a;
}
while(cont>0);
///Non appena il contatore raggiungerà lo 0, il ciclo più grande terminerà e noi
///avremo la matrice caricata e pronta per essere visualizzata.


///5)Visualizzazione a video.
///Ora che abbiamo terminato il caricamento, rimettiamo gli indici di righe e colonne a 0
///ed effettuiamo il classico ciclo per caricare la matrice:
i_r=0;
i_c=0;
printf("\n\nLa matrice a spirale \x8a\: \n\n");

do
{
do
{
printf("[%d]\t ", mat[i_r][i_c]);
i_c++;
}
while(i_c<co);
i_c=0;
printf("\n");
i_r++;
}
while(i_r<r);
///Il ciclo terminerà quando anche le righe avranno raggiunto la lunghezza di "r".

return 0;///Fine Programma.
}
*/