Juggler sequence: Difference between revisions

 

;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:

 

 

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.

 

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:

 

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

 

 

 

* [[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>

 

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

 

However, when I exchanged that for Go's GMP wrapper there was a massive speed-up (now only 6.4 seconds to reach n = 5,812,827) and even 7,110,201 became viable with an overall time of 1 minute 40 seconds.

 

import (

"fmt"

"log"

big "github.com/ncw/gmp"

"rcu"

fmt.Println()

nums := []int64{

}

for _, n := range nums {

count, maxCount, _, digits := juggler(n)

cn := rcu.Commatize(int(n))

}

 

{{out}}

39 14 3 233,046

 

-----------------------------------

</pre>

 

=={{header|Julia}}==

 

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

for i in 1:maxiters

m = iseven(m) ? isqrt(m) : isqrt(m*m*m)

2264915, 5812827])

@time juggler(7110201)

<pre>

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

7110201 205 119 89,981,517 digits

89.493898 seconds (1.11 M allocations: 27.713 GiB, 1.19% gc time)

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

if( length $max < 27 )

{

}

else

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

}

{{out}}

<pre>

7110201 205 119 d(n) = 89981517 digits

</pre>

 

=={{header|Raku}}==

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>

30,817 93 39 45,391

48,443 157 60 972,463

</pre>

 

=={{header|Wren}}==

{{libheader|Wren-fmt}}

{{libheader|Wren-big}}

 

var one = BigInt.one

 

var juggler = Fn.new { |n|

}

System.print()

System.print(" n l[n] i[n] d[n]")

System.print("----------------------------")

var res = juggler.call(n)

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

 

{{out}}

15,065 66 25 11,723

15,845 139 43 23,889

</pre>