aparler/RosettaCodeData
1
0
Fork 0
Code Issues 12 Pull requests 3 Projects Releases Packages Wiki Activity Actions

Data commit

Browse source
This commit is contained in:
Ingy döt Net 2023-07-01 11:58:00 -04:00
parent 7387c8f97b
commit cb5bb5e222
199093 changed files with 3378972 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

2
Task/Juggler-sequence/00-META.yaml Normal file
View file

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

45
Task/Juggler-sequence/00-TASK.txt Normal file
View file

@ -0,0 +1,45 @@
Background of the   '''juggler sequence''':
Juggler sequences were publicized by an American mathematician and author   [https://en.wikipedia.org/wiki/Clifford_A._Pickover Clifford A. Pickover].   The name of the sequence gets it's name from the similarity of the rising and falling nature of the numbers in the sequences,   much like balls in the hands of a juggler.
;Description
A [https://en.wikipedia.org/wiki/Juggler_sequence juggler sequence] is an integer sequence that starts with a positive integer a[0], with each subsequent term in the sequence being defined by the recurrence relation:
<big> a[k + 1] = floor(a[k] ^ 0.5) if a[k] is even <big> ''' ''or'' ''' </big> </big>
<big> a[k + 1] = floor(a[k] ^ 1.5) if a[k] is odd </big>
If a juggler sequence reaches 1, then all subsequent terms are equal to 1. This is known to be the case for initial terms up to 1,000,000 but it is not known whether all juggler sequences after that will eventually reach 1.
;Task:
Compute and show here the following statistics for juggler sequences with an initial term of a[n] where n is between '''20''' and '''39''' inclusive:
* l[n] - the number of terms needed to reach 1.
* h[n] - the maximum value reached in that sequence.
* i[n] - the index of the term (starting from 0) at which the maximum is (first) reached.
<br>
If your language supports ''big integers'' with an integer square root function, also compute and show here the same statistics for as many as you reasonably can of the following values for n:
113, 173, 193, 2183, 11229, 15065, 15845, 30817, 48443, 275485, 1267909, 2264915, 5812827
Those with fast languages and fast machines may also like to try their luck at n = 7110201.
However, as h[n] for most of these numbers is thousands or millions of digits long, show instead of h[n]:
* d[n] - the number of digits in h[n]
<br>
The results can be (partially) verified against the table [https://web.archive.org/web/20091027053243/http://www.geocities.com/hjsmithh/Juggler/JuggWhat.html here].
;Related tasks:
* &nbsp; [[Hailstone sequence]]
* &nbsp; [[Yellowstone sequence]]
* &nbsp; [[Isqrt_(integer_square_root)_of_X]]
;See also:
* [[oeis:A007320]] Number of steps needed for Juggler sequence started at n to reach 1
* [[oeis:A094716]] Largest value in the Juggler sequence started at n
<br><br>

19
Task/Juggler-sequence/11l/juggler-sequence-1.11l Normal file
View file

@ -0,0 +1,19 @@
F juggler(n)
V a = Int64(n)
V r_count = 0
V r_max = a
V r_maxidx = 0
L a != 1
V f = Float(a)
a = Int64(I a [&] 1 == 0 {sqrt(f)} E f * sqrt(f))
r_count++
I a > r_max
r_max = a
r_maxidx = r_count
R (r_count, r_max, r_maxidx)
print(‘n l[n] h[n] i[n]’)
print(‘------------------------------’)
L(n) 20..39
V (l, h, i) = juggler(n)
print(f:‘{n} {l:2} {h:14} {i}’)

37
Task/Juggler-sequence/11l/juggler-sequence-2.11l Normal file
View file

@ -0,0 +1,37 @@
F isqrt(BigInt x)
assert(x >= 0)
V q = BigInt(1)
L q <= x
q *= 4
V z = x
V r = BigInt(0)
L q > 1
q I/= 4
V t = z - r - q
r I/= 2
I t >= 0
z = t
r += q
R r
F juggler(k, countdig = 1B, maxiters = 1000)
V (m, maxj, maxjpos) = (BigInt(k), BigInt(k), 0)
L(i) 1 .< maxiters
m = I m % 2 == 0 {isqrt(m)} E isqrt(m * m * m)
I m >= maxj
(maxj, maxjpos) = (m, i)
I m == 1
print(f:‘{k:9}{commatize(i):6}{maxjpos:6}{commatize(I countdig {String(maxj).len} E maxj):20}{I countdig {‘ digits’} E ‘’}’)
R i
print(‘ERROR: Juggler series starting with ’k‘ did not converge in ’maxiters‘ iterations’)
print(" n l(n) i(n) h(n) or d(n)\n-------------------------------------------")
L(k) 20..39
juggler(k, 0B)
L(k) [113, 173, 193, 2183, 11229, 15065]
juggler(k)

78
Task/Juggler-sequence/Ada/juggler-sequence.ada Normal file
View file

@ -0,0 +1,78 @@
with Ada.Text_IO;
with Ada.Numerics.Generic_Elementary_Functions;
procedure Juggler is
subtype Number is Long_Long_Integer;
type Index_Type is new Natural;
subtype Initial_Values is Number range 20 .. 39;
generic
Initial : Number;
package Generic_Juggler is
procedure Next (Value : out Number; Index : out Index_Type);
end Generic_Juggler;
package body Generic_Juggler is
type Real is new Long_Long_Float;
package Real_Math is
new Ada.Numerics.Generic_Elementary_Functions (Real);
K : Index_Type := 0;
A_K : Real := Real (Initial);
procedure Next (Value : out Number; Index : out Index_Type) is
use Real_Math;
begin
Value := Number (A_K);
Index := K;
A_K := (if Number (A_K) mod 2 = 0
then Real'Floor (A_K ** 0.5)
else Real'Floor (A_K ** 1.5));
K := K + 1;
end Next;
end Generic_Juggler;
procedure Statistics (N : Number; L_N : out Index_Type;
H_N : out Number; I_N : out Index_Type)
is
package Juggler_Generator is new Generic_Juggler (Initial => N);
use Juggler_Generator;
Value : Number;
begin
H_N := 0;
I_N := 0;
loop
Next (Value, L_N);
if Value > H_N then
H_N := Value;
I_N := L_N;
end if;
exit when Value = 1;
end loop;
end Statistics;
procedure Put_Table is
package Number_IO is new Ada.Text_IO.Integer_IO (Number);
package Index_IO is new Ada.Text_IO.Integer_IO (Index_Type);
use Ada.Text_IO, Number_IO, Index_IO;
L_N : Index_Type;
H_N : Number;
I_N : Index_Type;
begin
Put_Line (" N L(N) H(N) I(N)");
Put_Line ("---------------------------------");
for N in Initial_Values loop
Statistics (N, L_N, H_N, I_N);
Put (N, Width => 3); Put (L_N, Width => 7);
Put (H_N, Width => 16); Put (I_N, Width => 7); New_Line;
end loop;
end Put_Table;
begin
Put_Table;
end Juggler;

48
Task/Juggler-sequence/AppleScript/juggler-sequence-1.applescript Normal file
View file

@ -0,0 +1,48 @@
on juggler(n)
script o
property sequence : {n}
end script
set i to 1
set {max, pos} to {n, i}
repeat until (n = 1)
set n to n ^ (n mod 2 + 0.5) div 1
set end of o's sequence to n
set i to i + 1
if (n > max) then set {max, pos} to {n, i}
end repeat
return {n:n, sequence:o's sequence, |length|:i, max:max, maxPos:pos}
end juggler
on intToText(n)
if (n < 2 ^ 29) then return n as integer as text
set lst to {n mod 10 as integer}
set n to n div 10
repeat until (n = 0)
set beginning of lst to n mod 10 as integer
set n to n div 10
end repeat
return join(lst, "")
end intToText
on join(lst, delim)
set astid to AppleScript's text item delimiters
set AppleScript's text item delimiters to delim
set txt to lst as text
set AppleScript's text item delimiters to astid
return txt
end join
on task()
set output to {}
repeat with n from 20 to 39
set {|length|:len, max:max, maxPos:pos} to juggler(n)
set end of output to join({n, ": l[n] = ", len - 1, ", h[n] = ", intToText(max), ", i[n] = ", pos - 1}, "")
end repeat
return join(output, linefeed)
end task
task()

20
Task/Juggler-sequence/AppleScript/juggler-sequence-2.applescript Normal file
View file

@ -0,0 +1,20 @@
"20: l[n] = 3, h[n] = 20, i[n] = 0
21: l[n] = 9, h[n] = 140, i[n] = 4
22: l[n] = 3, h[n] = 22, i[n] = 0
23: l[n] = 9, h[n] = 110, i[n] = 1
24: l[n] = 3, h[n] = 24, i[n] = 0
25: l[n] = 11, h[n] = 52214, i[n] = 3
26: l[n] = 6, h[n] = 36, i[n] = 3
27: l[n] = 6, h[n] = 140, i[n] = 1
28: l[n] = 6, h[n] = 36, i[n] = 3
29: l[n] = 9, h[n] = 156, i[n] = 1
30: l[n] = 6, h[n] = 36, i[n] = 3
31: l[n] = 6, h[n] = 172, i[n] = 1
32: l[n] = 6, h[n] = 36, i[n] = 3
33: l[n] = 8, h[n] = 2598, i[n] = 2
34: l[n] = 6, h[n] = 36, i[n] = 3
35: l[n] = 8, h[n] = 2978, i[n] = 2
36: l[n] = 3, h[n] = 36, i[n] = 0
37: l[n] = 17, h[n] = 24906114455136, i[n] = 8
38: l[n] = 3, h[n] = 38, i[n] = 0
39: l[n] = 14, h[n] = 233046, i[n] = 3"

24
Task/Juggler-sequence/AppleScript/juggler-sequence-3.applescript Normal file
View file

@ -0,0 +1,24 @@
do shell script "echo '
define juggler(n) {
#auto temp,i,max,pos
#scale = 0;
temp = n; i = 0; max = n; pos = i;
while (temp > 1) {
i = i + 1; temp = sqrt(temp ^ (1 + (temp % 2 * 2)));
if (temp > max) { max = temp; pos = i; }
}
if (n < 40) {
print n,\": l[n] = \",i,\", h[n] = \",max, \", i[n] = \",pos,\"\\n\";
} else {
print n,\": l[n] = \",i,\", d[n] = \",length(max), \", i[n] = \",pos,\"\\n\";
}
return;
}
for (n = 20 ; n < 40 ; n++) { juggler(n); }
print \"\\n\";
juggler(113); juggler(173); juggler(193); juggler(2183); juggler(11229); juggler(15065);
juggler(15845); # 91 seconds so far.
juggler(30817); # Another 191 to here.
# juggler(48443) produced no result after running all night.
' | bc | sed -n '/^0$/ !p;'"

29
Task/Juggler-sequence/AppleScript/juggler-sequence-4.applescript Normal file
View file

@ -0,0 +1,29 @@
"20: l[n] = 3, h[n] = 20, i[n] = 0
21: l[n] = 9, h[n] = 140, i[n] = 4
22: l[n] = 3, h[n] = 22, i[n] = 0
23: l[n] = 9, h[n] = 110, i[n] = 1
24: l[n] = 3, h[n] = 24, i[n] = 0
25: l[n] = 11, h[n] = 52214, i[n] = 3
26: l[n] = 6, h[n] = 36, i[n] = 3
27: l[n] = 6, h[n] = 140, i[n] = 1
28: l[n] = 6, h[n] = 36, i[n] = 3
29: l[n] = 9, h[n] = 156, i[n] = 1
30: l[n] = 6, h[n] = 36, i[n] = 3
31: l[n] = 6, h[n] = 172, i[n] = 1
32: l[n] = 6, h[n] = 36, i[n] = 3
33: l[n] = 8, h[n] = 2598, i[n] = 2
34: l[n] = 6, h[n] = 36, i[n] = 3
35: l[n] = 8, h[n] = 2978, i[n] = 2
36: l[n] = 3, h[n] = 36, i[n] = 0
37: l[n] = 17, h[n] = 24906114455136, i[n] = 8
38: l[n] = 3, h[n] = 38, i[n] = 0
39: l[n] = 14, h[n] = 233046, i[n] = 3
113: l[n] = 16, d[n] = 27, i[n] = 9
173: l[n] = 32, d[n] = 82, i[n] = 17
193: l[n] = 73, d[n] = 271, i[n] = 47
2183: l[n] = 72, d[n] = 5929, i[n] = 32
11229: l[n] = 101, d[n] = 8201, i[n] = 54
15065: l[n] = 66, d[n] = 11723, i[n] = 25
15845: l[n] = 139, d[n] = 23889, i[n] = 43
30817: l[n] = 93, d[n] = 45391, i[n] = 39"

9
Task/Juggler-sequence/BQN/juggler-sequence.bqn Normal file
View file

@ -0,0 +1,9 @@
Juggle ← {
Step ← ⌊⊢⋆(0.5 + 2|⊢)
¯1‿0‿0 + 3↑{
n‿imax‿max‿term ← 𝕩
𝕊⍟(term≠1) ⟨n+1, (max<term)⊑imax‿n, max⌈term, Step term⟩
} 0‿0‿0‿𝕩
}
>⟨"NLIH"⟩ ∾ (⊢∾Juggle)¨ 20+↕20

49
Task/Juggler-sequence/C++/juggler-sequence.cpp Normal file
View file

@ -0,0 +1,49 @@
#include <cassert>
#include <iomanip>
#include <iostream>
#include <string>
#include <gmpxx.h>
using big_int = mpz_class;
auto juggler(int n) {
assert(n >= 1);
int count = 0, max_count = 0;
big_int a = n, max = n;
while (a != 1) {
if (a % 2 == 0)
a = sqrt(a);
else
a = sqrt(big_int(a * a * a));
++count;
if (a > max) {
max = a;
max_count = count;
}
}
return std::make_tuple(count, max_count, max, max.get_str().size());
}
int main() {
std::cout.imbue(std::locale(""));
std::cout << "n l[n] i[n] h[n]\n";
std::cout << "--------------------------------\n";
for (int n = 20; n < 40; ++n) {
auto [count, max_count, max, digits] = juggler(n);
std::cout << std::setw(2) << n << " " << std::setw(2) << count
<< " " << std::setw(2) << max_count << " " << max
<< '\n';
}
std::cout << '\n';
std::cout << " n l[n] i[n] d[n]\n";
std::cout << "----------------------------------------\n";
for (int n : {113, 173, 193, 2183, 11229, 15065, 15845, 30817, 48443,
275485, 1267909, 2264915, 5812827, 7110201, 56261531,
92502777, 172376627, 604398963}) {
auto [count, max_count, max, digits] = juggler(n);
std::cout << std::setw(11) << n << " " << std::setw(3) << count
<< " " << std::setw(3) << max_count << " " << digits
<< '\n';
}
}

4
Task/Juggler-sequence/F-Sharp/juggler-sequence.fs Normal file
View file

@ -0,0 +1,4 @@
// Juggler sequence. Nigel Galloway: August 19th., 2021
let J n=Seq.unfold(fun(n,i,g,l)->if n=1I then None else let e=match n.IsEven with true->Isqrt n |_->Isqrt(n**3) in Some((i,g,l),if e>i then (e,e,l+1,l+1) else (e,i,g,l+1)))(n,n,0,0)|>Seq.last
printfn " n l[n] i[n] h[n]\n___________________"; [20I..39I]|>Seq.iter(fun n->let i,g,l=J n in printfn $"%d{int n}%5d{l+1}%5d{g} %A{i}")
printfn " n l[n] i[n] d[n]\n________________________"; [113I;173I;193I;2183I;11229I;15065I;15845I;30817I]|>Seq.iter(fun n->let i,g,l=J n in printfn $"%8d{int n}%5d{l+1}%5d{g} %d{(bigint.Log10>>int>>(+)1) i}")

38
Task/Juggler-sequence/Factor/juggler-sequence.factor Normal file
View file

@ -0,0 +1,38 @@
USING: combinators formatting generalizations io kernel math
math.extras math.functions.integer-logs math.order math.ranges
sequences strings tools.memory.private ;
: next ( m -- n )
dup odd? [ dup dup * * ] when integer-sqrt ;
: new-max ( l i h a -- l i h a )
[ drop dup ] 2dip nip dup ;
: (step) ( l i h a -- l i h a )
[ 1 + ] 3dip 2dup < [ new-max ] when next ;
: step ( l i h a -- l i h a )
dup 1 = [ (step) ] unless ;
: juggler ( n quot: ( h -- obj ) -- l i h )
[ 0 0 ] [ dup [ step ] to-fixed-point drop ] [ call ] tri*
[ 1 [-] ] dip ; inline
CONSTANT: fmt "%-8s %-8s %-8s %s\n"
: row. ( n quot -- )
dupd juggler [ commas ] 4 napply fmt printf ; inline
: dashes. ( n -- )
CHAR: - <string> print ;
: header. ( str -- )
[ "n" "l[n]" "i[n]" ] dip fmt printf 45 dashes. ;
: juggler. ( seq quot str -- )
header. [ row. ] curry each ; inline
20 39 [a,b] [ ] "h[n]" juggler. nl
{ 113 173 193 2183 11229 15065 15845 30817 }
[ integer-log10 1 + ] "d[n]" juggler.

61
Task/Juggler-sequence/Go/juggler-sequence.go Normal file
View file

@ -0,0 +1,61 @@
package main
import (
"fmt"
"log"
//"math/big"
big "github.com/ncw/gmp"
"rcu"
)
var zero = new(big.Int)
var one = big.NewInt(1)
var two = big.NewInt(2)
func juggler(n int64) (int, int, *big.Int, int) {
if n < 1 {
log.Fatal("Starting value must be a positive integer.")
}
count := 0
maxCount := 0
a := big.NewInt(n)
max := big.NewInt(n)
tmp := new(big.Int)
for a.Cmp(one) != 0 {
if tmp.Rem(a, two).Cmp(zero) == 0 {
a.Sqrt(a)
} else {
tmp.Mul(a, a)
tmp.Mul(tmp, a)
a.Sqrt(tmp)
}
count++
if a.Cmp(max) > 0 {
max.Set(a)
maxCount = count
}
}
return count, maxCount, max, len(max.String())
}
func main() {
fmt.Println("n l[n] i[n] h[n]")
fmt.Println("-----------------------------------")
for n := int64(20); n < 40; n++ {
count, maxCount, max, _ := juggler(n)
cmax := rcu.Commatize(int(max.Int64()))
fmt.Printf("%2d %2d %2d %s\n", n, count, maxCount, cmax)
}
fmt.Println()
nums := []int64{
113, 173, 193, 2183, 11229, 15065, 15845, 30817, 48443, 275485, 1267909,
2264915, 5812827, 7110201, 56261531, 92502777, 172376627, 604398963,
}
fmt.Println(" n l[n] i[n] d[n]")
fmt.Println("-------------------------------------")
for _, n := range nums {
count, maxCount, _, digits := juggler(n)
cn := rcu.Commatize(int(n))
fmt.Printf("%11s %3d %3d %s\n", cn, count, maxCount, rcu.Commatize(digits))
}
}

23
Task/Juggler-sequence/Haskell/juggler-sequence.hs Normal file
View file

@ -0,0 +1,23 @@
import Text.Printf
import Data.List
juggler :: Integer -> [Integer]
juggler = takeWhile (> 1) . iterate (\x -> if odd x
then isqrt (x*x*x)
else isqrt x)
task :: Integer -> IO ()
task n = printf s n (length ns + 1) (i :: Int) (showMax m)
where
ns = juggler n
(m, i) = maximum $ zip ns [0..]
s = "n = %d length = %d maximal value at = %d (%s)\n"
showMax n = let s = show n
in if n > 10^100
then show (length s) ++ " digits"
else show n
main = do
mapM_ task [20..39]
putStrLn "\nTough guys\n"
mapM_ task [ 113, 173, 193, 2183, 11229, 15065, 15845, 30817 ]

1
Task/Juggler-sequence/J/juggler-sequence-1.j Normal file
View file

@ -0,0 +1 @@
jug=: <.@^ 0.5+2|]

1
Task/Juggler-sequence/J/juggler-sequence-2.j Normal file
View file

@ -0,0 +1 @@
jugx=: <.@%:@(^ 1x+2*2|])

27
Task/Juggler-sequence/J/juggler-sequence-3.j Normal file
View file

@ -0,0 +1,27 @@
require'format/printf'
task=: {{
echo '%d: l: %d, h: %d, i:%d' sprintf y;(#;>./;]i.>./)jugx^:a: y
}}
task"0(+i.)20
20: l: 4, h: 20, i:0
21: l: 10, h: 140, i:4
22: l: 4, h: 22, i:0
23: l: 10, h: 110, i:1
24: l: 4, h: 24, i:0
25: l: 12, h: 52214, i:3
26: l: 7, h: 36, i:3
27: l: 7, h: 140, i:1
28: l: 7, h: 36, i:3
29: l: 10, h: 156, i:1
30: l: 7, h: 36, i:3
31: l: 7, h: 172, i:1
32: l: 7, h: 36, i:3
33: l: 9, h: 2598, i:2
34: l: 7, h: 36, i:3
35: l: 9, h: 2978, i:2
36: l: 4, h: 36, i:0
37: l: 18, h: 24906114455136, i:8
38: l: 4, h: 38, i:0
39: l: 15, h: 233046, i:3

10
Task/Juggler-sequence/J/juggler-sequence-4.j Normal file
View file

@ -0,0 +1,10 @@
taskx=: {{
echo '%d: l: %d, d: %d, i:%d' sprintf y;(#;#@":@(>./);]i.>./)jugx^:a: y
}}
taskx"0(113 173 193 2183 11229)
113: l: 17, d: 27, i:9
173: l: 33, d: 82, i:17
193: l: 74, d: 271, i:47
2183: l: 73, d: 5929, i:32
11229: l: 102, d: 8201, i:54

42
Task/Juggler-sequence/Jq/juggler-sequence.jq Normal file
View file

@ -0,0 +1,42 @@
def juggler:
. as $n
| if $n < 1 then "juggler starting value must be a positive integer." | error
else { a: $n, count: 0, maxCount: 0, max: $n }
| until (.a == 1;
if .a % 2 == 0 then .a |= isqrt
else .a = ((.a * .a * .a)|isqrt)
end
| .count += 1
| if .a > .max
then .max = .a
| .maxCount = .count
else .
end)
| [.count, .maxCount, .max, (.max|tostring|length)]
end
;
def fmt(a;b;c;d):
"\(.[0]|lpad(a)) \(.[1]|lpad(b)) \(.[2]|lpad(c)) \(.[3]|lpad(d))" ;
def task1:
"n l[n] i[n] h[n]",
"-----------------------------------",
(range(20; 40)
| . as $n
| juggler as $res
| [$n, $res[0], $res[1], $res[2] ]
| fmt(4;4;4;14) ) ;
def task2:
def nums:[113, 173, 193, 2183, 11229, 15065, 15845, 30817];
" n l[n] i[n] d[n]",
"-----------------------------",
(nums[]
| . as $n
| juggler as $res
| [$n, $res[0], $res[1], $res[3] ]
| fmt(6; 6; 6; 8) );
task1, "", task2

24
Task/Juggler-sequence/Julia/juggler-sequence.julia Normal file
View file

@ -0,0 +1,24 @@
using Formatting
function juggler(k, countdig=true, maxiters=20000)
m, maxj, maxjpos = BigInt(k), BigInt(k), BigInt(0)
for i in 1:maxiters
m = iseven(m) ? isqrt(m) : isqrt(m*m*m)
if m >= maxj
maxj, maxjpos = m, i
end
if m == 1
println(lpad(k, 9), lpad(i, 6), lpad(maxjpos, 6), lpad(format(countdig ?
ndigits(maxj) : Int(maxj), commas=true), 20), countdig ? " digits" : "")
return i
end
end
error("Juggler series starting with $k did not converge in $maxiters iterations")
end
println(" n l(n) i(n) h(n) or d(n)\n------------------------------------------")
foreach(k -> juggler(k, false), 20:39)
@time foreach(juggler,
[113, 173, 193, 2183, 11229, 15065, 15845, 30817, 48443, 275485, 1267909,
2264915, 5812827])
@time juggler(7110201)

10
Task/Juggler-sequence/Mathematica/juggler-sequence.math Normal file
View file

@ -0,0 +1,10 @@
next[n_Integer] := If[EvenQ@n, Floor[Sqrt[n]], Floor[n^(3/2)]]
stats[n_Integer] :=
Block[{data = Most@NestWhileList[next, n, # > 1 &], mx},
mx = First@Ordering[data, -1];
{n, Length[data], data[[mx]], mx - 1}]
{TableForm[Table[stats@n, {n, 20, 39}],
TableHeadings -> {None, {"n", "length", "max", "max pos"}}]

19
Task/Juggler-sequence/Nim/juggler-sequence.nim Normal file
View file

@ -0,0 +1,19 @@
import math, strformat
func juggler(n: Positive): tuple[count: int; max: uint64; maxIdx: int] =
var a = n.uint64
result = (0, a, 0)
while a != 1:
let f = float(a)
a = if (a and 1) == 0: sqrt(f).uint64
else: uint64(f * sqrt(f))
inc result.count
if a > result.max:
result.max = a
result.maxIdx = result.count
echo "n l[n] h[n] i[n]"
echo "——————————————————————————————"
for n in 20..39:
let (l, h, i) = juggler(n)
echo &"{n} {l:2} {h:14} {i}"

32
Task/Juggler-sequence/Perl/juggler-sequence.pl Normal file
View file

@ -0,0 +1,32 @@
#!/usr/bin/perl
use strict; # https://rosettacode.org/wiki/Juggler_sequence
use warnings;
use Math::BigInt lib => 'GMP';
print " n l(n) i(n) h(n) or d(n)\n";
print " ------- ---- ---- ------------\n";
for my $i ( 20 .. 39,
113, 173, 193, 2183, 11229, 15065, 15845, 30817,
48443, 275485, 1267909, 2264915, 5812827,
7110201 # tried my luck, luck takes about 94 seconds
)
{
my $max = my $n = Math::BigInt->new($i);
my $at = my $count = 0;
while( $n > 1 )
{
$n = sqrt( $n & 1 ? $n ** 3 : $n );
$count++;
$n > $max and ($max, $at) = ($n, $count);
}
if( length $max < 27 )
{
printf "%8d %4d %3d %s\n", $i, $count, $at, $max;
}
else
{
printf "%8d %4d %3d d(n) = %d digits\n", $i, $count, $at, length $max;
}
}

52
Task/Juggler-sequence/Phix/juggler-sequence.phix Normal file
View file

@ -0,0 +1,52 @@
(phixonline)-->
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</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: #008080;">function</span> <span style="color: #000000;">juggler</span><span style="color: #0000FF;">(</span><span style="color: #004080;">integer</span> <span style="color: #000000;">n</span><span style="color: #0000FF;">,</span> <span style="color: #004080;">bool</span> <span style="color: #000000;">bDigits</span><span style="color: #0000FF;">=</span><span style="color: #004600;">false</span><span style="color: #0000FF;">)</span>
<span style="color: #004080;">atom</span> <span style="color: #000000;">t0</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">time</span><span style="color: #0000FF;">(),</span> <span style="color: #000000;">t1</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">time</span><span style="color: #0000FF;">()+</span><span style="color: #000000;">1</span>
<span style="color: #7060A8;">assert</span><span style="color: #0000FF;">(</span><span style="color: #000000;">n</span><span style="color: #0000FF;">>=</span><span style="color: #000000;">1</span><span style="color: #0000FF;">)</span>
<span style="color: #004080;">mpz</span> <span style="color: #000000;">a</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">mpz_init</span><span style="color: #0000FF;">(</span><span style="color: #000000;">n</span><span style="color: #0000FF;">),</span>
<span style="color: #000000;">h</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">mpz_init</span><span style="color: #0000FF;">(</span><span style="color: #000000;">n</span><span style="color: #0000FF;">)</span>
<span style="color: #004080;">integer</span> <span style="color: #000000;">l</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">0</span><span style="color: #0000FF;">,</span>
<span style="color: #000000;">hi</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">0</span>
<span style="color: #008080;">while</span> <span style="color: #7060A8;">mpz_cmp_si</span><span style="color: #0000FF;">(</span><span style="color: #000000;">a</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: #008080;">do</span>
<span style="color: #008080;">if</span> <span style="color: #7060A8;">mpz_odd</span><span style="color: #0000FF;">(</span><span style="color: #000000;">a</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">then</span>
<span style="color: #7060A8;">mpz_pow_ui</span><span style="color: #0000FF;">(</span><span style="color: #000000;">a</span><span style="color: #0000FF;">,</span><span style="color: #000000;">a</span><span style="color: #0000FF;">,</span><span style="color: #000000;">3</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
<span style="color: #7060A8;">mpz_sqrt</span><span style="color: #0000FF;">(</span><span style="color: #000000;">a</span><span style="color: #0000FF;">,</span><span style="color: #000000;">a</span><span style="color: #0000FF;">)</span>
<span style="color: #000000;">l</span> <span style="color: #0000FF;">+=</span> <span style="color: #000000;">1</span>
<span style="color: #008080;">if</span> <span style="color: #7060A8;">mpz_cmp</span><span style="color: #0000FF;">(</span><span style="color: #000000;">a</span><span style="color: #0000FF;">,</span><span style="color: #000000;">h</span><span style="color: #0000FF;">)></span><span style="color: #000000;">0</span> <span style="color: #008080;">then</span>
<span style="color: #7060A8;">mpz_set</span><span style="color: #0000FF;">(</span><span style="color: #000000;">h</span><span style="color: #0000FF;">,</span><span style="color: #000000;">a</span><span style="color: #0000FF;">)</span>
<span style="color: #000000;">hi</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">l</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
<span style="color: #008080;">if</span> <span style="color: #7060A8;">platform</span><span style="color: #0000FF;">()!=</span><span style="color: #004600;">JS</span> <span style="color: #008080;">and</span> <span style="color: #7060A8;">time</span><span style="color: #0000FF;">()></span><span style="color: #000000;">t1</span> <span style="color: #008080;">then</span>
<span style="color: #7060A8;">progress</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"working (l=%d)\r"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">l</span><span style="color: #0000FF;">})</span>
<span style="color: #000000;">t1</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">time</span><span style="color: #0000FF;">()+</span><span style="color: #000000;">1</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">while</span>
<span style="color: #004080;">atom</span> <span style="color: #000000;">hd</span> <span style="color: #0000FF;">=</span> <span style="color: #008080;">iff</span><span style="color: #0000FF;">(</span><span style="color: #000000;">bDigits</span><span style="color: #0000FF;">?</span><span style="color: #7060A8;">mpz_sizeinbase</span><span style="color: #0000FF;">(</span><span style="color: #000000;">h</span><span style="color: #0000FF;">,</span><span style="color: #000000;">10</span><span style="color: #0000FF;">):</span><span style="color: #7060A8;">mpz_get_atom</span><span style="color: #0000FF;">(</span><span style="color: #000000;">h</span><span style="color: #0000FF;">))</span>
<span style="color: #000000;">t0</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">time</span><span style="color: #0000FF;">()-</span><span style="color: #000000;">t0</span>
<span style="color: #004080;">string</span> <span style="color: #000000;">t</span> <span style="color: #0000FF;">=</span> <span style="color: #008080;">iff</span><span style="color: #0000FF;">(</span><span style="color: #000000;">t0</span><span style="color: #0000FF;">>=</span><span style="color: #000000;">1</span><span style="color: #0000FF;">?</span><span style="color: #008000;">" ("</span><span style="color: #0000FF;">&</span><span style="color: #7060A8;">elapsed</span><span style="color: #0000FF;">(</span><span style="color: #000000;">t0</span><span style="color: #0000FF;">)&</span><span style="color: #008000;">")"</span><span style="color: #0000FF;">:</span><span style="color: #008000;">""</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">return</span> <span style="color: #0000FF;">{</span><span style="color: #000000;">n</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">l</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">hd</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">hi</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">t</span><span style="color: #0000FF;">}</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">function</span>
<span style="color: #008080;">procedure</span> <span style="color: #000000;">main</span><span style="color: #0000FF;">()</span>
<span style="color: #004080;">atom</span> <span style="color: #000000;">t0</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">time</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;">" n l[n] h[n] i[n]\n"</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;">"-----------------------------------\n"</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">for</span> <span style="color: #000000;">n</span><span style="color: #0000FF;">=</span><span style="color: #000000;">20</span> <span style="color: #008080;">to</span> <span style="color: #000000;">39</span> <span style="color: #008080;">do</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;">"%2d %2d %,18d %2d %s\n"</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">juggler</span><span style="color: #0000FF;">(</span><span style="color: #000000;">n</span><span style="color: #0000FF;">))</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
<span style="color: #004080;">sequence</span> <span style="color: #000000;">nums</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{</span><span style="color: #000000;">113</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">173</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">193</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">2183</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">11229</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">15065</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">15845</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">30817</span><span style="color: #0000FF;">}</span>
<span style="color: #000080;font-style:italic;">-- alas mpz_sqrt() throws a wobbly over the rest:
-- 48443, 275485, 1267909, 2264915, 5812827, 7110201}</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;">"\n n l[n] d[n] i[n]\n"</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;">"-----------------------------\n"</span><span style="color: #0000FF;">)</span>
<span style="color: #000080;font-style:italic;">-- ... and pwa/p2js(/mpfr.js) only copes with the first 3</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: #008080;">iff</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">platform</span><span style="color: #0000FF;">()=</span><span style="color: #004600;">JS</span><span style="color: #0000FF;">?</span><span style="color: #000000;">3</span><span style="color: #0000FF;">:</span><span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">nums</span><span style="color: #0000FF;">))</span> <span style="color: #008080;">do</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;">"%9d %3d %,6d %2d %s\n"</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">juggler</span><span style="color: #0000FF;">(</span><span style="color: #000000;">nums</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</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>
<span style="color: #0000FF;">?</span><span style="color: #7060A8;">elapsed</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">time</span><span style="color: #0000FF;">()-</span><span style="color: #000000;">t0</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">procedure</span>
<span style="color: #000000;">main</span><span style="color: #0000FF;">()</span>
<!--

21
Task/Juggler-sequence/Python/juggler-sequence.py Normal file
View file

@ -0,0 +1,21 @@
from math import isqrt
def juggler(k, countdig=True, maxiters=1000):
m, maxj, maxjpos = k, k, 0
for i in range(1, maxiters):
m = isqrt(m) if m % 2 == 0 else isqrt(m * m * m)
if m >= maxj:
maxj, maxjpos = m, i
if m == 1:
print(f"{k: 9}{i: 6,}{maxjpos: 6}{len(str(maxj)) if countdig else maxj: 20,}{' digits' if countdig else ''}")
return i
print("ERROR: Juggler series starting with $k did not converge in $maxiters iterations")
print(" n l(n) i(n) h(n) or d(n)\n-------------------------------------------")
for k in range(20, 40):
juggler(k, False)
for k in [113, 173, 193, 2183, 11229, 15065, 15845, 30817, 48443, 275485, 1267909]:
juggler(k)

35
Task/Juggler-sequence/Quackery/juggler-sequence.quackery Normal file
View file

@ -0,0 +1,35 @@
[ dip number$
over size -
space swap of
swap join echo$ ] is recho ( n n --> )
[ 1 & ] is odd ( n --> b )
[ dup dup * * ] is cubed ( n --> n )
[ dup 1
[ 2dup > while
+ 1 >>
2dup / again ]
drop nip ] is sqrt ( n --> n )
[ nested
[ dup -1 peek 1 != while
dup -1 peek
dup odd if cubed
sqrt join again ] ] is juggler ( n --> [ )
[ dup 4 recho
juggler
dup size 1 -
3 recho
0 swap behead swap
witheach
[ 2dup < if
[ rot drop
i^ 1+ unrot
swap ]
drop ]
15 recho 2 recho cr ] is stats ( n --> )
20 times [ i^ 20 + stats ]

57
Task/Juggler-sequence/REXX/juggler-sequence.rexx Normal file
View file

@ -0,0 +1,57 @@
/*REXX program calculates and displays the juggler sequence for any positive integer*/
numeric digits 20 /*define the number of decimal digits. */
parse arg LO HI list /*obtain optional arguments from the CL*/
if LO='' | LO="," then do; LO= 20; HI= 39; end /*Not specified? Then use the default.*/
if HI='' | HI="," then HI= LO /* " " " " " " */
w= length( commas(HI) ) /*find the max width of any number N. */
d= digits(); dd= d + d%3 + 1 /*get # numeric digits; another version*/
if LO>0 then say c('n',w) c("steps",7) c('maxIndex',8) c("biggest term" ,dd)
if LO>0 then say c('' ,w,.) c("" ,7,.) c('' ,8,.) c("" ,dd,.)
do n=LO to HI while n>0; steps= juggler(n) /*invoke JUGGLER: find the juggler num.*/
nc= commas(n) /*maybe add commas to N. */
say right(nc, w) c(steps, 8) c(imx, 8) right( commas(mx), dd-1)
end /*n*/
/*biggest term isn't shown for list #s.*/
xtra= words(list) /*determine how many numbers in list. */
if xtra==0 then exit 0 /*no special ginormous juggler numbers?*/
w= max(9, length( commas( word(list, xtra) ) ) ) /*find the max width of any list number*/
say; say; say
say c('n',w) c("steps",7) c('maxIndex',8) c("max number of digits",dd)
say c('' ,w,.) c("" ,7,.) c('' ,8,.) c("" ,dd,.)
do p=1 for xtra; n= word(list, p) /*process each of the numbers in list. */
steps= juggler(n); nc= commas(n) /*get a number & pass it on to JUGGLER.*/
say right(nc, w) c(steps, 8) c(imx, 8) right( commas(length(mx)), dd-1)
end /*p*/
exit 0 /*stick a fork in it, we're all done. */
/*──────────────────────────────────────────────────────────────────────────────────────*/
c: parse arg c1,c2,c3; if c3=='' then c3= ' '; else c3= '─'; return center(c1,c2,c3)
commas: parse arg ?; do jc=length(?)-3 to 1 by -3; ?=insert(',', ?, jc); end; return ?
/*──────────────────────────────────────────────────────────────────────────────────────*/
Isqrt: procedure; parse arg x; q= 1; r= 0 /*obtain X; R will be the Isqrt(X). */
do until q>x; q= q * 4 /*multiply Q by four until > X. */
end /*until*/
do while q>1; q= q % 4 /*processing while Q>1; quarter Q. */
t= x - r - q; r= r % 2 /*set T ──► X-R-Q; halve R. */
if t>=0 then do; x= t; r= r + q /*T≥0? Then set X ──► T; add Q ──► R.*/
end
end /*while*/; return r /*return the integer square root of X.*/
/*──────────────────────────────────────────────────────────────────────────────────────*/
juggler: parse arg #; imx= 0; mx= # /*get N; set index of MX and MX ──► 0.*/
@.=0; @.1=1; @.3=1; @.5=1; @.7=1; @.9=1 /*set semaphores (≡1) for odd dec. digs*/
do j=1 until z==1 /*here is where we begin to juggle. */
parse var # '' -1 _ /*obtain the last decimal digit of #. */
if @._ then do; cube= #*#*# /*Odd? Then compute integer sqrt(#**3).*/
if pos(., cube)>0 then do /*need to increase decimal digits.*/
parse var cube with 'E' x
if x>=digits() then numeric digits x+2
end
z= Isqrt(#*#*#) /*compute the integer sqrt(#**3) */
end
else z= Isqrt(#) /*Even? Then compute integer sqrt(#). */
L= length(z)
if L>=d then numeric digits L+1 /*reduce the number of numeric digits. */
if z>mx then do; mx= z; imx= j; end /*found a new max; set MX; set IMX. */
#= z
end /*j*/; return j

27
Task/Juggler-sequence/Raku/juggler-sequence.raku Normal file
View file

@ -0,0 +1,27 @@
use Lingua::EN::Numbers;
sub juggler (Int $n where * > 0) { $n, { $_ +& 1 ?? .³.&isqrt !! .&isqrt } … 1 }
sub isqrt ( \x ) { my ( $X, $q, $r, $t ) = x, 1, 0 ;
$q +<= 2 while $q ≤ $X ;
while $q > 1 {
$q +>= 2; $t = $X - $r - $q; $r +>= 1;
if $t ≥ 0 { $X = $t; $r += $q }
}
$r
}
say " n l[n] i[n] h[n]";
for 20..39 {
my @j = .&juggler;
my $max = @j.max;
printf "%2s %4d %4d %s\n", .&comma, +@j-1, @j.first(* == $max, :k), comma $max;
}
say "\n n l[n] i[n] d[n]";
( 113, 173, 193, 2183, 11229, 15065, 15845, 30817 ).hyper(:1batch).map: {
my $start = now;
my @j = .&juggler;
my $max = @j.max;
printf "%10s %4d %4d %10s %6.2f seconds\n", .&comma, +@j-1, @j.first(* == $max, :k),
$max.chars.&comma, (now - $start);
}

16
Task/Juggler-sequence/Ruby/juggler-sequence.rb Normal file
View file

@ -0,0 +1,16 @@
def juggler(k) = k.even? ? Integer.sqrt(k) : Integer.sqrt(k*k*k)
(20..39).chain([113, 173, 193, 2183, 11229, 15065, 15845, 30817, 48443, 275485, 1267909, 2264915]).each do |k|
k1 = k
l = h = i = 0
until k == 1 do
h, i = k, l if k > h
l += 1
k = juggler(k)
end
if k1 < 40 then
puts "#{k1}: l[n] = #{l}, h[n] = #{h}, i[n] = #{i}"
else
puts "#{k1}: l[n] = #{l}, d[n] = #{h.to_s.size}, i[n] = #{i}"
end
end

40
Task/Juggler-sequence/Wren/juggler-sequence-1.wren Normal file
View file

@ -0,0 +1,40 @@
import "/fmt" for Fmt
import "/big" for BigInt
var one = BigInt.one
var juggler = Fn.new { |n|
if (n < 1) Fiber.abort("Starting value must be a positive integer.")
var a = BigInt.new(n)
var count = 0
var maxCount = 0
var max = a.copy()
while (a != one) {
if (a.isEven) {
a = a.isqrt
} else {
a = (a.square * a).isqrt
}
count = count + 1
if (a > max) {
max = a
maxCount = count
}
}
return [count, maxCount, max, max.toString.count]
}
System.print("n l[n] i[n] h[n]")
System.print("-----------------------------------")
for (n in 20..39) {
var res = juggler.call(n)
Fmt.print("$2d $2d $2d $,i", n, res[0], res[1], res[2])
}
System.print()
var nums = [113, 173, 193, 2183, 11229, 15065, 15845, 30817]
System.print(" n l[n] i[n] d[n]")
System.print("----------------------------")
for (n in nums) {
var res = juggler.call(n)
Fmt.print("$,6d $3d $3d $,6i", n, res[0], res[1], res[3])
}

46
Task/Juggler-sequence/Wren/juggler-sequence-2.wren Normal file
View file

@ -0,0 +1,46 @@
/* juggler-gmp.wren */
import "./gmp" for Mpz
import "./fmt" for Fmt
var one = Mpz.one
var juggler = Fn.new { |n|
if (n < 1) Fiber.abort("Starting value must be a positive integer.")
var a = Mpz.from(n)
var count = 0
var maxCount = 0
var max = a.copy()
while (a != one) {
if (a.isEven) {
a.sqrt
} else {
a.cube.sqrt
}
count = count + 1
if (a > max) {
max.set(a)
maxCount = count
}
}
return [count, maxCount, max, max.toString.count]
}
System.print("n l[n] i[n] h[n]")
System.print("-----------------------------------")
for (n in 20..39) {
var res = juggler.call(n)
Fmt.print("$2d $2d $2d $,i", n, res[0], res[1], res[2])
}
System.print()
var nums = [
113, 173, 193, 2183, 11229, 15065, 15845, 30817, 48443,
275485, 1267909, 2264915, 5812827, 7110201
]
System.print(" n l[n] i[n] d[n]")
System.print("-----------------------------------")
for (n in nums) {
var res = juggler.call(n)
Fmt.print("$,9d $3d $3d $,i", n, res[0], res[1], res[3])
}