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

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

END MAGICSDB</langsyntaxhighlight>

on lambda|λ|(x)

end lambda|λ|

flatten(scale's lambda|λ|(map(scale, splitEvery(4, magicSeries(4)))))

on lambda|λ|(x, i)

end lambda|λ|

on lambda|λ|(x)

end lambda|λ|

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

on lambda|λ|(lstRow, iRow)

end lambda|λ|

-- GENERIC FUNCTIONS ---------------------------------------------------------------------------

-- mapconcatMap :: (a -> [b]) -> [a] -> [b]

on mapconcatMap(f, xs)

tellscript mReturn(f)append

seton lng|λ|(a, to length of xsb)

set lst to {} a & b

repeatend with i from 1 to lng|λ|

end repeat

end tellconcatMap

set v to lambda|λ|(v, item i of xs, i, xs)

-- untilintercalate :: (aText -> Bool)[Text] -> (a -> a) -> a -> aText

on |until|intercalate(pstrText, f, xlstText)

set vstrJoined to xlstText as text

repeatset untillng mp'sto lambda(v)length of xs

set vlst to lambda(v){}

property lambda|λ| : f

-- intercalatesplitEvery :: TextInt -> [Texta] -> Text[[a]]

on intercalatesplitEvery(strTextn, lstTextxs)

set strJoined to lstText as text{xs}

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

}</langsyntaxhighlight>

<langsyntaxhighlight lang="elixir">defmodule Magic_square do

Magic_square.doubly_even(8)</langsyntaxhighlight>

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

End</langsyntaxhighlight>

<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

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

=={{header|Perl 6}}==

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

ForEver</langsyntaxhighlight>

>>> </pre>

<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 lang="vb">' Magic squares of doubly even order

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

Magic constant=260</pre>

<langsyntaxhighlight lang="zkl">class MagicSquareDoublyEven{

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