Ulam numbers: Difference between revisions

<big><big> u₂ = 2 </big></big>

 

 

 

;Task:

 

 

* &nbsp; [[oeis:A002858|OEIS Ulam numbers]]

<br><br>

 

=={{header|FreeBASIC}}==

ulam(1) = 1 : ulam(2) = 2

 

print 10^i, get_ulam(10^i, ulam())

next i

 

{{out}}

===Version 1===

{{trans|Wren}}

 

import "fmt"

fmt.Println("The", n, "\bth Ulam number is", ulam(n))

}

 

{{out}}

 

Although not shown here, the 100,000th Ulam number (1,351,223) is computed in about 13.5 seconds.

 

import (

}

fmt.Println("\nTook", time.Since(start))

 

{{out}}

 

As mentioned in the Wren version 3 example, you need to know how much memory to allocate in advance.

 

import (

}

fmt.Println("\nTook", time.Since(start))

 

{{out}}

 

===Lazy List===

import Data.List

 

isSingleton as

| length as == 1 = True

 

 

=={{header|Julia}}==

{{trans|Wren}}

ulams = [1, 2]

memoized = Set([1, 2])

@time println("The ", n, "th Ulam number is: ", nthUlam(n))

end

<pre>

The 10th Ulam number is: 18

</pre>

 

 

{{out}}

<pre>

The 1,000th Ulam number is 12,294

The 10,000th Ulam number is 132,788

</pre>

For comparison, Julia took 4.5s (9.3s on repl.it), Go took 4.9s, Wren (on tio) 27s,

Raku (on repl.it) 9mins 50s,

FreeBASIC 17mins 44s, and I cancelled XPL0 (on EXPL32) after 53 minutes.

 

The above algorithm can also yield "The 100,000th Ulam number is 1,351,223" in 1 minute and 40s, for me.

<small>(I fully expect translations of this better algorithm to run even faster, btw)</small>

 

=={{header|Raku}}==

 

 

sub next-ulam {

for 1 .. 4 {

say "The {10**$_}th Ulam number is: ", @ulams[10**$_ - 1]

{{out}}

<pre>The 10th Ulam number is: 18

=={{header|REXX}}==

{{trans|Wren}}

This REXX version has several speed improvements.

parse arg $ /*obtain optional argument from the CL.*/

if $='' | $="," then $= 10 100 1000 10000 /*Not specified? Then use the defaults.*/

say 'the ' commas(#)th(#) ' Ulam number is: ' commas(x)

end /*k*/

exit 0 /*stick a fork in it, we're all done. */

/*──────────────────────────────────────────────────────────────────────────────────────*/

th: parse arg th; return word('th st nd rd', 1 + (th//10)*(th//100%10\==1)*(th//10<4))

/*──────────────────────────────────────────────────────────────────────────────────────*/

z= 3 /*value of next possible term in seq. */

do until #==n

cnt= 0

end

end /*j*/

 

end

end /*until*/

{{out|output|text=&nbsp; when using the default input of: &nbsp; &nbsp; <tt> 10 &nbsp; 100 &nbsp; 1000 &nbsp; 10000 </tt>}}

<pre>

 

=={{header|Ring}}==

load "stdlib.ring"

 

ok

next

Output:

<pre>

The 1000th Ulam number is: 12294

The 10000th Ulam number is: 132788

</pre>

 

===Version 1===

{{libheader|Wren-set}}

 

var ulam = Fn.new() { |n|

System.print("The %(n)th Ulam number is %(ulam.call(n))")

if (n == 10000) break

 

{{out}}

{{libheader|Wren-fmt}}

The above version is reasonably efficient and runs in about 21.6 seconds on my machine (Intel Core i7-8565U). The following version, which builds up a sieve as it goes along, is more than 3 times faster.

 

var ulam = Fn.new { |n|

Fmt.print("The $,r Ulam number is $,d", n, ulam.call(n))

}

 

{{out}}

 

The only downside with this version is that you need to know how much memory to allocate in advance.

 

var ulam = Fn.new { |n|

if (n > 100000) break

}

 

{{out}}

Ulam number in 24.7 seconds on a Pi4.

 

int N;

def Max = 1_352_000; \enough for 100_000th Ulam number

if T <= 2 then Sums(Sum):= T;

];

];

until Size >= N;

return Query;

N:= N*10;

until N > 100_000;

 

{{out}}