Related Articles
Coxeter method to construct the magic square
• Difficulty Level : Medium
• Last Updated : 05 Dec, 2019

Given an odd integer N, the task is to find the magic square of order N.

Examples:

Input: N = 3
Output:
6 1 8
7 5 3
2 9 4

Input: N = 5
Output:
15 8 1 24 17
16 14 7 5 23
22 20 13 6 4
3 21 19 12 10
9 2 25 18 11

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Approach Put the value 1 in the middle of the first row. Let the position be (i, j).

1. Now move up one cell and move left one cell. While moving up or left, if we go beyond the square’s boundary, then consider a box on the opposite side of the square. Let (row, col) is the position.
2. If the value of the magic square at (row, col) is empty, then (i, j) <– (row, col).
3. If the magic[row][col] is not empty, then move down from position (i, j) to next row by incrementing i by 1. But, while moving down, if we go beyond the square’s boundary, then consider a box on the opposite side of the square.
4. Insert next higher number in the magic square at position (i, j).
5. Repeat through step 1 till all the squares are filled.

## C++

 `// C++ implementation of the approach``#include ``#include `` ` `const` `int` `MAX = 10;`` ` `// Function to print the generated square``void` `print(``int` `mat[MAX][MAX], ``int` `n)``{``    ``for` `(``int` `i = 0; i < n; i++) {``        ``for` `(``int` `j = 0; j < n; j++) {``            ``printf``(``"%3d "``, mat[i][j]);``        ``}``        ``printf``(``"\n"``);``    ``}``}`` ` `// Function to generate the magic``// square of order n``void` `magic_square(``int` `magic[MAX][MAX], ``int` `n)``{``    ``// Position of the first value``    ``int` `i = 0;``    ``int` `j = (n - 1) / 2;`` ` `    ``// First value is placed``    ``// in the magic square``    ``magic[i][j] = 1;`` ` `    ``for` `(``int` `k = 2; k <= n * n; k++) {`` ` `        ``// Up position``        ``int` `row = (i - 1 < 0) ? (n - 1) : (i - 1);`` ` `        ``// Left position``        ``int` `col = (j - 1 < 0) ? (n - 1) : (j - 1);`` ` `        ``// If no item is present``        ``if` `(magic[row][col] == 0) {`` ` `            ``// Move up and left``            ``i = row, j = col;``        ``}`` ` `        ``// Otherwise``        ``else` `{`` ` `            ``// Move downwards``            ``i = (i + 1) % n;``        ``}`` ` `        ``// Place the next value``        ``magic[i][j] = k;``    ``}``}`` ` `// Driver code``int` `main()``{``    ``int` `magic[MAX][MAX] = { 0 };``    ``int` `n = 3;`` ` `    ``if` `(n % 2 == 1) {`` ` `        ``// Generate the magic square``        ``magic_square(magic, n);`` ` `        ``// Print the magic square``        ``print(magic, n);``    ``}`` ` `    ``return` `0;``}`

## Java

 `// Java implementation of the approach ``class` `GFG ``{``    ``final` `static` `int` `MAX = ``10``; ``     ` `    ``// Function to print the generated square ``    ``static` `void` `print(``int` `mat[][], ``int` `n) ``    ``{ ``        ``for` `(``int` `i = ``0``; i < n; i++)``        ``{ ``            ``for` `(``int` `j = ``0``; j < n; j++) ``            ``{ ``                ``System.out.print(mat[i][j] + ``" "``); ``            ``} ``            ``System.out.println(); ``        ``} ``    ``} ``     ` `    ``// Function to generate the magic ``    ``// square of order n ``    ``static` `void` `magic_square(``int` `magic[][], ``int` `n) ``    ``{ ``        ``// Position of the first value ``        ``int` `i = ``0``; ``        ``int` `j = (n - ``1``) / ``2``; ``     ` `        ``// First value is placed ``        ``// in the magic square ``        ``magic[i][j] = ``1``; ``     ` `        ``for` `(``int` `k = ``2``; k <= n * n; k++)``        ``{ ``     ` `            ``// Up position ``            ``int` `row = (i - ``1` `< ``0``) ? ``                          ``(n - ``1``) : (i - ``1``); ``     ` `            ``// Left position ``            ``int` `col = (j - ``1` `< ``0``) ? ``                          ``(n - ``1``) : (j - ``1``); ``     ` `            ``// If no item is present ``            ``if` `(magic[row][col] == ``0``)``            ``{ ``     ` `                ``// Move up and left ``                ``i = row; j = col; ``            ``} ``     ` `            ``// Otherwise ``            ``else` `            ``{ ``     ` `                ``// Move downwards ``                ``i = (i + ``1``) % n; ``            ``} ``     ` `            ``// Place the next value ``            ``magic[i][j] = k; ``        ``} ``    ``} ``     ` `    ``// Driver code ``    ``public` `static` `void` `main (String[] args)``    ``{ ``        ``int` `magic[][] = ``new` `int``[MAX][MAX]; ``         ` `        ``int` `n = ``3``; ``     ` `        ``if` `(n % ``2` `== ``1``)``        ``{ ``     ` `            ``// Generate the magic square ``            ``magic_square(magic, n); ``     ` `            ``// Print the magic square ``            ``print(magic, n); ``        ``} ``    ``} ``}`` ` `// This code is contributed by AnkitRai01`

## Python 3

 `# Python 3 implementation of the approach``MAX` `=` `10`` ` `# Function to print the generated square``def` `printf(mat, n):``    ``for` `i ``in` `range``(n):``        ``for` `j ``in` `range``(n):``            ``print``(mat[i][j], end ``=` `" "``)`` ` `        ``print``(``"\n"``, end ``=` `"")`` ` `# Function to generate the magic``# square of order n``def` `magic_square(magic,n):``     ` `    ``# Position of the first value``    ``i ``=` `0``    ``j ``=` `(n ``-` `1``) ``/``/` `2`` ` `    ``# First value is placed``    ``# in the magic square``    ``magic[i][j] ``=` `1`` ` `    ``for` `k ``in` `range``(``2``, n ``*` `n ``+` `1``, ``1``):``         ` `        ``# Up position``        ``if``(i ``-` `1` `< ``0``):``            ``row ``=` `(n ``-` `1``)``        ``else``:``            ``row ``=` `(i ``-` `1``)`` ` `        ``# Left position``        ``if``(j ``-` `1` `< ``0``):``            ``col ``=` `(n ``-` `1``)``        ``else``:``            ``col ``=` `(j ``-` `1``)`` ` `        ``# If no item is present``        ``if` `(magic[row][col] ``=``=` `0``):``         ` `            ``# Move up and left``            ``i ``=` `row``            ``j ``=` `col`` ` `        ``# Otherwise``        ``else``:``             ` `            ``# Move downwards``            ``i ``=` `(i ``+` `1``) ``%` `n`` ` `        ``# Place the next value``        ``magic[i][j] ``=` `k`` ` `# Driver code``if` `__name__ ``=``=` `'__main__'``:``    ``magic ``=` `[[``0` `for` `i ``in` `range``(``MAX``)] ``                ``for` `j ``in` `range``(``MAX``)]``    ``n ``=` `3`` ` `    ``if` `(n ``%` `2` `=``=` `1``):``         ` `        ``# Generate the magic square``        ``magic_square(magic, n)`` ` `        ``# Print the magic square``        ``printf(magic, n)`` ` `# This code is contributed by Surendra_Gangwar`

## C#

 `// C# implementation of the approach``using` `System;``     ` `class` `GFG ``{``    ``static` `int` `MAX = 10; ``     ` `    ``// Function to print the generated square ``    ``static` `void` `print(``int` `[,]mat, ``int` `n) ``    ``{ ``        ``for` `(``int` `i = 0; i < n; i++)``        ``{ ``            ``for` `(``int` `j = 0; j < n; j++) ``            ``{ ``                ``Console.Write(mat[i, j] + ``" "``); ``            ``} ``            ``Console.WriteLine(); ``        ``} ``    ``} ``     ` `    ``// Function to generate the magic ``    ``// square of order n ``    ``static` `void` `magic_square(``int` `[,]magic, ``int` `n) ``    ``{ ``        ``// Position of the first value ``        ``int` `i = 0; ``        ``int` `j = (n - 1) / 2; ``     ` `        ``// First value is placed ``        ``// in the magic square ``        ``magic[i, j] = 1; ``     ` `        ``for` `(``int` `k = 2; k <= n * n; k++)``        ``{ ``     ` `            ``// Up position ``            ``int` `row = (i - 1 < 0) ? ``                          ``(n - 1) : (i - 1); ``     ` `            ``// Left position ``            ``int` `col = (j - 1 < 0) ? ``                          ``(n - 1) : (j - 1); ``     ` `            ``// If no item is present ``            ``if` `(magic[row, col] == 0)``            ``{ ``     ` `                ``// Move up and left ``                ``i = row; j = col; ``            ``} ``     ` `            ``// Otherwise ``            ``else``            ``{ ``     ` `                ``// Move downwards ``                ``i = (i + 1) % n; ``            ``} ``     ` `            ``// Place the next value ``            ``magic[i, j] = k; ``        ``} ``    ``} ``     ` `    ``// Driver code ``    ``public` `static` `void` `Main(String[] args)``    ``{ ``        ``int` `[,]magic = ``new` `int``[MAX, MAX]; ``         ` `        ``int` `n = 3; ``     ` `        ``if` `(n % 2 == 1)``        ``{ ``     ` `            ``// Generate the magic square ``            ``magic_square(magic, n); ``     ` `            ``// Print the magic square ``            ``print(magic, n); ``        ``} ``    ``} ``}`` ` `// This code is contributed by 29AjayKumar`
Output:
```6   1   8
7   5   3
2   9   4
```

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

My Personal Notes arrow_drop_up