Juggler sequence: Difference between revisions

{{trans|Nim}}

 

V a = Int64(n)

V r_count = 0

L(n) 20..39

V (l, h, i) = juggler(n)

 

{{out}}

{{trans|Python}}

 

assert(x >= 0)

 

 

L(k) [113, 173, 193, 2183, 11229, 15065]

 

{{out}}

 

=={{header|Ada}}==

with Ada.Numerics.Generic_Elementary_Functions;

 

begin

Put_Table;

{{out}}

<pre>

===Core language===

Keeping within AppleScript's usable number range:

script o

property sequence : {n}

end task

 

 

{{output}}

21: l[n] = 9, h[n] = 140, i[n] = 4

22: l[n] = 3, h[n] = 22, i[n] = 0

37: l[n] = 17, h[n] = 24906114455136, i[n] = 8

38: l[n] = 3, h[n] = 38, i[n] = 0

 

===Shell script===

One of AppleScript's main roles is telling other software to do things. This includes Unix executables, many of which come with the system. In the following, the 'do shell script' command feeds a script to the Bash shell, which script itself contains code to be passed to and executed by the "bc" executable. It's essentially a script within a script within a script. The text returned from "bc", which can handle larger numbers than core AppleScript, contains lines which are just the zeros returned by the 'juggler' function, so these are stripped out using "sed". The 'do shell script' command is supplied by the StandardAdditions OSAX which comes with the system as a standard AppleScript extension. So ironically, there's not a single command from the core language in the following code. But it's legitimate AppleScript and the input and output are both AppleScript text objects.

 

define juggler(n) {

#auto temp,i,max,pos

juggler(30817); # Another 191 to here.

# juggler(48443) produced no result after running all night.

 

{{output}}

21: l[n] = 9, h[n] = 140, i[n] = 4

22: l[n] = 3, h[n] = 22, i[n] = 0

15065: l[n] = 66, d[n] = 11723, i[n] = 25

15845: l[n] = 139, d[n] = 23889, i[n] = 43

 

=={{header|BQN}}==

Step ← ⌊⊢⋆(0.5 + 2|⊢)

¯1‿0‿0 + 3↑{

}

 

{{out}}

<Pre>┌─

{{trans|Go}}

{{libheader|GMP}}

#include <iomanip>

#include <iostream>

<< '\n';

}

 

{{out}}

=={{header|F_Sharp|F#}}==

This task uses [[Isqrt_(integer_square_root)_of_X#F.23]]

// 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}")

{{out}}

<pre>

=={{header|Factor}}==

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

math.extras math.functions.integer-logs math.order math.ranges

sequences strings tools.memory.private ;

 

{ 113 173 193 2183 11229 15065 15845 30817 }

{{out}}

<pre>

 

The next four record holders for the largest term (see talk page), are also doable but increased the overall time to nearly 24 minutes on my machine.

 

import (

fmt.Printf("%11s %3d %3d %s\n", cn, count, maxCount, rcu.Commatize(digits))

}

 

{{out}}

Integer square root is computed as in [[Isqrt_(integer_square_root)_of_X#Haskell]]

 

import Data.List

 

mapM_ task [20..39]

putStrLn "\nTough guys\n"

 

<pre>n = 20 length = 3 maximal value at = 0 (20)

=={{header|J}}==

 

 

Instead, we take the square root of either the even number or the third power of the odd number:

 

 

Task examples:

 

task=: {{

37: l: 18, h: 24906114455136, i:8

38: l: 4, h: 38, i:0

 

Sadly, J's extended precision implementation is antiquated (slow), hopefully that will be fixed before too long.

 

Still, some of the stretch exercises can be computed quickly:

echo '%d: l: %d, d: %d, i:%d' sprintf y;(#;#@":@(>./);]i.>./)jugx^:a: y

}}

193: l: 74, d: 271, i:47

2183: l: 73, d: 5929, i:32

 

=={{header|jq}}==

The following jq program uses `idivide/1`, `isqrt/0`, and `lpad/1` as defined at

[[Isqrt_(integer_square_root)_of_X#jq]].

. as $n

| if $n < 1 then "juggler starting value must be a positive integer." | error

| fmt(6; 6; 6; 8) );

 

{{out}}

<pre>

 

=={{header|Julia}}==

 

function juggler(k, countdig=true, maxiters=20000)

2264915, 5812827])

@time juggler(7110201)

<pre>

n l(n) i(n) h(n) or d(n)

 

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

 

stats[n_Integer] :=

{TableForm[Table[stats@n, {n, 20, 39}],

 

{{out}}<pre>

=={{header|Nim}}==

Using only standard library, so limited to values of <code>n</code> less than 40.

 

func juggler(n: Positive): tuple[count: int; max: uint64; maxIdx: int] =

for n in 20..39:

let (l, h, i) = juggler(n)

 

{{out}}

 

=={{header|Perl}}==

 

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

printf "%8d %4d %3d d(n) = %d digits\n", $i, $count, $at, length $max;

}

{{out}}

<pre>

{{libheader|Phix/online}}

You can run this online [http://phix.x10.mx/p2js/juggler.htm here].

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

<span style="color: #000000;">main</span><span style="color: #0000FF;">()</span>

{{out}}

<pre>

=={{header|Python}}==

Slowed to a crawl at n of 1267909, so did not run for larger n.

 

def juggler(k, countdig=True, maxiters=1000):

for k in [113, 173, 193, 2183, 11229, 15065, 15845, 30817, 48443, 275485, 1267909]:

juggler(k)

<pre>

n l(n) i(n) h(n) or d(n)

=={{header|Quackery}}==

 

over size -

space swap of

15 recho 2 recho cr ] is stats ( n --> )

 

 

{{out}}

Reaches 30817 fairly quickly but later values suck up enough memory that it starts thrashing the disk cache and performance drops off a cliff (on my system). Killed it after 10 minutes and capped list at 30817. Could rewrite to not try to hold entire sequence in memory at once, but probably not worth it. If you want sheer numeric calculation performance, Raku is probably not where it's at.

 

sub juggler (Int $n where * > 0) { $n, { $_ +& 1 ?? .³.&isqrt !! .&isqrt } … 1 }

 

printf "%10s %4d %4d %10s %6.2f seconds\n", .&comma, +@j-1, @j.first(* == $max, :k),

$max.chars.&comma, (now - $start);

{{out}}

<pre> n l[n] i[n] h[n]

 

Another optimization was to reduce the number of digits after the &nbsp; sqrt &nbsp; was calculated.

numeric digits 20 /*define the number of decimal digits. */

parse arg LO HI list /*obtain optional arguments from the CL*/

if z>mx then do; mx= z; imx= j; end /*found a new max; set MX; set IMX. */

#= z

{{out|output|text=&nbsp; when using the inputs: &nbsp; &nbsp; <tt> , &nbsp; , &nbsp; 113 &nbsp; 173 &nbsp; 193 &nbsp; 2183 &nbsp; 11229 &nbsp; 15065 &nbsp; 30817 &nbsp; 48443 </tt>}}

<pre>

 

=={{header|Ruby}}==

 

(20..39).chain([113, 173, 193, 2183, 11229, 15065, 15845, 30817, 48443, 275485, 1267909, 2264915]).each do |k|

end

end

{{out}}

<pre>20: l[n] = 3, h[n] = 20, i[n] = 0

{{libheader|Wren-big}}

This took just over 17 minutes to reach n = 30,817 on my machine and I gave up after that.

import "/big" for BigInt

 

var res = juggler.call(n)

Fmt.print("$,6d $3d $3d $,6i", n, res[0], res[1], res[3])

 

{{out}}

{{libheader|Wren-gmp}}

Massive speed-up, of course, when one brings in GMP. Now takes about 1 minute 48 seconds to reach 7,110,201 which is not much slower than Go on the same machine!

 

import "./gmp" for Mpz

var res = juggler.call(n)

Fmt.print("$,9d $3d $3d $,i", n, res[0], res[1], res[3])

 

{{out}}