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

=={{header|HaskellGo}}==

| (rem n 4) > 0 = []

| otherwise = splitEvery n $

limit = sqr + [1..sqr]

magicSeries n= (iterate ((++) <*> fmap not) [True] !!)

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

checked nsquare = (h, all (\x -> h == x) t)

sums@h:t = sum <$> (square) ++ -- rows

(diagonals square) ++ -- diagonalsrows

transpose square ++ -- cols

<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 <= 1) 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));

// currydiagonals :: (([[a, b)]] -> c) ->[[a], [a -> b -> c]]

const currydiagonals = frows => a => b => f(a, b);

// replicateenumFromThenTo :: Int -> aInt -> Int -> [aInt]

const replicateenumFromThenTo = (n,x1 a)=> x2 => y => {

letconst vd = [a],x2 - x1;

return o = [];Array.from({

if length: Math.floor(ny <- 1x2) return/ d + o;2

while}, (n_, i) => 1)x1 {+ (d * i));

// 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 ? ()

// rangereplicate :: Int -> Inta -> [Inta]

const rangereplicate = (m, n) => x =>

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() =>;

// unlines :: [String] -> )String

const unlines = .map(xs => xs.reducejoin((a, b) => a + b, 0)'\n');

// zipWith :: (a -> b -> c) return-> [a] -> [b] -> [c]

"Summing to: " + sumxs.toStringslice(),

0, "RowMath.min(xs.length, column and diagonal sums checked: " +ys.length)

all).map((x, i) => f(x === sum, sums)(ys[i]));

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

"Marked" numbers indicate that those&nbsp; (sequentiallyvia generated)the numbers&nbsp; don't''diag''' get&nbsp; swappedsubroutine) &nbsp; (andindicate thusly,that staythose in(sequentially placegenerated) innumbers thedon't magic square).get

@.n=0 8; s= n%4; L= H=n%2-s+s 1; w= length(n**2) /*arraysize; small defaultsq; highlow middle. ; # width*/

max#: do a=n for to 1n by -1; do b=n tofor 1n by -1; if @.a.b>0 then return; end; end

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="zkl">class MagicSquareDoublyEven{

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