Magic squares of singly even order: Difference between revisions

{{trans|Python}}

 

 

F build_oms(=s)

 

print(‘Singly Even Magic Square’, end' ‘’)

 

{{out}}

 

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

MAGSQSE CSECT

USING MAGSQSE,R13 base register

XDEC DS CL12 temp for xdeco

REGEQU

{{out}}

<pre>

30 5 34 12 14 16

4 36 29 13 18 11

</pre>

 

The size, ''N'', is specified by the first value on the stack. In the example below it is set to 6, but adequate space has been left in the code to replace that with a larger value if desired.

 

\00g/10g/3*4vv>0g\-1-30g+1+10g%10g*\30g+1+10g%1+ +

:%4+*2/g01g0<vv4*`\g02\!`\0:-!-g02/2g03g04-3*2\-\3

 

{{out}}

=={{header|C}}==

Takes number of rows from command line, prints out usage on incorrect invocation.

#include<stdlib.h>

#include<ctype.h>

return 0;

}

Invocation and Output:

<pre>

 

Magic constant: 111

</pre>

 

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

#include <iostream>

#include <sstream>

return 0;

}

{{out}}

<pre>

=={{header|D}}==

{{trans|Java}}

import std.exception;

import std.stdio;

return result;

}

 

=={{header|Elixir}}==

[[wp:Conway's LUX method for magic squares]]:

@lux %{ L: [4, 1, 2, 3], U: [1, 4, 2, 3], X: [1, 4, 3, 2] }

end

 

 

{{out}}

 

=={{header|FreeBASIC}}==

' compile with: fbc -s console

' singly even magic square 6, 10, 14, 18...

Print : Print "hit any key to end program"

Sleep

{{out}}

<pre>Single even magic square size: 6*6

=={{header|Go}}==

{{trans|Java}}

 

import (

}

fmt.Printf("\nMagic constant: %d\n", (n*n+1)*n/2)

 

{{out}}

=={{header|Haskell}}==

Using [[wp:Conway's LUX method for magic squares|Conway's LUX method for magic squares]]

import Data.List (transpose, intercalate)

import Data.Maybe (fromJust, isJust)

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

print $ checked test

{{Out}}

<pre>32 29 4 1 24 21

Using the Strachey method:

 

odd =: i:@<.@-: |."0 1&|:^:2 >:@i.@,~

t =: ((*: * i.@4:) +"0 2 odd)@-:

d =: ((lm * {.@t) + -.@lm * {:@t)

m =: (a ,"1 c) , d ,"1 b

 

{{Out}}

Alternative implementation of the [[wp:Strachey_method_for_magic_squares|Strachey method]]:

 

strachey2=: (odd +/~ (0 2,:3 1) * *:)@-:

exchange=: (* -.) + (* |.)~

strachey5=: exchange (,:~1 0) */ (i.@,~@{: e. ((]*0 1+[)-:@<:)@{:)@$

 

 

{{out}}

 

=={{header|Java}}==

 

public static void main(String[] args) {

return result;

}

 

<pre>35 1 6 26 19 24

 

Magic constant: 111</pre>

 

=={{header|Julia}}==

{{trans|Lua}}

if iseven(order)

order += 1

check(msq)

end

With order 6:

35 30 31 8 3 4

=={{header|Kotlin}}==

{{trans|Java}}

 

fun magicSquareOdd(n: Int): Array<IntArray> {

}

println("\nMagic constant ${(n * n + 1) * n / 2}")

 

{{out}}

=={{header|Nim}}==

{{trans|Kotlin}}

 

type Square = seq[seq[int]]

let n = 6

echo magicSquareSinglyEven(n)

 

{{out}}

 

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

 

=={{header|Phix}}==

{{trans|FreeBASIC}}

{{out}}

<pre>

=={{header|Python}}==

{{trans|Lua}}

import math

from sys import stdout

stdout.write("Singly Even Magic Square")

display(build_sems(6))

{{out}}

<pre>Singly Even Magic Square - 6 x 6

=={{header|Ruby}}==

 

n.times.map{|i| n.times.map{|j| n*((i+j+1+n/2)%n) + ((i+2*j-5)%n) + 1} }

end

end

 

{{out}}

<pre>

===LUX method===

[[wp:Conway's LUX method for magic squares]]

attr_reader :square

LUX = { L: [[4, 1], [2, 3]], U: [[1, 4], [2, 3]], X: [[1, 4], [3, 2]] }

end

 

 

{{out}}

 

=={{header|Rust}}==

 

fn main() {

})

.collect::<Vec<Vec<_>>>()

{{out}}

<pre>

{{trans|Kotlin}}

{{libheader|Wren-fmt}}

 

var magicSquareOdd = Fn.new { |n|

System.print()

}

 

{{out}}

=={{header|zkl}}==

{{trans|Java}}

fcn init(n){ var result=magicSquareSinglyEven(n) }

fcn toString{

result

}

{{out}}

<pre>