Magic constant: Difference between revisions

{{works with|ALGOL 68G|Any - tested with release 2.8.3.win32}}

Uses ALGOL 68G's LONG LONG INT whose default precision is large enough to cope with 10^20.

# translation of the Free Basic sample with the Julia/Wren inverse function #

# returns the magic constant of a magic square of order n + 2 #

print( ( "10^", whole( n, -2 ), ": ", whole( inv a( e ), -9 ), newline ) )

OD

{{out}}

<pre>

=={{header|Arturo}}==

 

n: n+2

return (n*(1 + n^2))/2

print ""

loop 1..19 'z ->

 

{{out}}

 

=={{header|AWK}}==

# syntax: GAWK -f MAGIC_CONSTANT.AWK

# converted from FreeBASIC

return(k)

}

{{out}}

<pre>

=={{header|Basic}}==

==={{header|FreeBASIC}}===

function a(byval n as uinteger) as ulongint

n+=2

for e as uinteger = 1 to 20

print using "10^##: #########";e;inv_a(10^cast(double,e))

{{out}}<pre>

The first 20 magic constants are

 

==={{header|QB64}}===

 

DIM order AS INTEGER

FUNCTION MagicSum&& (n AS INTEGER)

MagicSum&& = (n * n + 1) / 2 * n

{{out}}

<pre>

 

==={{header|BASIC256}}===

n = n + 2

return n*(n^2 + 1)/2

print "10^"; e; ": "; chr(9); inv_a(10^e)

next e

 

==={{header|PureBasic}}===

n + 2

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

PrintN("10^" + Str(e) + ": " + #TAB$ + Str(inv_a(Pow(10,e))))

Next e

 

==={{header|QBasic}}===

{{works with|QBasic|1.1}}

{{works with|QuickBasic|4.5}}

n = n + 2

a = n * (n ^ 2 + 1) / 2

PRINT USING "10^##: #########"; e; inva(10 ^ e)

NEXT e

 

==={{header|True BASIC}}===

LET n = n + 2

LET a = n*(n^2 + 1)/2

PRINT USING": #########": inv_a(10^e)

NEXT e

 

==={{header|Yabasic}}===

n = n + 2

return n*(n^2 + 1)/2

print "10^", e using"##", ": ", inv_a(10^e) using "#########"

next e

 

 

=={{header|Factor}}==

{{works with|Factor|0.99 2021-06-02}}

math.ranges prettyprint sequences ;

 

over integer-log10 over "10^%02d: %d\n" printf

dup + 1 -

{{out}}

<pre>

{{trans|Wren}}

{{libheader|Go-rcu}}

 

import (

fmt.Printf("10%-2s : %9s\n", superscript(i), rcu.Commatize(order))

}

 

{{out}}

=={{header|J}}==

 

 

In other words, the magic constant for a magic square of order <tt>x</tt> is the result of the polynomial <code>(0.5*x)+(0.5*x^3)</code>

 

15 34 65 111 175 260 369 505 671 870 1105 1379 1695 2056 2465 2925 3439 4010 4641 5335

mgc 1003x

8 585 100101105

9 1260 1000188630

11 5849 100049490449

12 12600 1000188006300

18 1259922 1000002262299152685

19 2714418 10000004237431278525

 

=={{header|jq}}==

 

'''Preliminaries'''

def power($b): . as $in | reduce range(0;$b) as $i (1; . * $in);

 

elif . < 20 then ss[1] + ss[. - 10]

else ss[2] + ss[0]

 

'''The Task'''

def magicConstant: (.*. + 1) * . / 2;

| (10 | power($i)) as $goal

| ((($goal * 2)|iroot(3) + 1) | floor) as $order

{{out}}

As for [[#Wren|Wren]] except for commatization.

=={{header|Julia}}==

Uses the inverse of the magic constant function for the last part of the task.

 

magic(x) = (1 + x^2) * x ÷ 2

println("10^", string(expo, pad=2), " ", ordr)

end

<pre>

First 20 magic constants: [15, 34, 65, 111, 175, 260, 369, 505, 671, 870, 1105, 1379, 1695, 2056, 2465, 2925, 3439, 4010, 4641, 5335]

 

=={{header|Mathematica}}/{{header|Wolfram Language}}==

MagicSumHelper[n_] = Sum[i, {i, n^2}]/n;

MagicSum[n_] := MagicSumHelper[n + 2]

exps = Range[1, 50];

nums = 10^exps;

{{out}}

<pre>{15, 34, 65, 111, 175, 260, 369, 505, 671, 870, 1105, 1379, 1695, 2056, 2465, 2925, 3439, 4010, 4641, 5335}

 

=={{header|Perl}}==

 

use strict; # https://rosettacode.org/wiki/Magic_constant

{

printf "%3d %9d\n", $i, (10 ** $i * 2) ** ( 1 / 3 ) + 1;

{{out}}

<pre>

 

=={{header|Phix}}==

<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</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>

{{out}}

<pre>

=={{header|Prolog}}==

Minimalistic, efficient approach

m(X,Y):- Y is X*(X*X+1)/2.

 

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]))).

{{out}}

<pre>

 

=={{header|Python}}==

 

def a(n):

for e in range(1, 20):

{{out}}

<pre>The first 20 magic constants are:

 

=={{header|Quackery}}==

20 times [ i^ magicconstant echo sp ] cr cr

[ 10 21 ** ] constant

over = until ]

 

{{out}}

=={{header|Raku}}==

 

 

my @magic-constants = lazy (3..∞).hyper.map: { (1 + .²) * $_ / 2 };

say "\nSmallest order magic square with a constant greater than:";

 

{{out}}

<pre>First 20 magic constants: 15 34 65 111 175 260 369 505 671 870 1,105 1,379 1,695 2,056 2,465 2,925 3,439 4,010 4,641 5,335

 

=={{header|Sidef}}==

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

}

for n in (1 .. 20) {

printf("order(10^%-2s) = %s\n", n, order(10**n))

{{out}}

<pre>

{{libheader|Wren-fmt}}

This uses Julia's approach for the final parts.

import "./fmt" for Fmt

var order = (goal * 2).cbrt.floor + 1

Fmt.print("10$-2s : $,9d", superscript.call(i), order)

 

{{out}}

constant, and N rows add to the Sum. Thus the magic constant = Sum/N =

(N^3+N)/2.

real M, Thresh, MC;

[Text(0, "First 20 magic constants:^M^J");

Thresh:= Thresh*10.;

];

 

{{out}}