Magic squares of doubly even order: Difference between revisions

A [[wp:Magic_square|magic square]] is an   '''NxNN×N'''  square matrix whose numbers consist of consecutive numbers arranged so that the sum of each row and column,   ''and''   both diagonals are equal to the same sum   (which is called the ''magic number'' or ''magic constant'').

A magic square of doubly even order has a size that is a multiple of four   (e.g.     '''4''', '''8''', '''12'''). This means that the subsquares also have an even size, which plays a role in the construction.

Create a magic square of   '''8 x× 8'''.

; Related tasks

<langsyntaxhighlight lang="360asm">* Magic squares of doubly even order 01/03/2017

END MAGICSDB</langsyntaxhighlight>

<langsyntaxhighlight AppleScriptlang="applescript">-- MAGIC SQUARE OF DOUBLY EVEN ORDER -----------------------------------------

end |until|</langsyntaxhighlight>

<langsyntaxhighlight lang="befunge">8>>>v>10p00g:*1-*\110g2*-*+1+.:00g%!9+,:#v_@

p00:<^:!!-!%3//4g00%g00\!!%3/*:g00*4:::-1<*:</langsyntaxhighlight>

<langsyntaxhighlight lang="cpp">#include <iostream>

}</langsyntaxhighlight>

<langsyntaxhighlight Dlang="d">import std.stdio;

}</langsyntaxhighlight>

ELENA 46.x :

<langsyntaxhighlight lang="elena">import system'routines;

{ InvalidArgumentException.new:("base must be a positive multiple of 4").raise() };

var result := new IntMatrix.allocate(n,n);

for (int r := 0,; r < n,; r += 1)

for(int c := 0,; c < n,; c += 1,; i += 1)

result[r][c] := ((bits && (1 $shl bitPos)) != 0).iif(i+1,size - i)

}</langsyntaxhighlight>

<langsyntaxhighlight lang="elixir">defmodule Magic_square do

Magic_square.doubly_even(8)</langsyntaxhighlight>

<langsyntaxhighlight lang="factor">USING: arrays combinators.short-circuit formatting fry

MAIN: main</langsyntaxhighlight>

<langsyntaxhighlight lang="freebasic">' version 18-03-2016

End</langsyntaxhighlight>

<langsyntaxhighlight Golang="go">package main

<langsyntaxhighlight Haskelllang="haskell">import Data.List (transpose, unfoldr, intercalate)

chunksOf n $ zipWith (flip (bool =<< (-) limit)) series [1 .. sqr]

putStrLn ""[]</langsyntaxhighlight>

<pre>main 1 15 14 4

mask masksq=: >:@#@,#: 8| $_1&^ 153* 1021 102+ 153i.@$

t pat4=: ,:(, 65&-+.|.) each >:=i.644

<langsyntaxhighlight lang="java">public class MagicSquareDoublyEven {

}</langsyntaxhighlight>

<langsyntaxhighlight JavaScriptlang="javascript">(() => {

// doubleEvenMagicSquaredoublyEvenMagicSquare :: Int -> [[Int]]

const doubleEvenMagicSquaredoublyEvenMagicSquare = n => {

if0 === (n % 4 >? 0(() return=> undefined;{

// truthSeries :: Int -> [IntBool]

const truthSeries = n => {

0 >= n if? (n <= 0) return [true];

})();

// concatMapall :: (a -> [b]Bool) -> [a] -> [b]Bool

const concatMapall = (f, xs)p => [].concat.apply([], xs.map(f));

// splitEverychunksOf :: Int -> [a] -> [][a]]

const splitEverychunksOf = (n, => xs) => {

if enumFromThenTo(0)(xs.length <= n) return [xs];(

const [h, t] = [xs.slice(0,length n),- xs.slice(n)];1

return [h]).concatreduce(splitEvery(n, t));

// currycompose (<<<) :: ((a, b) -> c) -> (a -> b) -> a -> c

const currycompose = f(...fs) => a => b => f(a, b);

// replicatediagonals :: Int[[a]] -> [[a ->], [a]]

const replicatediagonals = (n, a)rows => {

let// vTwo =diagonal [a]sequences,

// from top left oand =bottom [];left

if// (nrespectively, <of 1)a returngiven o;matrix.

while map(n > 1flip(zipWith(index) {)(

if enumFromTo(n & 10) o = o.concat(v);pred(

n >>= 1; 0 < rows.length ? (

v = v rows[0].concat(v);length

} ) : 0

return o.concat(v ));

// isIntenumFromTo :: Int -> BoolInt -> [Int]

const isIntenumFromTo = xm => xn === Math.floor(x);>

// transposeflip :: [[(a]] -> [[b -> c) -> b -> a]] -> c

const transposeflip = xsf =>

xs[0].map((_, iCol)x => xs.map((row)y => row[iCol]f(y)(x);

// diagonalsindex (!!) :: [[a]] -> ([a],Int -> [a])

const diagonalsindex = xs => {i => xs[i];

// intercalate :: String if-> (nRows[String] ===-> nCols) {String

const nsintercalate = range(0,s nCols - 1);=>

// zipWithisInt :: (aInt -> b -> c) -> [a] -> [b] -> [c]Bool

const zipWithisInt = (f,x xs,=> ys)x =>== {Math.floor(x);

// reversejustifyRight :: [a]Int -> [a]Char -> String -> String

const reversejustifyRight = (xs)n => xs.slice(0)cFiller => s =>

n > s.reverselength ? ()

// rangemap :: Int(a -> Intb) -> [Inta] -> [b]

const rangemap = (m,f n)=> xs =>

length: Math.floor(n - m) + 1

}, (_, i) => m + ix);

// allreverse :: ([a -> Bool)] -> [a] -> Bool

const allreverse = (f, xs) => xs.every(f);

// justifyRightstr :: Inta -> Char -> Text -> TextString

const justifyRightstr = (n,x cFiller,=> strTextx.toString() =>;

const unlines = .map(nxs => {xs.join('\n');

// zipWith :: (a -> b -> c) const-> sums[a] =-> lines.concat([b] -> [c]

const zipWith = f => xs => ys transpose(lines)=>

xs.concatslice(diagonals(lines))

0, Math.min(xs.length, ys.length)

).map(xs => xs.reduce((ax, bi) => a + b, 0f(x)(ys[i]));

<langsyntaxhighlight lang="julia">#using v0.6Printf

end</langsyntaxhighlight>

<langsyntaxhighlight lang="scala">// version 1.1.0

}</langsyntaxhighlight>

<langsyntaxhighlight lang="parigp">magicsquare(n)=matrix(n,n,i,j,k=i+j*n-n;if(bitand(38505,2^((j-1)%4*4+(i-1)%4)),k,n*n+1-k))</langsyntaxhighlight>

<langsyntaxhighlight PureBasiclang="purebasic">Procedure.i MagicN(n.i)

ForEver</langsyntaxhighlight>

<langsyntaxhighlight lang="python">

<langsyntaxhighlight lang="python">'''Magic squares of doubly even order'''

main()</langsyntaxhighlight>

<langsyntaxhighlight lang="rexx">/*REXX program constructs a magic square of doubly even sides (a size divisible by 4).*/

n= 8; s= n%4; L= n%2-s+1; w= length(n**2) /*size; small sq; low middle; # width*/

@.= 0; H= n%2+s /*array default; high middle. */

end /*c*/

end /*r*/; return

do c=1 for n; if c>s & c<=n-s then iterate; @.r.c= -@(r,c); end /*cnegate*/

end /*rc*/

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

<langsyntaxhighlight lang="ruby">def double_even_magic_square(n)

puts to_string(double_even_magic_square(8))</langsyntaxhighlight>

<langsyntaxhighlight Scalalang="scala">object MagicSquareDoublyEven extends App {

}</langsyntaxhighlight>

<langsyntaxhighlight lang="ruby">func double_even_magic_square(n) {

say format_matrix(double_even_magic_square(8))</langsyntaxhighlight>

<langsyntaxhighlight lang="vb">' Magic squares of doubly even order

wscript.echo "Magic constant=" & (n*n+1)*n/2</langsyntaxhighlight>

<langsyntaxhighlight lang="vbnet">Module MagicSquares

End Module</langsyntaxhighlight>

<langsyntaxhighlight lang="zkl">class MagicSquareDoublyEven{

MagicSquareDoublyEven(8).println();</langsyntaxhighlight>