# Magic squares of odd order

Magic squares of odd order
You are encouraged to solve this task according to the task description, using any language you may know.

A magic square is an ${\displaystyle N\times N}$ square matrix whose numbers (usually integers) consist of consecutive numbers arranged so that the sum of each row and column, and both long (main) diagonals are equal to the same sum (which is called the magic number or magic constant).

The numbers are usually (but not always) the 1st ${\displaystyle N^{2}}$ positive integers.

A magic square whose rows and columns add up to a magic number but whose main diagonals do not, is known as a semimagic square.

 8 1 6 3 5 7 4 9 2

For any odd ${\displaystyle N}$, generate a magic square with the integers ${\displaystyle [1,}$ ${\displaystyle \ldots ,}$ ${\displaystyle N^{2}]}$ and show the results. Optionally, show the magic number.

You should demonstrate the generator by showing at least a magic square for ${\displaystyle N=5}$.

Also see

procedure Magic_Square is

  N: constant Positive := Positive'Value(Ada.Command_Line.Argument(1));

subtype Constants is Natural range 1 .. N*N;
Undef: constant Natural := 0;

  subtype Index is Natural range 0 .. N-1;
function Inc(I: Index) return Index is (if I = N-1 then 0 else I+1);
function Dec(I: Index) return Index is (if I = 0 then N-1 else I-1);

A: array(Index, Index) of Natural := (others => (others => Undef));
-- initially undefined; at the end holding the magic square

X: Index := 0; Y: Index := N/2; -- start position for the algorithm


begin

  for I in Constants loop -- write 1, 2, ..., N*N into the magic array
A(X, Y) := I; -- write I into the magic array
if A(Dec(X), Inc(Y)) = Undef then


X := Dec(X); Y := Inc(Y); -- go right-up

     else


X := Inc(X); -- go down

     end if;
end loop;

for Row in Index loop -- output the magic array
for Collumn in Index loop


CIO.Put(A(Row, Collumn), Width => (if N*N < 10 then 2 elsif N*N < 100 then 3 else 4));

     end loop;
end loop;


end Magic_Square;</lang>

Output:
>./magic_square 3
8 1 6
3 5 7
4 9 2
>./magic_square 11
68  81  94 107 120   1  14  27  40  53  66
80  93 106 119  11  13  26  39  52  65  67
92 105 118  10  12  25  38  51  64  77  79
104 117   9  22  24  37  50  63  76  78  91
116   8  21  23  36  49  62  75  88  90 103
7  20  33  35  48  61  74  87  89 102 115
19  32  34  47  60  73  86  99 101 114   6
31  44  46  59  72  85  98 100 113   5  18
43  45  58  71  84  97 110 112   4  17  30
55  57  70  83  96 109 111   3  16  29  42
56  69  82  95 108 121   2  15  28  41  54

## AutoHotkey

<lang autohotkey> msgbox % OddMagicSquare(5) msgbox % OddMagicSquare(7) return

OddMagicSquare(oddN){ sq := oddN**2 obj := {} loop % oddN obj[A_Index] := {} ; dis is row mid := Round((oddN+1)/2) sum := Round(sq*(sq+1)/2/oddN) obj[1][mid] := 1 cR := 1 , cC := mid loop % sq-1 { done := 0 , a := A_index+1 while !done { nR := cR-1 , nC := cC+1 if !nR nR := oddN if (nC>oddN) nC := 1 if obj[nR][nC] ;filled cR += 1 else cR := nR , cC := nC if !obj[cR][cC] obj[cR][cC] := a , done := 1 } }

str := "Magic Constant for " oddN "x" oddN " is " sum "n" for k,v in obj { for k2,v2 in v str .= " " v2 str .= "n" } return str } </lang>

Output:
Magic Constant for 5x5 is 65
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

Magic Constant for 7x7 is 175
30 39 48 1 10 19 28
38 47 7 9 18 27 29
46 6 8 17 26 35 37
5 14 16 25 34 36 45
13 15 24 33 42 44 4
21 23 32 41 43 3 12
22 31 40 49 2 11 20


## AWK

<lang AWK>

1. syntax: GAWK -f MAGIC_SQUARES_OF_ODD_ORDER.AWK

BEGIN {

   build(5)
build(3,1) # verify sum
build(7)
exit(0)


} function build(n,check, arr,i,width,x,y) {

   if (n !~ /^[0-9]*[13579]$/ || n < 3) { printf("error: %s is invalid\n",n) return } printf("\nmagic constant for %dx%d is %d\n",n,n,(n*n+1)*n/2) x = 0 y = int(n/2) for (i=1; i<=(n*n); i++) { arr[x,y] = i if (arr[(x+n-1)%n,(y+n+1)%n]) { x = (x+n+1) % n } else { x = (x+n-1) % n y = (y+n+1) % n } } width = length(n*n) for (x=0; x<n; x++) { for (y=0; y<n; y++) { printf("%*s ",width,arr[x,y]) } printf("\n") } if (check) { verify(arr,n) }  } function verify(arr,n, total,x,y) { # verify sum of each row, column and diagonal  print("\nverify")  1. horizontal  for (x=0; x<n; x++) { total = 0 for (y=0; y<n; y++) { printf("%d ",arr[x,y]) total += arr[x,y] } printf("\t: %d row %d\n",total,x+1) }  1. vertical  for (y=0; y<n; y++) { total = 0 for (x=0; x<n; x++) { printf("%d ",arr[x,y]) total += arr[x,y] } printf("\t: %d column %d\n",total,y+1) }  1. left diagonal  total = 0 for (x=y=0; x<n; x++ y++) { printf("%d ",arr[x,y]) total += arr[x,y] } printf("\t: %d diagonal top left to bottom right\n",total)  1. right diagonal  x = n - 1 total = 0 for (y=0; y<n; y++ x--) { printf("%d ",arr[x,y]) total += arr[x,y] } printf("\t: %d diagonal bottom left to top right\n",total)  } </lang> Output: magic constant for 5x5 is 65 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 magic constant for 3x3 is 15 8 1 6 3 5 7 4 9 2 verify 8 1 6 : 15 row 1 3 5 7 : 15 row 2 4 9 2 : 15 row 3 8 3 4 : 15 column 1 1 5 9 : 15 column 2 6 7 2 : 15 column 3 8 5 2 : 15 diagonal top left to bottom right 4 5 6 : 15 diagonal bottom left to top right magic constant for 7x7 is 175 30 39 48 1 10 19 28 38 47 7 9 18 27 29 46 6 8 17 26 35 37 5 14 16 25 34 36 45 13 15 24 33 42 44 4 21 23 32 41 43 3 12 22 31 40 49 2 11 20  ## bc Works with: GNU bc <lang bc>define magic_constant(n) {  return(((n * n + 1) / 2) * n)  } define print_magic_square(n) {  auto i, x, col, row, len, old_scale   old_scale = scale scale = 0 len = length(n * n)   print "Magic constant for n=", n, ": ", magic_constant(n), "\n" for (row = 1; row <= n; row++) { for (col = 1; col <= n; col++) { x = n * ((row + col - 1 + (n / 2)) % n) + \ ((row + 2 * col - 2) % n) + 1 for (i = 0; i < len - length(x); i++) { print " " } print x if (col != n) print " " } print "\n" }   scale = old_scale  } temp = print_magic_square(5)</lang> Output: Magic constant for n=5: 65 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 ## C Generates an associative magic square. If the size is larger than 3, the square is also panmagic. <lang c>#include <stdio.h> 1. include <stdlib.h> int f(int n, int x, int y) { return (x + y*2 + 1)%n; } int main(int argc, char **argv) { int i, j, n = atoi(argv[1]); for (i = 0; i < n; i++) { for (j = 0; j < n; j++) printf("% 4d", f(n, n - j - 1, i)*n + f(n, j, i) + 1); putchar('\n'); } return 0; }</lang> Output: % ./a.out 5 2 23 19 15 6 14 10 1 22 18 21 17 13 9 5 8 4 25 16 12 20 11 7 3 24  ## C++ <lang cpp> 1. include <iostream> 2. include <sstream> 3. include <iomanip> using namespace std; class magicSqr { public:  magicSqr() { sqr = 0; } ~magicSqr() { if( sqr ) delete [] sqr; }   void create( int d ) { if( sqr ) delete [] sqr; if( !( d & 1 ) ) d++; sz = d; sqr = new int[sz * sz]; memset( sqr, 0, sz * sz * sizeof( int ) ); fillSqr(); }   void display() { cout << "Odd Magic Square: " << sz << " x " << sz << "\n"; cout << "It's Magic Sum is: " << magicNumber() << "\n\n"; ostringstream cvr; cvr << sz * sz; int l = cvr.str().size();  for( int y = 0; y < sz; y++ ) { int yy = y * sz; for( int x = 0; x < sz; x++ ) cout << setw( l + 2 ) << sqr[yy + x]; cout << "\n"; }  cout << "\n\n"; }  private:  void fillSqr() {  int sx = sz / 2, sy = 0, c = 0; while( c < sz * sz ) { if( !sqr[sx + sy * sz] ) { sqr[sx + sy * sz]= c + 1; inc( sx ); dec( sy ); c++; } else { dec( sx ); inc( sy ); inc( sy ); } }  }   int magicNumber() { return ( ( ( sz * sz + 1 ) / 2 ) * sz ); }   void inc( int& a ) { if( ++a == sz ) a = 0; }   void dec( int& a ) { if( --a < 0 ) a = sz - 1; }   bool checkPos( int x, int y ) { return( isInside( x ) && isInside( y ) && !sqr[sz * y + x] ); }   bool isInside( int s ) { return ( s < sz && s > -1 ); }   int* sqr; int sz;  }; int main( int argc, char* argv[] ) {  magicSqr s; s.create( 5 ); s.display(); return system( "pause" );  } </lang> Output: Odd Magic Square: 5 x 5 It's Magic Sum is: 65 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 Odd Magic Square: 7 x 7 It's Magic Sum is: 175 30 39 48 1 10 19 28 38 47 7 9 18 27 29 46 6 8 17 26 35 37 5 14 16 25 34 36 45 13 15 24 33 42 44 4 21 23 32 41 43 3 12 22 31 40 49 2 11 20  ## Common Lisp <lang lisp>(defun magic-square (n)  (loop for i from 1 to n collect (loop for j from 1 to n collect (+ (* n (mod (+ i j (floor n 2) -1) n)) (mod (+ i (* 2 j) -2) n) 1))))  (defun magic-constant (n)  (* n (/ (1+ (* n n)) 2)))  (defun output (n)  (format T "Magic constant for n=~a: ~a~%" n (magic-constant n)) (let* ((size (length (write-to-string (* n n)))) (format-str (format NIL "~~{~~{~~~ad~~^ ~~}~~%~~}~~%" size))) (format T format-str (magic-square n))))</lang>  Output: > (output 5) Magic constant for n=5: 65 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 ## D Translation of: Python <lang d>void main(in string[] args) {  import std.stdio, std.conv, std.range, std.algorithm,std.exception;   immutable n = args.length == 2 ? args[1].to!uint : 5; enforce(n > 0 && n % 2 == 1, "Only odd n > 1"); immutable len = text(n ^^ 2).length.text;   foreach (immutable r; 1 .. n + 1) writefln("%-(%" ~ len ~ "d %)", iota(1, n + 1) .map!(c => n * ((r + c - 1 + n / 2) % n) + ((r + 2 * c - 2) % n)));   writeln("\nMagic constant: ", (n * n + 1) * n / 2);  }</lang> Output: 16 23 0 7 14 22 4 6 13 15 3 5 12 19 21 9 11 18 20 2 10 17 24 1 8 Magic constant: 65 ### Alternative Version Translation of: C <lang d>import std.stdio, std.conv, std.string, std.range, std.algorithm; uint[][] magicSquare(immutable uint n) pure nothrow @safe in {  assert(n > 0 && n % 2 == 1);  } out(mat) {  // mat is square of the right size. assert(mat.length == n); assert(mat.all!(row => row.length == n));   immutable magic = mat[0].sum;   // The sum of all rows is the same magic number. assert(mat.all!(row => row.sum == magic));   // The sum of all columns is the same magic number. //assert(mat.transposed.all!(col => col.sum == magic)); assert(mat.dup.transposed.all!(col => col.sum == magic));   // The sum of the main diagonals is the same magic number. assert(mat.enumerate.map!(ir => ir[1][ir[0]]).sum == magic); //assert(mat.enumerate.map!({i, r} => r[i]).sum == magic); assert(mat.enumerate.map!(ir => ir[1][ir[0]]).sum == magic);  } body {  enum M = (in uint x) pure nothrow @safe @nogc => (x + n - 1) % n; auto m = new uint[][](n, n);   uint i = 0; uint j = n / 2; foreach (immutable uint k; 1 .. n ^^ 2 + 1) { m[i][j] = k; if (m[M(i)][M(j)]) { i = (i + 1) % n; } else { i = M(i); j = M(j); } }   return m;  } void showSquare(in uint[][] m) in {  assert(m.all!(row => row.length == m[0].length));  } body {  immutable maxLen = text(m.length ^^ 2).length.text; writefln("%(%(%" ~ maxLen ~ "d %)\n%)", m); writeln("\nMagic constant: ", m[0].sum);  } int main(in string[] args) {  if (args.length == 1) { 5.magicSquare.showSquare; return 0; } else if (args.length == 2) { immutable n = args[1].to!uint; if (n > 0 && n % 2 == 1) { n.magicSquare.showSquare; return 0; } }   stderr.writefln("Requires n odd and larger than 0."); return 1;  }</lang> 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 Magic constant: 65 ## Elixir Translation of: Ruby <lang elixir>defmodule RC do  require Integer def odd_magic_square(n) when Integer.is_odd(n) do for i <- 0..n-1 do for j <- 0..n-1 do n * rem(i+j+1+div(n,2),n) + rem(i+2*j+2*n-5,n) + 1 end end end  end Enum.each([3,5,9], fn n ->  IO.puts "\nSize #{n}, magic sum #{div(n*n+1,2)*n}" Enum.each(RC.odd_magic_square(n), fn x -> IO.inspect x end)  end)</lang> Output: Size 3, magic sum 15 [8, 1, 6] [3, 5, 7] [4, 9, 2] Size 5, magic sum 65 [16, 23, 5, 7, 14] [22, 4, 6, 13, 20] [3, 10, 12, 19, 21] [9, 11, 18, 25, 2] [15, 17, 24, 1, 8] Size 9, magic sum 369 [50, 61, 72, 74, 4, 15, 26, 28, 39] [60, 71, 73, 3, 14, 25, 36, 38, 49] [70, 81, 2, 13, 24, 35, 37, 48, 59] [80, 1, 12, 23, 34, 45, 47, 58, 69] [9, 11, 22, 33, 44, 46, 57, 68, 79] [10, 21, 32, 43, 54, 56, 67, 78, 8] [20, 31, 42, 53, 55, 66, 77, 7, 18] [30, 41, 52, 63, 65, 76, 6, 17, 19] [40, 51, 62, 64, 75, 5, 16, 27, 29]  ## Fortran Works with: Fortran version 95 and later <lang fortran>program Magic_Square  implicit none   integer, parameter :: order = 15 integer :: i, j write(*, "(a, i0)") "Magic Square Order: ", order write(*, "(a)") "----------------------" do i = 1, order do j = 1, order write(*, "(i4)", advance = "no") f1(order, i, j) end do write(*,*) end do write(*, "(a, i0)") "Magic number = ", f2(order)  contains integer function f1(n, x, y)  integer, intent(in) :: n, x, y   f1 = n * mod(x + y - 1 + n/2, n) + mod(x + 2*y - 2, n) + 1  end function integer function f2(n)  integer, intent(in) :: n   f2 = n * (1 + n * n) / 2  end function end program</lang> Output: Magic Square Order: 15 ---------------------- 122 139 156 173 190 207 224 1 18 35 52 69 86 103 120 138 155 172 189 206 223 15 17 34 51 68 85 102 119 121 154 171 188 205 222 14 16 33 50 67 84 101 118 135 137 170 187 204 221 13 30 32 49 66 83 100 117 134 136 153 186 203 220 12 29 31 48 65 82 99 116 133 150 152 169 202 219 11 28 45 47 64 81 98 115 132 149 151 168 185 218 10 27 44 46 63 80 97 114 131 148 165 167 184 201 9 26 43 60 62 79 96 113 130 147 164 166 183 200 217 25 42 59 61 78 95 112 129 146 163 180 182 199 216 8 41 58 75 77 94 111 128 145 162 179 181 198 215 7 24 57 74 76 93 110 127 144 161 178 195 197 214 6 23 40 73 90 92 109 126 143 160 177 194 196 213 5 22 39 56 89 91 108 125 142 159 176 193 210 212 4 21 38 55 72 105 107 124 141 158 175 192 209 211 3 20 37 54 71 88 106 123 140 157 174 191 208 225 2 19 36 53 70 87 104 Magic number = 1695 ## FreeBASIC <lang FreeBASIC>' version 23-06-2015 ' compile with: fbc -s console Sub magicsq(size As Integer, filename As String ="")  If (size And 1) = 0 Or size < 3 Then Print : Beep ' alert Print "error: size is not odd or size is smaller then 3" Sleep 3000,1 'wait 3 seconds, ignore keypress Exit Sub End If   ' filename <> "" then save magic square in a file ' filename can contain directory name ' if filename exist it will be overwriten, no error checking   Dim As Integer sq(size,size) ' array to hold square ' start in the middle of the first row Dim As Integer nr = 1, x = size - (size \ 2), y = 1 Dim As Integer max = size * size ' create format string for using Dim As String frmt = String(Len(Str(max)) +1, "#")   ' main loop for creating magic square Do If sq(x, y) = 0 Then sq(x, y) = nr If nr Mod size = 0 Then y += 1 Else x += 1 y -= 1 End If nr += 1 End If If x > size Then x = 1 Do While sq(x,y) <> 0 x += 1 Loop End If If y < 1 Then y = size Do While sq(x,y) <> 0 y -= 1 Loop EndIf Loop Until nr > max   ' printing square's bigger than 19 result in a wrapping of the line Print "Odd magic square size:"; size; " *"; size Print "The magic sum ="; ((max +1) \ 2) * size Print   For y = 1 To size For x = 1 To size Print Using frmt; sq(x,y); Next Print Next print   ' output magic square to a file with the name provided If filename <> "" Then nr = FreeFile Open filename For Output As #nr Print #nr, "Odd magic square size:"; size; " *"; size Print #nr, "The magic sum ="; ((max +1) \ 2) * size Print #nr,   For y = 1 To size For x = 1 To size Print #nr, Using frmt; sq(x,y); Next Print #nr, Next End If  End Sub ' ------=< MAIN >=------ magicsq(5) magicsq(11) ' the next line will also print the square to a file called: magic_square_19.txt magicsq(19, "magic_square_19.txt") ' empty keyboard buffer While Inkey <> "" : Var _key_ = Inkey : Wend Print : Print "hit any key to end program" Sleep End</lang> Output: Odd magic square size: 5 * 5 Odd magic square size: 11 * 11 The magic sum = 65 The magic sum = 671 17 24 1 8 15 68 81 94 107 120 1 14 27 40 53 66 23 5 7 14 16 80 93 106 119 11 13 26 39 52 65 67 4 6 13 20 22 92 105 118 10 12 25 38 51 64 77 79 10 12 19 21 3 104 117 9 22 24 37 50 63 76 78 91 11 18 25 2 9 116 8 21 23 36 49 62 75 88 90 103 7 20 33 35 48 61 74 87 89 102 115 19 32 34 47 60 73 86 99 101 114 6 31 44 46 59 72 85 98 100 113 5 18 43 45 58 71 84 97 110 112 4 17 30 55 57 70 83 96 109 111 3 16 29 42 Only the first 2 square shown. 56 69 82 95 108 121 2 15 28 41 54 ## Go Translation of: C <lang go>package main import (  "fmt" "log"  ) func ms(n int) (int, []int) {  M := func(x int) int { return (x + n - 1) % n } if n <= 0 || n&1 == 0 { n = 5 log.Println("forcing size", n) } m := make([]int, n*n) i, j := 0, n/2 for k := 1; k <= n*n; k++ { m[i*n+j] = k if m[M(i)*n+M(j)] != 0 { i = (i + 1) % n } else { i, j = M(i), M(j) } } return n, m  } func main() {  n, m := ms(5) i := 2 for j := 1; j <= n*n; j *= 10 { i++ } f := fmt.Sprintf("%%%dd", i) for i := 0; i < n; i++ { for j := 0; j < n; j++ { fmt.Printf(f, m[i*n+j]) } fmt.Println() }  }</lang> 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 ## Haskell Translation of: cpp <lang haskell> -- as a translation from imperative code, this is probably not a "good" implementation import Data.List type Var = (Int, Int, Int, Int) -- sx sy sz c magicSum :: Int -> Int magicSum x = ((x * x + 1) div 2) * x wrapInc :: Int -> Int -> Int wrapInc max x  | x + 1 == max = 0 | otherwise = x + 1  wrapDec :: Int -> Int -> Int wrapDec max x  | x == 0 = max - 1 | otherwise = x - 1  isZero :: Int -> Int -> Int -> Bool isZero m x y = m !! x !! y == 0 setAt :: (Int,Int) -> Int -> Int -> Int setAt (x, y) val table  | (upper, current : lower) <- splitAt x table, (left, this : right) <- splitAt y current = upper ++ (left ++ val : right) : lower | otherwise = error "Outside"  create :: Int -> Int create x = replicate x$ replicate x 0

cells :: Int -> Int cells m = x*x where x = length m

fill :: Var -> Int -> Int fill (sx, sy, sz, c) m

  | c < cells m =
if isZero m sx sy
then fill ((wrapInc sz sx), (wrapDec sz sy), sz, c + 1) (setAt (sx, sy) (c + 1) m)
else fill ((wrapDec sz sx), (wrapInc sz(wrapInc sz sy)), sz, c) m
| otherwise = m


magicNumber :: Int -> Int magicNumber d = transpose $fill (d div 2, 0, d, 0) (create d) display :: Int -> String display (x:xs)  | null xs = vdisplay x | otherwise = vdisplay x ++ ('\n' : display xs)  vdisplay :: [Int] -> String vdisplay (x:xs)  | null xs = show x | otherwise = show x ++ " " ++ vdisplay xs  magicSquare x = do  putStr "Magic Square of " putStr$ show x
putStr " = "
putStrLn $show$ magicSum x
putStrLn $display$ magicNumber x


</lang>

## Icon and Unicon

This is a Unicon-specific solution because of the use of the [: ... :] construct. <lang unicon>procedure main(A)

   n := integer(!A) | 3
write("Magic number: ",n*(n*n+1)/2)
sq := buildSquare(n)
showSquare(sq)


end

procedure buildSquare(n)

   sq := [: |list(n)\n :]
r := 0
c := n/2
every i := !(n*n) do {
/sq[r+1,c+1] := i
nr := (n+r-1)%n
nc := (c+1)%n
if /sq[nr+1,nc+1] then (r := nr,c := nc) else r := (r+1)%n
}
return sq


end

procedure showSquare(sq)

   n := *sq
s := *(n*n)+2
every r := !sq do every writes(right(!r,s)|"\n")


end</lang>

Output:
->ms 5
Magic number: 65
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
->


## J

<lang J>ms=: i:@<.@-: |."0 1&|:^:2 >:@i.@,~</lang>

In other words, generate a square of counting integers, like this: <lang J> >:@i.@,~ 3 1 2 3 4 5 6 7 8 9</lang>

Then generate a list of integers centering on 0 up to half of that value, like this: <lang J> i:@<.@-: 3 _1 0 1</lang>

Finally, rotate each corresponding row and column of the table by the corresponding value in the list. We can use the same instructions to rotate both rows and columns if we transpose the matrix before rotating (and perform this transpose+rotate twice).

Example use:

<lang J> ms 5

9 15 16 22  3


20 21 2 8 14

1  7 13 19 25


12 18 24 5 6 23 4 10 11 17

  ~.+/ms 5


65

  ~.+/ms 101


515201</lang>

## Java

<lang java>public class MagicSquare {

   public static void main(String[] args) {
int n = 5;
for (int[] row : magicSquareOdd(n)) {
for (int x : row)
System.out.format("%2s ", x);
System.out.println();
}
System.out.printf("\nMagic constant: %d ", (n * n + 1) * n / 2);
}

   public static int[][] magicSquareOdd(final int base) {
if (base % 2 == 0 || base < 3)
throw new IllegalArgumentException("base must be odd and > 2");

       int[][] grid = new int[base][base];
int r = 0, number = 0;
int size = base * base;

       int c = base / 2;
while (number++ < size) {
grid[r][c] = number;
if (r == 0) {
if (c == base - 1) {
r++;
} else {
r = base - 1;
c++;
}
} else {
if (c == base - 1) {
r--;
c = 0;
} else {
if (grid[r - 1][c + 1] == 0) {
r--;
c++;
} else {
r++;
}
}
}
}
return grid;
}


}</lang>

Output:
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

Magic constant: 65 

## jq

Adapted from #AWK <lang jq>def odd_magic_square:

 if type != "number" or . % 2 == 0 or . <= 0
then error("odd_magic_square requires an odd positive integer")
else
. as $n | reduce range(1; 1 + ($n*$n)) as$i
( [0, (($n-1)/2), []]; .[0] as$x | .[1] as $y | .[2]  | setpath([$x, $y];$i )

         | if getpath([(($x+$n-1) % $n), (($y+$n+1) %$n)])
then [(($x+$n+1) % $n),$y, .]
else [ (($x+$n-1) % $n), (($y+$n+1) %$n), .]
end )  | .[2]
end ;</lang>


 def pp: if length == 0 then empty
else "\(.[0])", (.[1:] | pp )
end;
"The magic sum for a square of size \(.) is \( (.*. + 1)*./2 ):",
(odd_magic_square | pp)


Output:

<lang sh>jq -n -r -M -c -f odd_magic_square.jq The magic sum for a square of size 3 is 15: [8,1,6] [3,5,7] [4,9,2] The magic sum for a square of size 5 is 65: [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] The magic sum for a square of size 9 is 369: [47,58,69,80,1,12,23,34,45] [57,68,79,9,11,22,33,44,46] [67,78,8,10,21,32,43,54,56] [77,7,18,20,31,42,53,55,66] [6,17,19,30,41,52,63,65,76] [16,27,29,40,51,62,64,75,5] [26,28,39,50,61,72,74,4,15] [36,38,49,60,71,73,3,14,25] [37,48,59,70,81,2,13,24,35]</lang> ## Liberty BASIC <lang lb> Dim m(1,1) Call magicSquare 5 Call magicSquare 17 End Sub magicSquare n  ReDim m(n,n) inc = 1 count = 1 row = 1 col=(n+1)/2 While count <= n*n m(row,col) = count count = count + 1 If inc < n Then inc = inc + 1 row = row - 1 col = col + 1 If row <> 0 Then If col > n Then col = 1 Else row = n End If Else inc = 1 row = row + 1 End If Wend Call printSquare n  End Sub Sub printSquare n  'Arbitrary limit to fit width of A4 paper If n < 23 Then Print n;" x ";n;" Magic Square --- "; Print "Magic constant is ";Int((n*n+1)/2*n) For row = 1 To n For col = 1 To n Print Using("####",m(row,col)); Next col Print Print Next row Else Notice "Magic Square will not fit on one sheet of paper." End If  End Sub </lang> Output: 5 x 5 Magic Square --- Magic constant is 65 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 17 x 17 Magic Square --- Magic constant is 2465 155 174 193 212 231 250 269 288 1 20 39 58 77 96 115 134 153 173 192 211 230 249 268 287 17 19 38 57 76 95 114 133 152 154 191 210 229 248 267 286 16 18 37 56 75 94 113 132 151 170 172 209 228 247 266 285 15 34 36 55 74 93 112 131 150 169 171 190 227 246 265 284 14 33 35 54 73 92 111 130 149 168 187 189 208 245 264 283 13 32 51 53 72 91 110 129 148 167 186 188 207 226 263 282 12 31 50 52 71 90 109 128 147 166 185 204 206 225 244 281 11 30 49 68 70 89 108 127 146 165 184 203 205 224 243 262 10 29 48 67 69 88 107 126 145 164 183 202 221 223 242 261 280 28 47 66 85 87 106 125 144 163 182 201 220 222 241 260 279 9 46 65 84 86 105 124 143 162 181 200 219 238 240 259 278 8 27 64 83 102 104 123 142 161 180 199 218 237 239 258 277 7 26 45 82 101 103 122 141 160 179 198 217 236 255 257 276 6 25 44 63 100 119 121 140 159 178 197 216 235 254 256 275 5 24 43 62 81 118 120 139 158 177 196 215 234 253 272 274 4 23 42 61 80 99 136 138 157 176 195 214 233 252 271 273 3 22 41 60 79 98 117 137 156 175 194 213 232 251 270 289 2 21 40 59 78 97 116 135  ## Mathematica Rotate rows and columns of the initial matrix with rows filled in order 1 2 3 .... N^2 <lang Mathematica> rp[v_, pos_] := RotateRight[v, (Length[v] + 1)/2 - pos]; rho[m_] := MapIndexed[rp, m]; magic[n_] :=  rho[Transpose[rho[Table[i*n + j, {i, 0, n - 1}, {j, 1, n}]]]];  square = magic[11] // Grid Print["Magic number is ", Total[square1, 1]] </lang> Output: (alignment lost in translation to text) {68, 80, 92, 104, 116, 7, 19, 31, 43, 55, 56}, {81, 93, 105, 117, 8, 20, 32, 44, 45, 57, 69}, {94, 106, 118, 9, 21, 33, 34, 46, 58, 70, 82}, {107, 119, 10, 22, 23, 35, 47, 59, 71, 83, 95}, {120, 11, 12, 24, 36, 48, 60, 72, 84, 96, 108}, {1, 13, 25, 37, 49, 61, 73, 85, 97, 109, 121}, {14, 26, 38, 50, 62, 74, 86, 98, 110, 111, 2}, {27, 39, 51, 63, 75, 87, 99, 100, 112, 3, 15}, {40, 52, 64, 76, 88, 89, 101, 113, 4, 16, 28}, {53, 65, 77, 78, 90, 102, 114, 5, 17, 29, 41}, {66, 67, 79, 91, 103, 115, 6, 18, 30, 42, 54}  Magic number is 671 Output from code that checks the results Rows {671,671,671,671,671,671,671,671,671,671,671} Columns {671,671,671,671,671,671,671,671,671,671,671} Diagonals 671 671 ## Maxima <lang Maxima>wrap1(i):= if i>%n% then 1 else if i<1 then %n% else i; wrap(P):=maplist('wrap1, P); uprigth(P):= wrap(P + [-1, 1]); down(P):= wrap(P + [1, 0]); magic(n):=block([%n%: n,  M: zeromatrix (n, n), P: [1, (n + 1)/2], m: 1, Pc], do ( M[P[1],P[2]]: m, m: m + 1, if m>n^2 then return(M), Pc: uprigth(P), if M[Pc[1],Pc[2]]=0 then P: Pc else while(M[P[1],P[2]]#0) do P: down(P)));</lang>  Usage: <lang output>(%i6) magic(3);  [ 8 1 6 ] [ ]  (%o6) [ 3 5 7 ]  [ ] [ 4 9 2 ]  (%i7) magic(5);  [ 17 24 1 8 15 ] [ ] [ 23 5 7 14 16 ] [ ]  (%o7) [ 4 6 13 20 22 ]  [ ] [ 10 12 19 21 3 ] [ ] [ 11 18 25 2 9 ]  (%i8) magic(7);  [ 30 39 48 1 10 19 28 ] [ ] [ 38 47 7 9 18 27 29 ] [ ] [ 46 6 8 17 26 35 37 ] [ ]  (%o8) [ 5 14 16 25 34 36 45 ]  [ ] [ 13 15 24 33 42 44 4 ] [ ] [ 21 23 32 41 43 3 12 ] [ ] [ 22 31 40 49 2 11 20 ]  /* magic number for n=7 */ (%i9) lsum(q, q, first(magic(7))); (%o9) 175</lang> ## Nim Translation of: Python <lang nim>import strutils proc ^*(base: int, exp: int): int =  var (base, exp) = (base, exp) result = 1   while exp != 0: if (exp and 1) != 0: result *= base exp = exp shr 1 base *= base  proc magic(n) =  for row in 1 .. n: for col in 1 .. n: let cell = (n * ((row + col - 1 + n div 2) mod n) + ((row + 2 * col - 2) mod n) + 1) stdout.write align(cell, len($(n^2)))," " echo "" echo "\nAll sum to magic number ", ((n * n + 1) * n div 2)  for n in [5, 3, 7]:  echo "\nOrder ",n,"\n=======" magic(n)</lang>  Output: Order 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 All sum to magic number 65 Order 3 ======= 8 1 6 3 5 7 4 9 2 All sum to magic number 15 Order 7 ======= 30 39 48 1 10 19 28 38 47 7 9 18 27 29 46 6 8 17 26 35 37 5 14 16 25 34 36 45 13 15 24 33 42 44 4 21 23 32 41 43 3 12 22 31 40 49 2 11 20 All sum to magic number 175 ## Oforth <lang Oforth>func: magicSquare(n) { | i j wd |  n sq log asInteger 1 + ->wd n loop: i [ n loop: j [ i j + 1 - n 2 / + n mod n * i j + j + 2 - n mod 1 + + System.Out swap <<w(wd) " " << drop ] printcr ] System.Out "Magic constant is : " << n sq 1 + 2 / n * << cr  }</lang> Output: magicSquare(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 Magic constant is : 65  ## Perl 6 <lang perl6>sub MAIN (Int$n = 5) {

   note "Sorry, must be a positive odd integer." and exit if $n %% 2 or$n < 0;

   my $x =$n/2;
my $y = 0; my$i = 1;
my @sq;

   @sq[($i %$n ?? $y-- !!$y++) % $n][($i % $n ??$x++ !! $x) %$n] = $i++ for ^($n * $n);   my$f = "%{$i.chars}d"; say .fmt($f, ' ') for @sq;

   say "\nThe magic number is ", [+] @sq[0].list;


}</lang>

Output:

Default, No parameter:

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

The magic number is 65

With a parameter of 19

192 213 234 255 276 297 318 339 360   1  22  43  64  85 106 127 148 169 190
212 233 254 275 296 317 338 359  19  21  42  63  84 105 126 147 168 189 191
232 253 274 295 316 337 358  18  20  41  62  83 104 125 146 167 188 209 211
252 273 294 315 336 357  17  38  40  61  82 103 124 145 166 187 208 210 231
272 293 314 335 356  16  37  39  60  81 102 123 144 165 186 207 228 230 251
292 313 334 355  15  36  57  59  80 101 122 143 164 185 206 227 229 250 271
312 333 354  14  35  56  58  79 100 121 142 163 184 205 226 247 249 270 291
332 353  13  34  55  76  78  99 120 141 162 183 204 225 246 248 269 290 311
352  12  33  54  75  77  98 119 140 161 182 203 224 245 266 268 289 310 331
11  32  53  74  95  97 118 139 160 181 202 223 244 265 267 288 309 330 351
31  52  73  94  96 117 138 159 180 201 222 243 264 285 287 308 329 350  10
51  72  93 114 116 137 158 179 200 221 242 263 284 286 307 328 349   9  30
71  92 113 115 136 157 178 199 220 241 262 283 304 306 327 348   8  29  50
91 112 133 135 156 177 198 219 240 261 282 303 305 326 347   7  28  49  70
111 132 134 155 176 197 218 239 260 281 302 323 325 346   6  27  48  69  90
131 152 154 175 196 217 238 259 280 301 322 324 345   5  26  47  68  89 110
151 153 174 195 216 237 258 279 300 321 342 344   4  25  46  67  88 109 130
171 173 194 215 236 257 278 299 320 341 343   3  24  45  66  87 108 129 150
172 193 214 235 256 277 298 319 340 361   2  23  44  65  86 107 128 149 170

The magic number is 3439

## PL/I

<lang PL/I>magic: procedure options (main); /* 18 April 2014 */

  declare n fixed binary;

  put skip list ('What is the order of the magic square?');
get list (n);
if n < 3 | iand(n, 1) = 0 then
do; put skip list ('The value is out of range'); stop; end;
put skip list ('The order is ' || trim(n));

  begin;
declare m(n, n) fixed, (i, j, k) fixed binary;

     on subrg snap put data (i, j, k);
m = 0;
i = 1; j = (n+1)/2;

     do k = 1 to n*n;
if m(i,j) = 0 then
m(i,j) = k;
else
do;
i = i + 2; j = j + 1;
if i > n then i = mod(i,n);
if j > n then j = 1;
m(i,j) = k;
end;
i = i - 1; j = j - 1;
if i < 1 then i = n;
if j < 1 then j = n;
end;

     do i = 1 to n;
put skip edit (m(i, *)) (f(4));
end;

     put skip list ('The magic number is' || sum(m(1,*)));
end;


end magic;</lang>

Output:
What is the order of the magic square?

The order is 5
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
The magic number is                65
What is the order of the magic square?

The order is 7
28  19  10   1  48  39  30
29  27  18   9   7  47  38
37  35  26  17   8   6  46
45  36  34  25  16  14   5
4  44  42  33  24  15  13
12   3  43  41  32  23  21
20  11   2  49  40  31  22
The magic number is               175

## Python

<lang python>>>> def magic(n):

   for row in range(1, n + 1):
print(' '.join('%*i' % (len(str(n**2)), cell) for cell in
(n * ((row + col - 1 + n // 2) % n) +
((row + 2 * col - 2) % n) + 1
for col in range(1, n + 1))))
print('\nAll sum to magic number %i' % ((n * n + 1) * n // 2))


>>> for n in (5, 3, 7): print('\nOrder %i\n=======' % n) magic(n)

Order 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

All sum to magic number 65

Order 3

### =

8 1 6 3 5 7 4 9 2

All sum to magic number 15

Order 7

### =

30 39 48 1 10 19 28 38 47 7 9 18 27 29 46 6 8 17 26 35 37

5 14 16 25 34 36 45


13 15 24 33 42 44 4 21 23 32 41 43 3 12 22 31 40 49 2 11 20

All sum to magic number 175 >>> </lang>

## Racket

<lang racket>#lang racket

http://en.wikipedia.org/wiki/Magic_square#Method_for_constructing_a_magic_square_of_odd_order

(define (squares n) n)

(define (last-no n) (sqr n))

(define (middle-no n) (/ (add1 (sqr n)) 2))

(define (M n) (* n (middle-no n)))

(define ((Ith-row-Jth-col n) I J)

 (+ (* (modulo (+ I J -1 (exact-floor (/ n 2))) n) n)
(modulo (+ I (* 2 J) -2) n)
1))


(define (magic-square n)

 (define IrJc (Ith-row-Jth-col n))
(for/list ((I (in-range 1 (add1 n)))) (for/list ((J (in-range 1 (add1 n)))) (IrJc I J))))


(define (fmt-list-of-lists l-o-l width)

 (string-join
(for/list ((row l-o-l))
(string-join (map (λ (x) (~a #:align 'right #:width width x)) row) "  "))
"\n"))


(define (show-magic-square n)

 (format "MAGIC SQUARE ORDER:~a~%~a~%MAGIC NUMBER:~a~%"
n (fmt-list-of-lists (magic-square n) (+ (order-of-magnitude (last-no n)) 1)) (M n)))


(displayln (show-magic-square 3)) (displayln (show-magic-square 5)) (displayln (show-magic-square 9))</lang>

Output:
MAGIC SQUARE ORDER:3
8  1  6
3  5  7
4  9  2
Magic Number:15

MAGIC SQUARE ORDER: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
Magic Number:65

MAGIC SQUARE ORDER:9
47  58  69  80   1  12  23  34  45
57  68  79   9  11  22  33  44  46
67  78   8  10  21  32  43  54  56
77   7  18  20  31  42  53  55  66
6  17  19  30  41  52  63  65  76
16  27  29  40  51  62  64  75   5
26  28  39  50  61  72  74   4  15
36  38  49  60  71  73   3  14  25
37  48  59  70  81   2  13  24  35
Magic Number:369

## REXX

<lang rexx>/*REXX program generates and displays true magic squares (for odd N). */ parse arg N .; if N== then N=5 /*matrix size ¬given? Use default*/ w=length(N*N); r=2; c=(n+1)%2-1 /*define initial row and column. */ @.=. /* [↓] uses the Siamese method.*/

   do j=1  for n*n;   br=r==N & c==N; r=r-1;  c=c+1   /*BR=bottom right*/
if r<1 & c>N then do;  r=r+2;  c=c-1;    end       /*R under, C over*/
if r<1       then r=n; if r>n  then r=1; if c>n then c=1  /*overflow*/
if @.r.c\==. then do; r=r+2; c=c-1; if br then do; r=N; c=c+1; end;end
@.r.c=j                            /*assign #───►square matrix cell.*/
end   /*j*/                        /* [↑]  can handle even N matrix.*/
/* [↓]  displays (aligned) matrix*/
do   r=1  for N;  _=            /*display 1 matrix row at a time.*/
do c=1  for N;  _=_ right(@.r.c, w);  end  /*c*/    /*build row*/
say substr(_,2)                 /*row has an extra leading blank.*/
end   /*c*/                     /* [↑]   also right-justified #s.*/


say /*might as well show a blank line*/ if N//2 then say 'The magic number (or magic constant is): ' N*(n*n+1)%2

                                      /*stick a fork in it, we're done.*/</lang>

Output:

using the default input of   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

The magic number  (or magic constant is):  65

Output:

using the default input of   3

8 1 6
3 5 7
4 9 2

The magic number  (or magic constant is):  15

Output:

using the input of

19:
192 213 234 255 276 297 318 339 360   1  22  43  64  85 106 127 148 169 190
212 233 254 275 296 317 338 359  19  21  42  63  84 105 126 147 168 189 191
232 253 274 295 316 337 358  18  20  41  62  83 104 125 146 167 188 209 211
252 273 294 315 336 357  17  38  40  61  82 103 124 145 166 187 208 210 231
272 293 314 335 356  16  37  39  60  81 102 123 144 165 186 207 228 230 251
292 313 334 355  15  36  57  59  80 101 122 143 164 185 206 227 229 250 271
312 333 354  14  35  56  58  79 100 121 142 163 184 205 226 247 249 270 291
332 353  13  34  55  76  78  99 120 141 162 183 204 225 246 248 269 290 311
352  12  33  54  75  77  98 119 140 161 182 203 224 245 266 268 289 310 331
11  32  53  74  95  97 118 139 160 181 202 223 244 265 267 288 309 330 351
31  52  73  94  96 117 138 159 180 201 222 243 264 285 287 308 329 350  10
51  72  93 114 116 137 158 179 200 221 242 263 284 286 307 328 349   9  30
71  92 113 115 136 157 178 199 220 241 262 283 304 306 327 348   8  29  50
91 112 133 135 156 177 198 219 240 261 282 303 305 326 347   7  28  49  70
111 132 134 155 176 197 218 239 260 281 302 323 325 346   6  27  48  69  90
131 152 154 175 196 217 238 259 280 301 322 324 345   5  26  47  68  89 110
151 153 174 195 216 237 258 279 300 321 342 344   4  25  46  67  88 109 130
171 173 194 215 236 257 278 299 320 341 343   3  24  45  66  87 108 129 150
172 193 214 235 256 277 298 319 340 361   2  23  44  65  86 107 128 149 170

The magic number  (or magic constant is):  3439


## Ruby

<lang ruby>def odd_magic_square(n)

 raise ArgumentError "Need odd positive number" if n.even? || n <= 0
n.times.map{|i| n.times.map{|j| n*((i+j+1+n/2)%n) + ((i+2*j-5)%n) + 1} }


end

[3, 5, 9].each do |n|

 puts "\nSize #{n}, magic sum #{(n*n+1)/2*n}"
fmt = "%#{(n*n).to_s.size + 1}d" * n
odd_magic_square(n).each{|row| puts fmt % row}


end </lang>

Output:
Size 3, magic sum 15
8 1 6
3 5 7
4 9 2

Size 5, magic sum 65
16 23  5  7 14
22  4  6 13 20
3 10 12 19 21
9 11 18 25  2
15 17 24  1  8

Size 9, magic sum 369
50 61 72 74  4 15 26 28 39
60 71 73  3 14 25 36 38 49
70 81  2 13 24 35 37 48 59
80  1 12 23 34 45 47 58 69
9 11 22 33 44 46 57 68 79
10 21 32 43 54 56 67 78  8
20 31 42 53 55 66 77  7 18
30 41 52 63 65 76  6 17 19
40 51 62 64 75  5 16 27 29


## Rust

<lang rust>fn main() {

   let n = 9;
let mut square = Vec::from_fn(n, |_| Vec::from_fn(n, |_| 0u));
for (i, row) in square.iter_mut().enumerate() {
for (j, e) in row.iter_mut().enumerate() {
*e = n * (((i + 1) + (j + 1) - 1 + (n >> 1)) % n) + (((i + 1) + (2 * (j + 1)) - 2) % n) + 1;
print!("{:3} ", e);
}
println!("");
}
let sum = n * (((n * n) + 1) / 2);
println!("The sum of the square is {}.", sum);


}</lang>

Output:
 47  58  69  80   1  12  23  34  45
57  68  79   9  11  22  33  44  46
67  78   8  10  21  32  43  54  56
77   7  18  20  31  42  53  55  66
6  17  19  30  41  52  63  65  76
16  27  29  40  51  62  64  75   5
26  28  39  50  61  72  74   4  15
36  38  49  60  71  73   3  14  25
37  48  59  70  81   2  13  24  35
The sum of the square is 369.

<lang seed7>$include "seed7_05.s7i"; const func integer: succ (in integer: num, in integer: max) is  return succ(num mod max);  const func integer: pred (in integer: num, in integer: max) is  return succ((num - 2) mod max);  const proc: main is func  local var integer: size is 3; var array array integer: magic is 0 times 0 times 0; var integer: row is 1; var integer: column is 1; var integer: number is 0; begin if length(argv(PROGRAM)) >= 1 then size := integer parse (argv(PROGRAM)[1]); end if; magic := size times size times 0; column := succ(size div 2); for number range 1 to size ** 2 do magic[row][column] := number; if magic[pred(row, size)][succ(column, size)] = 0 then row := pred(row, size); column := succ(column, size); else row := succ(row, size); end if; end for; for key row range magic do for key column range magic[row] do write(magic[row][column] lpad 4); end for; writeln; end for; end func;</lang>  Output: > s7 magicSquaresOfOddOrder 7 SEED7 INTERPRETER Version 5.0.5203 Copyright (c) 1990-2014 Thomas Mertes 30 39 48 1 10 19 28 38 47 7 9 18 27 29 46 6 8 17 26 35 37 5 14 16 25 34 36 45 13 15 24 33 42 44 4 21 23 32 41 43 3 12 22 31 40 49 2 11 20  ## Tcl <lang tcl>proc magicSquare {order} {  if {!($order & 1) || $order < 0} {  error "order must be odd and positive"  } set s [lrepeat$order [lrepeat $order 0]] set x [expr {$order / 2}]
set y 0
for {set i 1} {$i <=$order**2} {incr i} {


lset s $y$x $i set x [expr {($x + 1) % $order}] set y [expr {($y - 1) % $order}] if {[lindex$s $y$x]} { set x [expr {($x - 1) %$order}] set y [expr {($y + 2) %$order}] }

   }
return $s  }</lang> Demonstrating: Works with: Tcl version 8.6 <lang tcl>package require Tcl 8.6 set square [magicSquare 5] puts [join [lmap row$square {join [lmap n $row {format "%2s"$n}]}] "\n"] puts "magic number = [tcl::mathop::+ {*}[lindex \$square 0]]"</lang>

Output:
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
magic number = 65


## zkl

Translation of: Ruby

<lang zkl>fcn rmod(n,m){ n=n%m; if (n<0) n+=m; n } // Ruby: -5%3-->1 fcn odd_magic_square(n){ //-->list of n*n numbers, row order

  if (n.isEven or n <= 0) throw(Exception.ValueError("Need odd positive number"));
[[(i,j); n; n; '{ n*((i+j+1+n/2):rmod(_,n)) + ((i+2*j-5):rmod(_,n)) + 1 }]]


}

T(3, 5, 9).pump(Void,fcn(n){

  "\nSize %d, magic sum %d".fmt(n,(n*n+1)/2*n).println();
fmt := "%%%dd".fmt((n*n).toString().len() + 1) * n;


});</lang>

Output:
Size 3, magic sum 15
8 1 6
3 5 7
4 9 2

Size 5, magic sum 65
16 23  5  7 14
22  4  6 13 20
3 10 12 19 21
9 11 18 25  2
15 17 24  1  8

Size 9, magic sum 369
50 61 72 74  4 15 26 28 39
60 71 73  3 14 25 36 38 49
70 81  2 13 24 35 37 48 59
80  1 12 23 34 45 47 58 69
9 11 22 33 44 46 57 68 79
10 21 32 43 54 56 67 78  8
20 31 42 53 55 66 77  7 18
30 41 52 63 65 76  6 17 19
40 51 62 64 75  5 16 27 29