[C] "Quadrato magico"

Non riesco a capire come risolvere il seguente esercizio:
Un quadrato magico è un quadrato di questo tipo:

$((16,3,2,13),(5,10,11,8),(9,6,7,12),(4,15,14,1))$


[questo quadrato magico proviene da un'incisione di Albrecht Dürer del 1514]

Dove la somma delle righe, delle colonne e delle diagonali sono identiche.

Scrivere un programma che stampi un quadrato magico $n*n$, dove la somma delle righe, delle colonne e delle diagonali è sempre la stessa. L'utente specificherà il valore di $n$.

Schermata tipica:

This program creates a magic square of a specified size.
The size must be an odd number between $1$ and $99$.
Enter the size of the magic square: 5
$((17,24,1,8,15),(23,5,7,14,16),(4,6,13,20,22),(10,12,19,21,3),(11,18,25,2,9))$

Suggerimento: iniziare mettendo il numero $1$ in mezzo alla riga $0$.

Mi potreste dare qualche spunto/suggerimento su come si può fare?

Ci sono anche degli ulteriori suggerimenti aggiuntivi:
Disporre i numeri rimanenti 2,3,... $n^2$ movendosi in su di una riga e di una colonna. Qualsiasi tentativo di andare oltre i limiti del vettore deve "arrotolarsi"¹ sulla faccia opposta del vettore stesso. Per esempio invece di memorizzare il prossimo numero nella colonna $n$, lo memorizzerà nella colonna $0$. Se un particolare elemento del vettore è già occupato mettere il numero immediatamente sotto il numero che è stato memorizzato precedentemente. Se il vostro compilatore supporta i vettori a lunghezza variabile, dichiarare un vettore di n righe ed n colonno, In caso contrario dichiarare il vettore in maniera tale che abbia $99$ righe e $99$ colonne.

Sarebbe da usare dei cicli.

---

Note

1. Sta proprio scritto così ↑

Una modalità per comporre un quadrato magico "standard" di ordine dispari è quello di iniziare a mettere il numero $1$ in mezzo alla prima riga e poi proseguire disponendo gli altri nella posizione in diagonale appena più in alto ovvero una colonna più a destra ed una riga più in alto.
Quando vai "fuori" dal quadrato, se esci in alto riparti dalla riga più in basso, se esci a destra riparti dalla colonna più a sinistra.
Se la "casella" di destinazione è già "occupata" riparti dalla casella appena sottostante quella dove ti trovi.

Osserva bene quello che ti è stato fornito e vedrai che funziona

Cordialmente, Alex

Grazie mille della risposta, avrei due domande, che però non riesco a risolvere.
quando mi trovo nel "vertice" in alto a destra del quadrato, per esempio il 15 di questo quadrato:
$ ((17,24,1,8,15),(23,5,7,14,16),(4,6,13,20,22),(10,12,19,21,3),(11,18,25,2,9)) $

Dove devo andare?

La seconda domanda è questa:
L'ultimo numero del quadrato si trova sempre nella stessa colonna centrale dell' $1$ e nell'ultima riga?

La seconda è "sì" (così almeno mi pare di ricordare )
Per la prima: le regole son sempre le stesse

Eccolo. Grazie ai tuoi consigli ho risolto l'esercizio.
In questo tipo di esercizi mi risulta più che altro difficile capire la "matematica" che ci sta dietro, una volta fatto ciò mettere giù due righe di codice (anche se probabilmente sono stato un po' sovrabbondante sulle condizioni sugli elementi del quadrato, in ogni caso funziona e genera quadrati magici che è un piacere) è relativamente semplice.

La seconda è "sì" (così almeno mi pare di ricordare )

Si è così. Generandone un po' si vede che l'ultimo elemento finisce sempre nella casella a metà dell'ultima riga.

Testo nascosto, perché contrassegnato dall'autore come fuori tema. Fai click in quest'area per vederlo.

Codice:

#include<stdio.h>
#include<stdlib.h>

#define N 99

int main(void)
{
    int quadrato[N][N]={0};
    int n=0;
    int max=0;
    int ultimo_numero=0;
    int numero_corrente=1;
    int i=0;
    int j=0;

    printf("Questo programma genera un quadrato magico di dimensione specificata dall'utente\n");
    printf("La sua dimensione deve essere un numero dispari compreso tra 1 e %d.", N);

    do{
    printf("Inserire la dimensione del desiderata:\t");
    scanf("%d", &n);
    if(n%2==0||n<=0)
    {
        printf("\n\t******************\n\t*NUMERO INVALIDO!*\n\t******************\n\n");
    };
    }while(n%2==0||n<=0);

    max=n-1;
    ultimo_numero=n*n;
    i=0;
    j=max/2;
    quadrato[i][j]=numero_corrente;


   while(numero_corrente<=ultimo_numero)
   {
       numero_corrente=numero_corrente+1;
       if((i-1>=0)&&(j+1<=max)&&(quadrato[i-1][j+1]==0))
       {
           i=i-1;
           j=j+1;
           quadrato[i][j]=numero_corrente;
       }else if((i-1>=0)&&(j+1<=max)&&(quadrato[i-1][j+1]!=0)&&(quadrato[i+1][j]==0)&&(i+1<=max))
       {
           i=i+1;
           quadrato[i][j]=numero_corrente;
       }else if((i-1<0)&&(j+1<=max)&&(quadrato[max][j+1]!=0))
       {
           i=max;
           j=j+1;
           quadrato[i][j]=numero_corrente;
       }else if((i-1)<0&&(j+1>max)&&(quadrato[i+1][j]==0))
       {
           i=i+1;
           quadrato[i][j]=numero_corrente;
       }else if((i-1>=0)&&(j+1>max)&&(quadrato[i-1][0]==0))
       {
           i=i-1;
           j=0;
           quadrato[i][j]=numero_corrente;
       }else if((i-1<0)&&(j+1<=max)&&(quadrato[max][j+1]==0))
       {
           i=max;
           j=j+1;
           quadrato[i][j]=numero_corrente;
       }else
       {
           ;
       };

   };
   printf("\n\n\tQuadrato magico:\n\n");
   for(i=0; i<=max; i++)
   {
       for(j=0; j<=max; j++)
       {
           printf("%.3d  ", quadrato[i][j]);
            if(j==max)
       {
           printf("\n");
       };
       };

   };


exit(0);
}