Magic squares of doubly even order: Difference between revisions

{{trans|Java}}

 

V bits = 1001'0110'0110'1001b

V size = n * n

print(‘#2 ’.format(x), end' ‘’)

print()

 

{{out}}

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

{{trans|Java}}

MAGICSDB CSECT

USING MAGICSDB,R13

XDEC DS CL12 temp for xdeco

YREGS

{{out}}

<pre>

=={{header|ALGOL 60}}==

{{works with|A60}}

comment Magic squares of doubly even order - 10/02/2021;

integer array pattern[1:4,1:4];

end;

outstring(1,"magic constant ="); outinteger(1,(s+1)*n div 2)

{{out}}

<pre>

{{Trans|ALGOL 60}}

Using a procedure to generate the square for easier re-use.

PROC doubly even magic square = ( INT n )[,]INT:

IF n MOD 4 /= 0 THEN

print( ( "magic constant = ", whole( ( ( ( order * order ) + 1 ) * order ) OVER 2, 0 ), newline ) )

OD

{{out}}

<pre>

133 134 135 9 8 7 6 5 4 142 143 144

magic constant = 870

</pre>

 

=={{header|AppleScript}}==

{{Trans|JavaScript}}

 

-- magicSquare :: Int -> [[Int]]

end tell

return v

{{Out}}

magic(8)

{{trans|C#}}

Since standard awk does not support bitwise operators, we provide the function countup to do the magic.

BEGIN {

n = 8

bitpos = int(c / mult) + int(r / mult) * 4 + 1

return substr(pattern, bitpos, 1) + 0

 

{{out}}

The size, ''N'', is specified by the first value on the stack. The algorithm is loosely based on the [[Magic_squares_of_doubly_even_order#Java|Java]] implementation.

 

 

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

=={{header|C sharp|C#}}==

{{trans|Java}}

 

namespace MagicSquareDoublyEven

}

}

<pre> 1 2 62 61 60 59 7 8

9 10 54 53 52 51 15 16

 

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

#include <sstream>

#include <iomanip>

s.display();

return 0;

{{out}}

<pre>

=={{header|D}}==

{{trans|Java}}

 

void main() {

 

return result;

 

{{out}}

 

Magic constant: 260</pre>

 

=={{header|Elena}}==

{{trans|C#}}

import extensions;

import extensions'routines;

{

if(n < 4 || n.mod(4) != 0)

int bits := 09669h;

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

int i := 0;

{

{

int bitPos := c / mult + (r / mult) * 4;

}

};

console.printLine().printLine("Magic constant: ",(n * n + 1) * n / 2)

{{out}}

<pre>

 

=={{header|Elixir}}==

def doubly_even(n) when rem(n,4)!=0, do: raise ArgumentError, "must be even, but not divisible by 4."

def doubly_even(n) do

end

 

 

{{out}}

 

=={{header|Factor}}==

generalizations kernel math math.matrices prettyprint sequences

;

] each ;

 

{{out}}

<pre>

 

=={{header|FreeBASIC}}==

' compile with: fbc -s console

' doubly even magic square 4, 8, 12, 16...

Print : Print "hit any key to end program"

Sleep

{{out}}

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

 

=={{header|Go}}==

 

import (

fmt.Printf("\nMagic Constant: %d\n", magicConstant)

}

{{Out}}

<pre> 1 2 62 61 60 59 7 8

 

=={{header|Haskell}}==

import Data.List.Split (chunksOf)

import Data.Bool (bool)

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

print $ checked test

{{Out}}

<pre> 1 15 14 4

 

=={{header|J}}==

masksq=: >:@#@, | _1&^ * 1 + i.@$

pat4=: ,:(+.|.)=i.4

mask=: ,/@(,./"3@$&pat4)@] ,~ % 4:

demsq=: masksq@mask

{{out}}

<pre>

 

=={{header|Java}}==

 

public static void main(String[] args) {

return result;

}

 

<pre> 1 2 62 61 60 59 7 8

===ES6===

{{Trans|Haskell}}

'use strict';

 

// MAIN ------------------------------------------------

return main();

{{Out}}

<pre>Order: 4

'''Works with gojq, the Go implementation of jq'''

 

def l: tostring | ($len - length) as $l | (" " * $l)[:$l] + .;

if type == "array" then map(l) else l end;

"\nMagic constant for order \($n): \(($n*$n + 1) * $n / 2)\n\n" ;

 

{{out}}

<pre>

 

=={{header|Julia}}==

 

function magicsquaredoubleeven(order::Int)

end

println()

 

{{out}}

=={{header|Kotlin}}==

{{trans|Java}}

 

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

}

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

 

{{out}}

=={{header|Nim}}==

{{trans|Kotlin}}

 

type Square = seq[seq[int]]

let n = 8

echo magicSquareDoublyEven(n)

 

{{out}}

 

A magic one-liner:

 

Output:<pre>magicsquare(8)

 

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

 

=={{header|Phix}}==

{{trans|C++}}

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

<span style="color: #008080;">constant</span> <span style="color: #000000;">t</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{{</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #000000;">0</span><span style="color: #0000FF;">,</span><span style="color: #000000;">0</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>

=={{header|PureBasic}}==

{{trans|FreeBasic}}

ProcedureReturn n*(n*n+1)/2

EndProcedure

DblEvenMagicSquare(n)

n=0

{{out}}<pre>Input [4,8,12..n] (0=Exit)

>8

=={{header|Python}}==

===Procedural===

def MagicSquareDoublyEven(order):

sq = [range(1+n*order,order + (n*order)+1) for n in range(order) ]

 

printsq(MagicSquareDoublyEven(8))

{{out}}<pre>

1 2 62 61 60 59 7 8

Generating test results and a magic square in the form of a wiki table:

{{Works with|Python|3.7}}

 

from itertools import chain, repeat

 

if __name__ == '__main__':

{{Out}}

<pre>Row sums: [260, 260, 260, 260, 260, 260, 260, 260]

Translation of the magic square code example from [https://math.nist.gov/javanumerics/jama/ Jama], which is released to the public domain. This includes all three cases.

 

if (n %% 2 == 1) {

p <- (n + 1) %/% 2 - 2

a

}

 

'''Example'''

"Marked" numbers &nbsp; (via the &nbsp; '''diag''' &nbsp; subroutine) &nbsp; indicate that those (sequentially generated) numbers don't get

<br>swapped &nbsp; (and thusly, stay in place in the magic square).

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. */

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

end /*c*/

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

<pre>

=={{header|Ruby}}==

 

raise ArgumentError, "Need multiple of four" if n%4 > 0

block_size, max = n/4, n*n

end

 

{{out}}

<pre>

 

=={{header|Rust}}==

 

fn main() {

println!();

}

{{out}}

<pre>

=={{header|Scala}}==

{{Out}}Best seen running in your browser either by [https://scalafiddle.io/sf/bdTcGF3/0 ScalaFiddle (ES aka JavaScript, non JVM)] or [https://scastie.scala-lang.org/gLhkwHHlRO6rPXg9U7MDzg Scastie (remote JVM)].

private val n = 8

 

println(f"---%nMagic constant: ${(n * n + 1) * n / 2}%d")

 

 

=={{header|Sidef}}==

{{trans|Ruby}}

assert(n%4 == 0, "Need multiple of four")

var (bsize, max) = (n/4, n*n)

}

 

{{out}}

<pre>

{{trans|R}}

 

function magic(n) {

if (mod(n,2)==1) {

return(a)

}

 

<pre>. mata magic(8)

=={{header|VBScript}}==

{{trans|Java}}

n=8 'multiple of 4

pattern="1001011001101001"

wscript.echo l

Next 'r

{{out}}

<pre>Magic square : 8 x 8

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

{{trans|C#}}

 

Function MagicSquareDoublyEven(n As Integer) As Integer(,)

End Sub

 

{{out}}

<pre> 1 2 62 61 60 59 7 8

{{trans|Kotlin}}

{{libheader|Wren-fmt}}

 

var magicSquareDoublyEven = Fn.new { |n|

System.print()

}

 

{{out}}

=={{header|zkl}}==

{{trans|Java}}

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

fcn toString{

}

}

{{out}}

<pre>