Magic squares of odd order: Difference between revisions

{{trans|Python}}

L(row) 1..n

print(((1..n).map(col -> @n * ((@row + col - 1 + @n I/ 2) % @n)

L(n) (5, 3, 7)

print("\nOrder #.\n=======".format(n))

{{out}}

=={{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>

{{works with|Dyalog APL}}

{{trans|C}}

{{out}}

<pre> magic¨ 1 3 5 7

to allow for first class functions and closures.

-- oddMagicSquare :: Int -> [[Int]]

g

end if

{{Out}}

magic(3)

=={{header|Arturo}}==

ensure -> and? odd? n

n >= 0

]

print ""

{{out}}

=={{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

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

=={{header|BCPL}}==

{{trans|C}}

let cell(n, x, y) = f(n, n-x-1, y)*n + f(n, x, y) + 1

$)

{{out}}

<pre>Magic square of order 1 with constant 1:

{{trans|C}}

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

{{out}}

=={{header|BQN}}==

{{trans|C}}

{{out}}

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

return 0;

}

{{out}}

<pre>

=={{header|CLU}}==

rep = array[array[int]]

print_magic_square(n)

end

{{out}}

<pre>Magic square of order 1 with magic number 1:

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

=={{header|Cowgol}}==

{{trans|C}}

sub magic(n: uint16) is

magic(n);

n := n + 2;

{{out}}

<pre>Magic square of order 1 with constant 1:

=={{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

=={{header|Draco}}==

proc dec(word n, order) word: if n=0 then order-1 else n-1 fi corp

print_magic_square(sq5);

print_magic_square(sq7)

{{out}}

<pre>Magic square of order 1 with magic number 1:

=={{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>

=={{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

=={{header|FreeBASIC}}==

' compile with: fbc -s console

Print : Print "hit any key to end program"

Sleep

{{out}}

<pre>Odd magic square size: 5 * 5 Odd magic square size: 11 * 11

=={{header|Frink}}==

This program takes an order from command-line or requests an odd order from the user. It uses an algorithm from Dr. Crypton's column in Science Digest in the 1980s which the developer of Frink remembered and used to use by hand to create giant magic squares until his English teacher told him "don't do that in class."

until isInteger[order] and order mod 2 == 1

order = eval[input["Enter order (must be odd): ", 3]]

println[formatTable[a]]

{{out}}

<pre>

=={{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 (maximumBy, transpose)

import Data.List.Split (chunksOf)

<*> succ . maximum . fmap length . join

)

{{Out}}

<pre> 8 1 6

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

import Control.Monad (forM_)

putStrLn $ unlines (table " " (fmap show <$> test))

print $ checked test

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

Note also that an important feature of magic squares is that their diagonals sum the same way:

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

=={{header|Liberty BASIC}}==

Dim m(1,1)

End If

End Sub

{{Out}}

<pre>

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

{{out}}

(alignment lost in translation to text):

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

proc magic(n: int) =

for n in [3, 5, 7]:

echo "\nOrder ", n, "\n======="

{{out}}

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

<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>

<span style="color: #008080;">function</span> <span style="color: #000000;">magic_square</span><span style="color: #0000FF;">(</span><span style="color: #004080;">integer</span> <span style="color: #000000;">n</span><span style="color: #0000FF;">)</span>

<span style="color: #000000;">check</span><span style="color: #0000FF;">(</span><span style="color: #000000;">square</span><span style="color: #0000FF;">)</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>

{{out}}

<pre>

{{Trans|J}}

go =>

nl

end,

{{out}}

===Testing a larger instance===

N = 313,

M = magic_square(N),

check(M),

{{out}}

=={{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?

=={{header|PureBasic}}==

{{trans|Pascal}}

Define.i i,j

PrintN("The magic number is: "+Str(#N*(#N*#N+1)/2))

EndIf

{{out}}

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

'$Dynamic

DefLng A-Z

Next row

End If

{{Out}}

<pre>Order 5 Magic Square constant is 65

=={{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

next

see "the magic number is : " + n*(n*n+1) / 2 + nl

Output:

<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 j = int(n/2)

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>

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

=={{header|uBasic/4tH}}==

{{trans|FreeBASIC}}

Proc _magicsq(5)

Print

Return

{{out}}

<pre>Odd magic square size: 5 * 5

{{trans|C}}

Works with Excel VBA.

'Magic squares of odd order

Const n = 9

Debug.Print "The magic number of"; n; "x"; n; "square is:"; n * (n * n + 1) \ 2

End Sub 'magicsquare

=={{header|VBScript}}==

{{trans|Liberty BASIC}}

Sub magic_square(n)

Dim ms()

magic_square(5)

{{Out}}

{{trans|C}}

{{works with|Visual Basic|VB6 Standard}}

'Magic squares of odd order

Const n = 9

Debug.Print "The magic number is: " & n * (n * n + 1) \ 2

End Sub 'magicsquare

{{out}}

<pre>

=={{header|Visual Basic .NET}}==

{{works with|Visual Basic .NET|2011}}

'Magic squares of odd order

Const n = 9

Next i

Console.WriteLine("The magic number is: " & n * (n * n + 1) \ 2)

{{out}}

<pre>

=={{header|VTL-2}}==

{{trans|C}}

20 ?="Magic square of order ";

30 ?=N

160 ?=""

170 N=N+2

{{out}}

<pre>Magic square of order 1 with constant 1:

{{trans|Go}}

{{libheader|Wren-fmt}}

var ms = Fn.new { |n|

System.print()

}

{{out}}

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

<pre>