Magic squares of odd order: Difference between revisions

 

;Task

For any odd   '''N''',   [[wp:Magic square#Method_for_constructing_a_magic_square_of_odd_order|generate a magic square]] with the integers   ''' 1''' ──► '''N''',   and show the results here.

 

; See also:

* MathWorld™ entry: [http://mathworld.wolfram.com/MagicSquare.html Magic_square]

 

=={{header|360 Assembly}}==

{{trans|C}}

MAGICS CSECT

USING MAGICS,R15 set base register

PG DC CL92' ' buffer

YREGS

{{out}}

<pre>

 

=={{header|Ada}}==

 

procedure Magic_Square is

Ada.Text_IO.New_Line;

end loop;

 

{{out}}

 

=={{header|ALGOL 68}}==

PROC magic square = ( INT order ) [,]INT:

IF NOT ODD order OR order < 1

 

# test the magic square generation #

{{out}}

<pre>

 

=={{header|ALGOL W}}==

% construct a magic square of odd order - as a procedure can't return an %

% array, the caller must supply one that is big enough %

end for_i

 

{{out}}

<pre>

</pre>

 

=={{header|AppleScript}}==

{{trans|JavaScript}}

to allow for first class functions and closures.

 

on oddMagicSquare(n)

end oddMagicSquare

 

on run

-- Orders 3, 5, 11

 

 

 

-- intercalate :: Text -> [Text] -> Text

end transpose

 

 

-- formattedTable :: [[Int]] -> String

g

end if

{{Out}}

magic(3)

| 66 || 67 || 79 || 91 || 103 || 115 || 6 || 18 || 30 || 42 || 54

|}

 

=={{header|AutoHotkey}}==

msgbox % OddMagicSquare(5)

msgbox % OddMagicSquare(7)

return str

}

{{out}}

<pre>

 

=={{header|AWK}}==

# syntax: GAWK -f MAGIC_SQUARES_OF_ODD_ORDER.AWK

BEGIN {

printf("\t: %d diagonal bottom left to top right\n",total)

}

{{out}}

<pre>

==={{header|Applesoft BASIC}}===

Even if the code works for any odd number, N=9 is the maximum for a 40 column wide screen. Line <code>130</code> is a user defined modulo function, and <code>140</code> helps calculate the addends for the number that will go in the current position.

100 :

110 REM MAGIC SQUARE OF ODD ORDER

260 NEXT I

270 PRINT "MAGIC CONSTANT: ";N * (N * N + 1) / 2

{{out}}

<pre>ENTER N: 5

20 11 7 3 24

MAGIC CONSTANT: 65</pre>

 

==={{header|IS-BASIC}}===

110 DO

120 INPUT PROMPT "The square order: ":N

180 PRINT

190 NEXT

 

=={{header|Batch File}}==

rem Magic squares of odd order

setlocal EnableDelayedExpansion

set /a w=n*(n*n+1)/2

echo The magic number is: %w%

{{out}}

<pre>The square order is: 9

=={{header|bc}}==

{{works with|GNU bc}}

return(((n * n + 1) / 2) * n)

}

}

 

 

{{Out}}

10 12 19 21 3

11 18 25 2 9</pre>

 

=={{header|Befunge}}==

{{trans|C}}

The size, ''n'', is specified by the first value on the stack.

 

{{out}}

8 4 25 16 12

20 11 7 3 24 </pre>

 

=={{header|C}}==

Generates an associative magic square. If the size is larger than 3, the square is also [http://en.wikipedia.org/wiki/Pandiagonal_magic_square panmagic].

#include <stdlib.h>

return 0;

{{out}}

<pre>$ ./magic 5

 

=={{header|C++}}==

#include <iostream>

#include <sstream>

#include <iomanip>

using namespace std;

{

public:

{

fillSqr();

}

void display()

{

cout << "Odd Magic Square: " << sz << " x " << sz << "\n";

cout << "It's Magic Sum is: " << magicNumber() << "\n\n";

int l = cvr.str().size();

for( int y = 0; y < sz; y++ )

{

for( int x = 0; x < sz; x++ )

cout << setw( l + 2 ) << sqr[yy + x];

cout << "\n";

}

cout << "\n\n";

}

private:

void fillSqr()

}

}

int magicNumber()

{ return sz * ( ( sz * sz ) + 1 ) / 2; }

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 sz;

};

{

s.display();

return 0;

}

{{out}}

<pre>

Odd Magic Square: 7 x 7

It's Magic Sum is: 175

22 31 40 49 2 11 20

</pre>

 

=={{header|Common Lisp}}==

(loop for i from 1 to n

collect

(let* ((size (length (write-to-string (* n n))))

(format-str (format NIL "~~{~~{~~~ad~~^ ~~}~~%~~}~~%" size)))

 

{{Out}}

11 18 25 2 9</pre>

 

=={{header|D}}==

{{trans|Python}}

{

import std.stdio, std.conv, std.range, std.algorithm, std.exception;

 

writeln("\nMagic constant: ", ((n * n + 1) * n) / 2);

{{out}}

<pre>17 24 1 8 15

===Alternative Version===

{{trans|C}}

 

uint[][] magicSquare(immutable uint n) pure nothrow @safe

stderr.writefln("Requires n odd and larger than 0.");

return 1;

{{out}}

<pre>15 8 1 24 17

 

Magic constant: 65</pre>

 

=={{header|EchoLisp}}==

The '''make-ms''' procedure allows to construct different magic squares for a same n, by modifying the grid filling moves. (see MathWorld reference)

(lib 'matrix)

 

(array-print ms))

{{out}}

<pre>

28 2 32 13 36 17 47

10 40 21 44 25 6 29

</pre>

 

=={{header|Elixir}}==

{{trans|Ruby}}

def odd_magic_square(n) when rem(n,2)==1 do

for i <- 0..n-1 do

IO.puts "\nSize #{n}, magic sum #{div(n*n+1,2)*n}"

RC.odd_magic_square(n) |> RC.print_square

 

{{out}}

 

=={{header|ERRE}}==

PROGRAM MAGIC_SQUARE

 

 

END PROGRAM

{{out}}

Same as FreeBasic version

=={{header|Factor}}==

This solution uses the method from the paper linked in the J entry: http://www.jsoftware.com/papers/eem/magicsq.htm

sequences sequences.extras ;

IN: rosetta-code.magic-squares-odd

"Magic number: %d\n\n" printf ;

 

{{out}}

<pre>

=={{header|Fortran}}==

{{works with|Fortran|95 and later}}

implicit none

 

f2 = n * (1 + n * n) / 2

end function

Output:

<pre>Magic Square Order: 15

Magic number = 1695</pre>

 

 

 

 

{{out}}

 

=={{header|Go}}==

{{trans|C}}

 

import (

fmt.Println()

}

{{out}}

<pre>

====Translating imperative code====

{{trans|cpp}}

import Data.List

 

putStr " = "

putStrLn $ show $ magicSum x

 

====Transpose . cycled====

Defining the magic square as two applications of ('''transpose . cycled''') to a simply ordered square.

 

import Data.List.Split (chunksOf)

import Data.Ord (comparing)

 

magicSquare :: Int -> [[Int]]

magicSquare n

| otherwise = []

 

-------------------------- TEST ---------------------------

main :: IO ()

 

------------------------- GENERIC -------------------------

let n = length rows

d = quot n 2

 

justifyRight :: Int -> a -> [a] -> [a]

 

showSquare rows =

{{Out}}

<pre> 8 1 6

Encoding the traditional [[wp:Siamese_method|'Siamese' method]]

 

import Control.Monad (forM_)

 

magic :: Int -> [[Int]]

magic = mapAsTable <*> siamMap

 

 

siamMap :: Int -> M.Map (Int, Int) Int

 

nextSiam :: Int -> M.Map (Int, Int) Int -> (Int, Int) -> (Int, Int)

nextSiam uBound sMap (x, y) =

let alt (a, b)

| otherwise = (a, b) -- Up one, right one.

 

 

mapAsTable :: Int -> M.Map (Int, Int) Int -> [[Int]]

mapAsTable nCols xyMap =

let axis = [0 .. nCols - 1]

 

checked :: [[Int]] -> (Int, Bool)

checked square =

let diagonals =

 

table :: String -> [[String]] -> [String]

table delim rows =

 

main :: IO ()

main =

forM_ [3, 5, 7] $

{{Out}}

<pre>8 1 6

 

This is a Unicon-specific solution because of the use of the <tt>[: ... :]</tt> construct.

n := integer(!A) | 3

write("Magic number: ",n*(n*n+1)/2)

s := *(n*n)+2

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

 

{{out}}

Based on http://www.jsoftware.com/papers/eem/magicsq.htm

 

 

In other words, generate a square of counting integers, like this:

1 2 3

4 5 6

 

Then generate a list of integers centering on 0 up to half of that value, like this:

 

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:

 

9 15 16 22 3

20 21 2 8 14

65

~.+/ms 101

 

 

 

=={{header|Java}}==

 

public static void main(String[] args) {

return grid;

}

 

{{out}}

( and referring to http://www.jsoftware.com/papers/eem/magicsq.htm )

 

 

// n -> [[n]]

}

).join('\n\n')

 

Output:

 

(2nd Haskell version: ''cycledRows . transpose . cycledRows'')

 

// magicSquare :: Int -> [[Int]]

.map(magicSquare)

.map(xs => unlines(xs.map(show))));

{{Out}}

<pre>[8,1,6]

Encoding the traditional [[wp:Siamese_method|'Siamese' method]]

{{Trans|Haskell}}

 

// Number of rows -> n rows of integers

n => unlines(table(" ",

map(xs => map(show, xs), oddMagicTable(n))))));

{{Out}}

<pre>8 1 6

=={{header|jq}}==

'''Adapted from [[#AWK]]'''

if type != "number" or . % 2 == 0 or . <= 0

then error("odd_magic_square requires an odd positive integer")

else [ (($x+$n-1) % $n), (($y+$n+1) % $n), .]

end ) | .[2]

'''Examples'''

def pp: if length == 0 then empty

else "\(.[0])", (.[1:] | pp )

;

 

{{out}}

The magic sum for a square of size 3 is 15:

[8,1,6]

[26,28,39,50,61,72,74,4,15]

[36,38,49,60,71,73,3,14,25]

 

=={{header|Julia}}==

 

function magicsquareodd(base::Int)

end

println()

 

{{out}}

=={{header|Kotlin}}==

{{trans|C}}

 

fun f(n: Int, x: Int, y: Int) = (x + y * 2 + 1) % n

}

println("\nThe magic constant is ${(n * n + 1) / 2 * n}")

Sample input/output:

{{out}}

 

2 75 67 59 51 43 35 27 10

72 55 47 39 31 23 15 7 80

 

 

=={{header|Lua}}==

See [[Magic_squares/Lua]].

 

Rotate rows and columns of the initial matrix with rows filled in order 1 2 3 .... N^2

Method from http://www.jsoftware.com/papers/eem/magicsq.htm

rho[m_] := MapIndexed[rp, m];

magic[n_] :=

 

square = magic[11] // Grid

{81, 93, 105, 117, 8, 20, 32, 44, 45, 57, 69},

{94, 106, 118, 9, 21, 33, 34, 46, 58, 70, 82},

{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

 

=={{header|Maxima}}==

wrap(P):=maplist('wrap1, P);

 

Pc: uprigth(P),

if M[Pc[1],Pc[2]]=0 then P: Pc

 

Usage:

[ 8 1 6 ]

[ ]

/* magic number for n=7 */

(%i9) lsum(q, q, first(magic(7)));

 

=={{header|Nim}}==

{{trans|Python}}

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)

echo ""

 

{{out}}

=======

17 24 1 8 15

 

All sum to magic number 65

 

Order 7

=={{header|Oforth}}==

 

| i j wd |

n sq log asInteger 1+ ->wd

printcr

]

 

{{out}}

{{trans|Perl}}

The index-fiddling differs from Perl since GP vectors start at 1.

my(M=matrix(n,n),j=n\2+1,i=1);

for(l=1,n^2,

M;

}

{{out}}

<pre>[30 39 48 1 10 19 28]

{{works with|Free Pascal|1.0}}

{{trans|C}}

(* Magic squares of odd order *)

CONST

END;

WRITELN('The magic number is: ',n*(n*n+1) DIV 2)

{{out}}

<pre>

shuffles columns and rows and changed col<-> row to get different looks. n! x n! * 2 different arrangements.

See last column of version before moved to the top row.

{$IFDEF FPC }{$MODE DELPHI}{$ELSE}{$APPTYPE CONSOLE}{$ENDIF}

uses

Mq := MagicSqrOdd(n,random(2)=0);

writeln(MagicSqrCheck(Mq));

{{out}}

<pre>

 

See [[Magic_squares/Perl|Magic squares/Perl]] for a general magic square generator.

 

=={{header|Phix}}==

{{out}}

<pre>

{42,29,23,17,11, 5,48}}

</pre>

 

=={{header|PicoLisp}}==

(de magic (A)

(let

(magic 5)

(prinl)

{{out}}

<pre>

 

=={{header|PL/I}}==

declare n fixed binary;

 

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

end;

{{out}}

<pre>What is the order of the magic square?

20 11 2 49 40 31 22

The magic number is 175</pre>

 

=={{header|Python}}==

===Procedural===

for row in range(1, n + 1):

print(' '.join('%*i' % (len(str(n**2)), cell) for cell in

 

All sum to magic number 175

 

===Composition of pure functions===

{{Trans|Haskell}}

{{Works with|Python|3.7}}

 

from itertools import cycle, islice, repeat

# MAIN ---

if __name__ == '__main__':

{{Out}}

<pre>Magic squares of odd order N:

 

=={{header|R}}==

See [http://rosettacode.org/wiki/Magic_squares_of_doubly_even_order#R here] for the solution for all three cases.

 

 

=={{header|Racket}}==

;; Using "helpful formulae" in:

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

(displayln (show-magic-square 3))

(displayln (show-magic-square 5))

{{out}}

<pre>MAGIC SQUARE ORDER:3

=={{header|REXX}}==

This REXX version will also generate a square of an even order, but it'll not be a ''magic square''.

parse arg N . /*obtain the optional argument from CL.*/

if N=='' | N=="," then N=5 /*Not specified? Then use the default.*/

say /* [↓] If an odd square, show magic #.*/

if N//2 then say 'The magic number (or magic constant is): ' N * (NN+1) % 2

{{out|output|text=&nbsp; when using the default input of: &nbsp; '''5'''}}

<pre>

 

=={{header|Ring}}==

n=9

see "the square order is : " + n + nl

see nl

next

Output:

<pre>

 

the magic number is : 369

</pre>

 

=={{header|Ruby}}==

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} }

odd_magic_square(n).each{|row| puts fmt % row}

end

{{out}}

<pre>

 

=={{header|Rust}}==

let n = 9;

let mut square = vec![vec![0; n]; n];

let sum = n * (((n * n) + 1) / 2);

println!("The sum of the square is {}.", sum);

 

{{out}}

 

=={{header|Scala}}==

require(n % 2 != 0, "n must be an odd number")

 

 

printMagicSquare(7)

 

{{out}}

 

=={{header|Seed7}}==

 

const func integer: succ (in integer: num, in integer: max) is

writeln;

end for;

 

{{out}}

 

=={{header|Sidef}}==

var i = 0

 

var magic_square = []

}

 

var sq = magic_square(n)

print_square(sq)

 

 

{{out}}

 

=={{header|Swift}}==

 

struct Point: CustomStringConvertible {

try MagicSquare(base: 7).createOdd()

 

Demonstrating:

{{works with|Swift 5}}

 

=={{header|Tcl}}==

if {!($order & 1) || $order < 0} {

error "order must be odd and positive"

}

return $s

Demonstrating:

{{works with|Tcl|8.6}}

 

set square [magicSquare 5]

puts [join [lmap row $square {join [lmap n $row {format "%2s" $n}]}] "\n"]

{{out}}

<pre>

</pre>

 

{{trans|C}}

{{works with|TI-83 BASIC|TI-84Plus 2.55MP}}

DelVar [A]:{N,N}→dim([A])

For(I,1,N)

End

End

{{out}}

<pre>

[72 55 47 39 31 23 15 7 80]]

</pre>

 

=={{header|VBScript}}==

{{trans|Liberty BASIC}}

Sub magic_square(n)

Dim ms()

End Sub

 

{{Out}}

23 5 7 14 16

4 6 13 20 22

10 12 19 21 3

 

{{trans|C}}

{{out}}

 

{{out}}

<pre>

</pre>

 

=={{header|zkl}}==

{{trans|Ruby}}

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"));

fmt := "%%%dd".fmt((n*n).toString().len() + 1) * n;

odd_magic_square(n).pump(Console.println,T(Void.Read,n-1),fmt.fmt);

{{out}}

8 1 6

3 5 7

20 31 42 53 55 66 77 7 18

30 41 52 63 65 76 6 17 19