Data commit

Task/Magic-constant/00-META.yaml

@@ -0,0 +1,2 @@
+---
+from: http://rosettacode.org/wiki/Magic_constant

Task/Magic-constant/00-TASK.txt

@@ -0,0 +1,41 @@
+A magic square is a square grid containing consecutive integers from 1 to N², arranged so that every row, column and diagonal adds up to the same number. That number is a constant. There is no way to create a valid N x N magic square that does not sum to the associated constant. 
+
+;EG
+
+A 3 x 3 magic square ''always'' sums to 15. 
+
+<pre style="font-family: consolas, inconsolata, monospace; line-height: normal;">    ┌───┬───┬───┐
+    │ 2 │ 7 │ 6 │
+    ├───┼───┼───┤
+    │ 9 │ 5 │ 1 │
+    ├───┼───┼───┤
+    │ 4 │ 3 │ 8 │
+    └───┴───┴───┘</pre>
+
+A 4 x 4 magic square ''always'' sums to 34.
+
+Traditionally, the sequence leaves off terms for n = 0 and n = 1 as the magic squares of order 0 and 1 are trivial; and a term for n = 2 because it is impossible to form a magic square of order 2.
+
+
+;Task
+
+* Starting at order 3, show the first 20 magic constants.
+* Show the 1000th magic constant. (Order 1003)
+* Find and show the order of the smallest N x N magic square whose constant is greater than 10¹ through 10¹⁰.
+
+
+;Stretch
+
+* Find and show the order of the smallest N x N magic square whose constant is greater than 10¹¹ through 10²⁰.
+
+
+;See also
+
+* [[wp:Magic_constant|Wikipedia: Magic constant]]
+* [[oeis:A006003|OEIS: A006003]] (Similar sequence, though it includes terms for 0, 1 & 2.)
+* [[Magic squares of odd order]]
+* [[Magic squares of singly even order]]
+* [[Magic squares of doubly even order]]
+
+
+

Task/Magic-constant/11l/magic-constant.11l

@@ -0,0 +1,17 @@
+F a(=n)
+   n += 2
+   R n * (n ^ 2 + 1) / 2
+
+F inv_a(x)
+   V k = 0
+   L k * (k ^ 2.0 + 1) / 2 + 2 < x
+      k++
+   R k
+
+print(‘The first 20 magic constants are:’)
+L(n) 1..19
+   print(Int(a(n)), end' ‘ ’)
+print("\nThe 1,000th magic constant is: "Int(a(1000)))
+
+L(e) 1..19
+   print(‘10^’e‘: ’inv_a(10.0 ^ e))

Task/Magic-constant/ALGOL-68/magic-constant.alg

@@ -0,0 +1,24 @@
+BEGIN # find some magic constants - the row, column and diagonal sums of a magin square #
+      # translation of the Free Basic sample with the Julia/Wren inverse function #
+    # returns the magic constant of a magic square of order n + 2 #
+    PROC a     = ( INT n )LONG LONG INT:
+         BEGIN
+            LONG LONG INT n2 = n + 2;
+            ( n2 * ( ( n2 * n2 ) + 1 ) ) OVER 2
+         END # a # ;
+    # returns the order of the magic square whose magic constant is at least x #
+    PROC inv a = ( LONG LONG INT x )LONG LONG INT:
+         ENTIER long long exp( long long ln( x * 2 ) / 3 ) + 1;
+
+    print( ( "The first 20 magic constants are " ) );
+    FOR n TO 20 DO
+        print( ( whole( a( n ), 0 ), " " ) )
+    OD;
+    print( ( newline ) );
+    print( ( "The 1,000th magic constant is ", whole( a( 1000 ), 0 ), newline ) );
+    LONG LONG INT e := 1;
+    FOR n TO 20 DO
+        e *:= 10;
+        print( ( "10^", whole( n, -2 ), ": ", whole( inv a( e ), -9 ), newline ) )
+    OD
+END

Task/Magic-constant/AWK/magic-constant.awk

@@ -0,0 +1,24 @@
+# syntax: GAWK -f MAGIC_CONSTANT.AWK
+# converted from FreeBASIC
+BEGIN {
+    printf("The first 20 magic constants are:")
+    for (i=1; i<=20; i++) {
+      printf(" %d",a(i))
+    }
+    printf("\n")
+    printf("The 1,000th magic constant is: %d\n",a(1000))
+    for (i=1; i<=20; i++) {
+      printf("10^%02d: %8d\n",i,inv_a(10^i))
+    }
+    exit(0)
+}
+function a(n) {
+    n += 2
+    return(n*(n^2+1)/2)
+}
+function inv_a(x,  k) {
+    while (k*(k^2+1)/2+2 < x) {
+      k++
+    }
+    return(k)
+}

Task/Magic-constant/Arturo/magic-constant.arturo

@@ -0,0 +1,21 @@
+a: function [n][
+    n: n+2
+    return (n*(1 + n^2))/2
+]
+
+aInv: function [x][
+    k: new 0
+    while [x > 2 + k*(1+k^2)/2]
+        -> inc 'k
+    return k
+]
+print "The first 20 magic constants are:"
+print map 1..19 => a
+
+print ""
+print "The 1,000th magic constant is:"
+print a 1000
+
+print ""
+loop 1..19 'z ->
+    print ["10 ^" z "=>" aInv 10^z]

Task/Magic-constant/BASIC256/magic-constant.basic

@@ -0,0 +1,24 @@
+function a(n)
+	n = n + 2
+	return n*(n^2 + 1)/2
+end function
+
+function inv_a(x)
+	k = 0
+	while k*(k^2+1)/2+2 < x
+		k += 1
+	end while
+	return k
+end function
+
+print "The first 20 magic constants are:"
+for n = 1 to 20
+	print int(a(n));" ";
+next n
+print : print
+print "The 1,000th magic constant is "; int(a(1000)); chr(10)
+
+for e = 1 to 20
+	print "10^"; e; ": "; chr(9); inv_a(10^e)
+next e
+end

Task/Magic-constant/Delphi/magic-constant.delphi

@@ -0,0 +1,38 @@
+function GetMagicNumber(N: double): double;
+begin
+Result:=N * (((N * N) + 1) / 2);
+end;
+
+function GetNumberLess(N: double): integer;
+var M: double;
+begin
+for Result:=1 to High(Integer) do
+	begin
+	M:=GetMagicNumber(Result);
+	if M>N then break;
+	end;
+end;
+
+procedure ShowMagicNumber(Memo: TMemo);
+var I,J: integer;
+var N,M: double;
+var S: string;
+begin
+S:='';
+for I:=3 to 23 do
+	begin
+	S:=S+Format('%8.0n',[GetMagicNumber(I)]);
+	if (I mod 5)=2 then S:=S+#$0D#$0A;
+	end;
+Memo.Lines.Add(S);
+Memo.Lines.Add('');
+Memo.Lines.Add('1000th: '+Format('%8.0n',[GetMagicNumber(1002)]));
+Memo.Lines.Add('');
+N:=10;
+for I:=1 to 20 do
+	begin
+	J:=GetNumberLess(N);
+	Memo.Lines.Add('M^'+Format('%d%8d',[I,J]));
+	N:=N * 10;
+	end;
+end;

Task/Magic-constant/Factor/magic-constant.factor

@@ -0,0 +1,17 @@
+USING: formatting io kernel math math.functions.integer-logs
+math.ranges prettyprint sequences ;
+
+: magic ( m -- n ) dup sq 1 + 2 / * ;
+
+"First 20 magic constants:" print
+3 22 [a,b] [ bl ] [ magic pprint ] interleave nl
+nl
+"1000th magic constant: " write 1002 magic .
+nl
+"Smallest order magic square with a constant greater than:" print
+1 0 20 [
+    [ 10 * ] dip
+    [ dup magic pick < ] [ 1 + ] while
+    over integer-log10 over "10^%02d: %d\n" printf
+    dup + 1 -
+] times 2drop

Task/Magic-constant/Free-Pascal/magic-constant.pas

@@ -0,0 +1,40 @@
+program MagicConst;
+{$IFDEF FPC}{$MODE DELPHI}{$OPTIMIZATION ON,ALL}{$ENDIF}
+{$IFDEF WINDOWS}{$APPTYPE CONSOLE}{$ENDIF}
+
+function MagicSum(n :Uint32):Uint64; inline;
+var
+  k : Uint64;
+begin
+  k := n*Uint64(n);
+  result := (k*k+k) DIV 2;
+end;
+
+function MagSumPerRow(n:Uint32):Uint32;
+begin
+//result := MagicSum(n) DIV n;
+  //(n^3 + n) /2
+  result := ((Uint64(n)*n+1)*n) DIV 2;
+end;
+var
+  s : String[31];
+  i : Uint32;
+  lmt,rowcnt : extended;
+Begin
+  writeln('First Magic constants 3..20');
+  For i := 3 to 20 do
+     write(MagSumPerRow(i),' ');
+  writeln;
+  writeln('1000.th ',MagSumPerRow(1002));
+
+  writeln('First Magic constants > 10^xx');
+  //lmt = (rowcnt^3 + rowcnt) /2 -> rowcnt > (lmt*2 )^(1/3)
+  lmt := 2.0 * 10.0;
+  For i :=  1 to 50 do
+  begin
+    rowcnt := Int(exp(ln(lmt)/3))+1.0;//+1 suffices
+    str(trunc(rowcnt),s);
+    writeln('10^',i:2,#9,s:18);
+    f := 10.0*lmt;
+  end;
+end.

Task/Magic-constant/FreeBASIC/magic-constant.basic

@@ -0,0 +1,24 @@
+function a(byval n as uinteger) as ulongint
+    n+=2
+    return n*(n^2 + 1)/2
+end function
+
+function inv_a(x as double) as ulongint
+    dim as ulongint k = 0
+    while k*(k^2+1)/2+2 < x
+        k+=1
+    wend
+    return k
+end function
+
+dim as ulongint n
+print "The first 20 magic constants are ":
+for n = 1 to 20
+    print a(n);" ";
+next n
+print
+print "The 1,000th magic constant is ";a(1000)
+
+for e as uinteger = 1 to 20
+    print using "10^##: #########";e;inv_a(10^cast(double,e))
+next e

Task/Magic-constant/Go/magic-constant.go

@@ -0,0 +1,45 @@
+package main
+
+import (
+    "fmt"
+    "math"
+    "rcu"
+)
+
+func magicConstant(n int) int {
+    return (n*n + 1) * n / 2
+}
+
+var ss = []string{
+    "\u2070", "\u00b9", "\u00b2", "\u00b3", "\u2074",
+    "\u2075", "\u2076", "\u2077", "\u2078", "\u2079",
+}
+
+func superscript(n int) string {
+    if n < 10 {
+        return ss[n]
+    }
+    if n < 20 {
+        return ss[1] + ss[n-10]
+    }
+    return ss[2] + ss[0]
+}
+
+func main() {
+    fmt.Println("First 20 magic constants:")
+    for n := 3; n <= 22; n++ {
+        fmt.Printf("%5d ", magicConstant(n))
+        if (n-2)%10 == 0 {
+            fmt.Println()
+        }
+    }
+
+    fmt.Println("\n1,000th magic constant:", rcu.Commatize(magicConstant(1002)))
+
+    fmt.Println("\nSmallest order magic square with a constant greater than:")
+    for i := 1; i <= 20; i++ {
+        goal := math.Pow(10, float64(i))
+        order := int(math.Cbrt(goal*2)) + 1
+        fmt.Printf("10%-2s : %9s\n", superscript(i), rcu.Commatize(order))
+    }
+}

Task/Magic-constant/J/magic-constant-1.j

@@ -0,0 +1 @@
+mgc=: 0 0.5 0 0.5&p.

Task/Magic-constant/J/magic-constant-2.j

@@ -0,0 +1,15 @@
+   mgc 3+i.20
+15 34 65 111 175 260 369 505 671 870 1105 1379 1695 2056 2465 2925 3439 4010 4641 5335
+   mgc 1003x
+504514015
+   (#\,.],.mgc) x:(mgc i.3000) I.10^1+i.10
+ 1    3          15
+ 2    6         111
+ 3   13        1105
+ 4   28       10990
+ 5   59      102719
+ 6  126     1000251
+ 7  272    10061960
+ 8  585   100101105
+ 9 1260  1000188630
+10 2715 10006439295

Task/Magic-constant/J/magic-constant-3.j

@@ -0,0 +1,11 @@
+   ((10+#\),.],.mgc) x:(mgc i.6e6) I.10^11+i.10
+11    5849          100049490449
+12   12600         1000188006300
+13   27145        10000910550385
+14   58481       100003310078561
+15  125993      1000021311323825
+16  271442     10000026341777165
+17  584804    100000232056567634
+18 1259922   1000002262299152685
+19 2714418  10000004237431278525
+20 5848036 100000026858987459346

Task/Magic-constant/Jq/magic-constant-1.jq

@@ -0,0 +1,36 @@
+# To take advantage of gojq's arbitrary-precision integer arithmetic:
+def power($b): . as $in | reduce range(0;$b) as $i (1; . * $in);
+
+# nth-root
+def iroot($n):
+  . as $in
+  | if $n == 1 then .
+    else (. < 0) as $neg
+    | if $neg and (n % 2) == 0
+      then "Cannot take the \($n)th root of a negative number." | error
+      else ($n-1) as $n
+      | {t: (if $neg then -. else . end)}
+      | .s = .t + 1
+      | .u = .t
+      | until (.u >= .s;
+          .s = .u
+          | .u = ((.u * $n) + (.t / (.u|power($n)))) / ($n + 1) )
+      | if $neg then - .s else .s end
+      end
+    end;
+
+# input: an array
+# output: a stream of arrays of size size except possibly for the last array
+def group(size):
+  recurse( .[size:]; length>0) | .[0:size];
+
+def lpad($len): tostring | ($len - length) as $l | (" " * $l)[:$l] + .;
+
+def ss : ["\u2070", "\u00b9", "\u00b2", "\u00b3", "\u2074",
+          "\u2075", "\u2076", "\u2077", "\u2078", "\u2079"];
+
+def superscript:
+  if . < 10 then ss[.]
+  elif . < 20 then ss[1] + ss[. - 10]
+  else ss[2] + ss[0]
+  end;

Task/Magic-constant/Jq/magic-constant-2.jq

@@ -0,0 +1,14 @@
+def magicConstant: (.*. + 1) * . / 2;
+
+"First 20 magic constants:",
+ ([range(3;23)
+  | magicConstant]
+  | group(10) | map(lpad(5)) | join(" ")),
+ "",
+ "1,000th magic constant: \( 1002| magicConstant)",
+ "",
+ "Smallest order magic square with a constant greater than:",
+ (range(1; 21) as $i
+  | (10 | power($i)) as $goal
+  | ((($goal * 2)|iroot(3) + 1) | floor) as $order
+  | ("10\($i|superscript)" | lpad(5)) + ": \($order|lpad(9))"  )

Task/Magic-constant/Julia/magic-constant.julia

@@ -0,0 +1,13 @@
+using Lazy
+
+magic(x) = (1 + x^2) * x ÷ 2
+magics = @>> Lazy.range() map(magic) filter(x -> x > 10) # first 2 values are filtered out
+println("First 20 magic constants: ", Int.(take(20, magics)))
+println("Thousandth magic constant is: ", collect(take(1000, magics))[end])
+
+println("Smallest magic square with constant greater than:")
+for expo in 1:20
+    goal = big"10"^expo
+    ordr = Int(floor((2 * goal)^(1/3))) + 1
+    println("10^", string(expo, pad=2), "    ", ordr)
+end

Task/Magic-constant/Mathematica/magic-constant.math

@@ -0,0 +1,11 @@
+ClearAll[i, n, MagicSumHelper, MagicSum, InverseMagicSum]
+MagicSumHelper[n_] = Sum[i, {i, n^2}]/n;
+MagicSum[n_] := MagicSumHelper[n + 2]
+InverseMagicSum[lim_] := Ceiling[-(1/(3^(1/3) (9 lim + Sqrt[3] Sqrt[1 + 27 lim^2])^(1/3))) + (9 lim + Sqrt[3] Sqrt[1 + 27 lim^2])^(1/3)/3^(2/3)]
+
+MagicSum /@ Range[20]
+MagicSum[1000]
+
+exps = Range[1, 50];
+nums = 10^exps;
+Transpose[{Superscript[10, #] & /@ exps, InverseMagicSum[nums]}] // Grid

Task/Magic-constant/Nim/magic-constant.nim

@@ -0,0 +1,35 @@
+import std/[math, unicode]
+
+func magicConstant(n: int): int =
+  ## Return the magic constant for a magic square of order "n".
+  n * (n * n + 1) div 2
+
+func minOrder(n: int): int =
+  ## Return the smallest order such as the magic constant is greater than "10^n".
+  const Ln2 = ln(2.0)
+  const Ln10 = ln(10.0)
+  result = int(exp((Ln2 + n.toFloat * Ln10) / 3)) + 1
+
+const First = 3
+const Superscripts: array['0'..'9', string] = ["⁰", "¹", "²", "³", "⁴", "⁵", "⁶", "⁷", "⁸", "⁹"]
+
+template order(idx: Positive): int =
+  ## Compute the order of the magic square at index "idx".
+  idx + (First - 1)
+
+func superscript(n: Natural): string =
+  ## Return the Unicode string to use to represent an exponent.
+  for d in $n:
+    result.add(Superscripts[d])
+
+echo "First 20 magic constants:"
+for idx in 1..20:
+  stdout.write ' ', order(idx).magicConstant
+echo()
+
+echo "\n1000th magic constant: ", order(1000).magicConstant
+
+echo "\nOrder of the smallest magic square whose constant is greater than:"
+for n in 1..20:
+  let left = "10" & n.superscript & ':'
+  echo left.alignLeft(6), ($minOrder(n)).align(7)

Task/Magic-constant/Perl/magic-constant.pl

@@ -0,0 +1,16 @@
+#!/usr/bin/perl
+
+use strict; # https://rosettacode.org/wiki/Magic_constant
+use warnings;
+
+my @twenty = map $_ * ( $_ ** 2 + 1 ) / 2, 3 .. 22;
+print "first twenty: @twenty\n\n" =~ s/.{50}\K /\n/gr;
+
+my $thousandth = 1002 * ( 1002 ** 2 + 1 ) / 2;
+print "thousandth: $thousandth\n\n";
+
+print "10**N   order\n";
+for my $i ( 1 .. 20 )
+  {
+  printf "%3d %9d\n", $i, (10 ** $i * 2) ** ( 1 / 3 ) + 1;
+  }

Task/Magic-constant/Phix/magic-constant.phix

@@ -0,0 +1,21 @@
+(phixonline)-->
+ <span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
+
+ <span style="color: #008080;">function</span> <span style="color: #000000;">magic</span><span style="color: #0000FF;">(</span><span style="color: #004080;">integer</span> <span style="color: #000000;">nth</span><span style="color: #0000FF;">)</span>
+     <span style="color: #004080;">integer</span> <span style="color: #000000;">order</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">nth</span><span style="color: #0000FF;">+</span><span style="color: #000000;">2</span>
+     <span style="color: #008080;">return</span> <span style="color: #0000FF;">(</span><span style="color: #000000;">order</span><span style="color: #0000FF;">*</span><span style="color: #000000;">order</span><span style="color: #0000FF;">+</span><span style="color: #000000;">1</span><span style="color: #0000FF;">)/</span><span style="color: #000000;">2</span> <span style="color: #0000FF;">*</span> <span style="color: #000000;">order</span>
+ <span style="color: #008080;">end</span> <span style="color: #008080;">function</span>
+ <span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"First 20 magic constants: %V\n"</span><span style="color: #0000FF;">,{</span><span style="color: #7060A8;">apply</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">tagset</span><span style="color: #0000FF;">(</span><span style="color: #000000;">20</span><span style="color: #0000FF;">),</span><span style="color: #000000;">magic</span><span style="color: #0000FF;">)})</span>
+ <span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"1000th magic constant: %,d\n"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">magic</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1000</span><span style="color: #0000FF;">)})</span>
+
+ <span style="color: #008080;">include</span> <span style="color: #004080;">mpfr</span><span style="color: #0000FF;">.</span><span style="color: #000000;">e</span>
+
+ <span style="color: #004080;">mpz</span> <span style="color: #0000FF;">{</span><span style="color: #000000;">goal</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">order</span><span style="color: #0000FF;">}</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">mpz_inits</span><span style="color: #0000FF;">(</span><span style="color: #000000;">2</span><span style="color: #0000FF;">)</span>
+ <span style="color: #008080;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #000000;">20</span> <span style="color: #008080;">do</span>
+     <span style="color: #7060A8;">mpz_ui_pow_ui</span><span style="color: #0000FF;">(</span><span style="color: #000000;">goal</span><span style="color: #0000FF;">,</span><span style="color: #000000;">10</span><span style="color: #0000FF;">,</span><span style="color: #000000;">i</span><span style="color: #0000FF;">)</span>
+     <span style="color: #7060A8;">mpz_mul_si</span><span style="color: #0000FF;">(</span><span style="color: #000000;">order</span><span style="color: #0000FF;">,</span><span style="color: #000000;">goal</span><span style="color: #0000FF;">,</span><span style="color: #000000;">2</span><span style="color: #0000FF;">)</span>
+     <span style="color: #7060A8;">mpz_nthroot</span><span style="color: #0000FF;">(</span><span style="color: #000000;">order</span><span style="color: #0000FF;">,</span><span style="color: #000000;">order</span><span style="color: #0000FF;">,</span><span style="color: #000000;">3</span><span style="color: #0000FF;">)</span>
+     <span style="color: #7060A8;">mpz_add_si</span><span style="color: #0000FF;">(</span><span style="color: #000000;">order</span><span style="color: #0000FF;">,</span><span style="color: #000000;">order</span><span style="color: #0000FF;">,</span><span style="color: #000000;">1</span><span style="color: #0000FF;">)</span>
+     <span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"1e%d: %s\n"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">i</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">mpz_get_str</span><span style="color: #0000FF;">(</span><span style="color: #000000;">order</span><span style="color: #0000FF;">,</span><span style="color: #000000;">10</span><span style="color: #0000FF;">,</span><span style="color: #004600;">true</span><span style="color: #0000FF;">)})</span>
+ <span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
+<!--

Task/Magic-constant/Prolog/magic-constant.pro

@@ -0,0 +1,10 @@
+m(X,Y):- Y is X*(X*X+1)/2.
+
+l(L,R,T,X):- L > R -> X is L; M is div(L+R,2), m(M,F),
+    (T < F -> R_ is M-1, l(L,R_,T,X); L_ is M+1, l(L_,R,T,X)).
+l(B,X):- l(1,B,B,X).
+
+task:-
+    write("First 20 magic constants are:"), forall(between(3,22,N), (m(N,X), format(" ~d",X))), nl,
+    write("The 1000th magic constant is:"), forall(m(1002,X), format(" ~d",X)), nl,
+    forall(between(1,20,N), (l(10**N,X), format("10^~d:\t~d\n",[N,X]))).

Task/Magic-constant/PureBasic/magic-constant.basic

@@ -0,0 +1,25 @@
+Procedure.i a(n.i)
+  n + 2
+  ProcedureReturn n*(Pow(n,2) + 1)/2
+EndProcedure
+
+Procedure.i inv_a(x.i)
+  k.i = 0
+  While k*(Pow(k,2)+1)/2+2 < x
+    k + 1
+  Wend
+  ProcedureReturn k
+EndProcedure
+
+OpenConsole()
+PrintN("The first 20 magic constants are:")
+For n.i = 1 To 20
+  Print(Str(a(n)) + " ")
+Next n
+PrintN("") : PrintN("")
+PrintN("The 1,000th magic constant is " + Str(a(1000)))
+
+For e.i = 1 To 20
+  PrintN("10^" + Str(e) + ": " + #TAB$ + Str(inv_a(Pow(10,e))))
+Next e
+CloseConsole()

Task/Magic-constant/Python/magic-constant.py

@@ -0,0 +1,21 @@
+#!/usr/bin/python
+
+def a(n):
+    n += 2
+    return n*(n**2 + 1)/2
+
+def inv_a(x):
+    k = 0
+    while k*(k**2+1)/2+2 < x:
+        k+=1
+    return k
+
+
+if __name__ == '__main__':
+    print("The first 20 magic constants are:");
+    for n in range(1, 20):
+        print(int(a(n)), end = " ");
+    print("\nThe 1,000th magic constant is:",int(a(1000)));
+
+    for e in range(1, 20):
+        print(f'10^{e}: {inv_a(10**e)}');

Task/Magic-constant/QB64/magic-constant.qb64

@@ -0,0 +1,26 @@
+$NOPREFIX
+
+DIM order AS INTEGER
+DIM target AS INTEGER64
+
+PRINT "First 20 magic constants:"
+FOR i = 3 TO 22
+    PRINT USING "####,  "; MagicSum(i);
+    IF i MOD 5 = 2 THEN PRINT
+NEXT i
+PRINT
+PRINT USING "1000th magic constant: ##########,"; MagicSum(1002)
+PRINT
+PRINT "Smallest order magic square with a constant greater than:"
+FOR i = 1 TO 13 ' 64-bit integers can take us no further, unsigned or not
+    target = 10 ^ i
+    DO
+        order = order + 1
+    LOOP UNTIL MagicSum(order) > target
+    PRINT USING "10^**: #####,"; i; order
+    order = order * 2 - 1
+NEXT i
+
+FUNCTION MagicSum&& (n AS INTEGER)
+    MagicSum&& = (n * n + 1) / 2 * n
+END FUNCTION

Task/Magic-constant/QBasic/magic-constant.basic

@@ -0,0 +1,24 @@
+FUNCTION a (n)
+    n = n + 2
+    a = n * (n ^ 2 + 1) / 2
+END FUNCTION
+
+FUNCTION inva (x)
+    k = 0
+    WHILE k * (k ^ 2 + 1) / 2 + 2 < x
+        k = k + 1
+    WEND
+    inva = k
+END FUNCTION
+
+PRINT "The first 20 magic constants are: ";
+FOR n = 1 TO 20
+    PRINT a(n); " ";
+NEXT n
+PRINT
+PRINT "The 1,000th magic constant is "; a(1000)
+PRINT
+FOR e = 1 TO 20
+    PRINT USING "10^##: #########"; e; inva(10 ^ e)
+NEXT e
+END

Task/Magic-constant/Quackery/magic-constant.quackery

@@ -0,0 +1,14 @@
+  [ 3 + dup 3 ** + 2 / ] is magicconstant ( n --> n )
+
+  20 times [ i^ magicconstant echo sp ] cr cr
+
+  1000 magicconstant echo cr cr
+
+  0 1
+  [ over magicconstant over > if
+      [ over 3 + echo cr
+        10 * ]
+    dip 1+
+    [ 10 21 ** ] constant
+    over = until ]
+  2drop

Task/Magic-constant/Raku/magic-constant.raku

@@ -0,0 +1,9 @@
+use Lingua::EN::Numbers:ver<2.8+>;
+
+my @magic-constants = lazy (3..∞).hyper.map: { (1 + .²) * $_ / 2 };
+
+put "First 20 magic constants: ", @magic-constants[^20]».&comma;
+say "1000th magic constant: ", @magic-constants[999].&comma;
+say "\nSmallest order magic square with a constant greater than:";
+
+(1..20).map: -> $p {printf "10%-2s: %s\n", $p.&super, comma 3 + @magic-constants.first( * > exp($p, 10), :k ) }

Task/Magic-constant/Sidef/magic-constant.sidef

@@ -0,0 +1,14 @@
+func f(n) {
+    (n+2) * ((n+2)**2 + 1) / 2
+}
+
+func order(n) {
+    iroot(2*n, 3) + 1
+}
+
+say ("First 20 terms: ", f.map(1..20).join(' '))
+say ("1000th term: ", f(1000), " with order ", order(f(1000)))
+
+for n in (1 .. 20) {
+    printf("order(10^%-2s) = %s\n", n, order(10**n))
+}

Task/Magic-constant/True-BASIC/magic-constant.basic

@@ -0,0 +1,25 @@
+FUNCTION a(n)
+    LET n = n + 2
+    LET a = n*(n^2 + 1)/2
+END FUNCTION
+
+FUNCTION inv_a(x)
+    LET k = 0
+    DO WHILE k*(k^2+1)/2+2 < x
+       LET k = k + 1
+    LOOP
+    LET inv_a = k
+END FUNCTION
+
+PRINT "The first 20 magic constants are: ";
+FOR n = 1 TO 20
+    PRINT a(n);" ";
+NEXT n
+PRINT
+PRINT "The 1,000th magic constant is "; a(1000)
+
+FOR e = 1 TO 20
+    PRINT USING "10^##": e;
+    PRINT USING": #########": inv_a(10^e)
+NEXT e
+END

Task/Magic-constant/Wren/magic-constant.wren

@@ -0,0 +1,22 @@
+import "./seq" for Lst
+import "./fmt" for Fmt
+
+var magicConstant = Fn.new { |n| (n*n + 1) * n / 2 }
+
+var ss = ["\u2070", "\u00b9", "\u00b2", "\u00b3", "\u2074",
+          "\u2075", "\u2076", "\u2077", "\u2078", "\u2079"]
+
+var superscript = Fn.new { |n| (n < 10) ? ss[n] : (n < 20) ? ss[1] + ss[n - 10] : ss[2] + ss[0] }
+
+System.print("First 20 magic constants:")
+var mc20 = (3..22).map { |n| magicConstant.call(n) }.toList
+for (chunk in Lst.chunks(mc20, 10)) Fmt.print("$5d", chunk)
+
+Fmt.print("\n1,000th magic constant: $,d", magicConstant.call(1002))
+
+System.print("\nSmallest order magic square with a constant greater than:")
+for (i in 1..20) {
+    var goal = 10.pow(i)
+    var order = (goal * 2).cbrt.floor + 1
+    Fmt.print("10$-2s : $,9d", superscript.call(i), order)
+}

Task/Magic-constant/XPL0/magic-constant.xpl0

@@ -0,0 +1,27 @@
+int  N, X;
+real M, Thresh, MC;
+[Text(0, "First 20 magic constants:^M^J");
+for N:= 3 to 20+3-1 do
+    [IntOut(0, (N*N*N+N)/2);  ChOut(0, ^ )];
+CrLf(0);
+Text(0, "1000th magic constant: ");
+N:= 1000+3-1;
+IntOut(0, (N*N*N+N)/2);
+CrLf(0);
+Text(0, "Smallest order magic square with a constant greater than:^M^J");
+Thresh:= 10.;
+M:= 3.;
+Format(1, 0);
+for X:= 1 to 10 do
+    [repeat MC:= (M*M*M+M)/2.;
+            M:= M+1.;
+    until   MC > Thresh;
+    Text(0, "10^^");
+    if X < 10 then ChOut(0, ^0);
+    IntOut(0, X);
+    Text(0, ": ");
+    RlOut(0, M-1.);
+    CrLf(0);
+    Thresh:= Thresh*10.;
+    ];
+]

Task/Magic-constant/Yabasic/magic-constant.basic

@@ -0,0 +1,23 @@
+sub a(n)
+    n = n + 2
+    return n*(n^2 + 1)/2
+end sub
+
+sub inv_a(x)
+    k = 0
+    while k*(k^2+1)/2+2 < x
+        k = k + 1
+    wend
+    return k
+end sub
+
+print "The first 20 magic constants are: "
+for n = 1 to 20
+    print a(n), " ";
+next n
+print "\nThe 1,000th magic constant is ", a(1000), "\n"
+
+for e = 1 to 20
+    print "10^", e using"##", ": ", inv_a(10^e) using "#########"
+next e
+end