Klarner-Rado sequence: Difference between revisions

 

Klarner-Rado sequences are a class of similar sequences that were studied by the mathematicians David Klarner and Richard Rado.

 

<br>

 

=={{header|ALGOL 68}}==

Generates the sequence in order. Note that to run this with ALGOL 68G under Windows (and probably Linux), a large heap size must be specified on the command line, e.g.: <code>-heap 1024M</code>.

# - if n is an element, so are 2n + 1 and 3n + 1 #

INT max element = 100 000 000;

FI

OD

{{out}}

<pre>

The millionth element is 54381285

</pre>

 

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

// Klarner-Rado sequence. Nigel Galloway: August 19th., 20

let n=kr()|>Seq.take 1000000|>Array.ofSeq in n|>Array.take 100|>Array.iter(printf "%d "); printfn "\nkr[999] is %d\nkr[9999] is %d\nkr[99999] is %d\nkr[999999] is %d" n.[999] n.[9999] n.[99999] n.[999999]

{{out}}

<pre>

kr[9999] is 157653

kr[99999] is 2911581

</pre>

 

=={{header|FreeBASIC}}==

{{trans|Phix}}

 

Dim As Integer limit = 1e8

If(count Mod 20) = 0 Then Print

Elseif count = np10 Then

Print "The "; Format(count, "#,###,###"); "th Klarner-Rado number is "; Format(i, "#,###,###")

np10 *= 10

End If

Next i

{{out}}

<pre>Same as Phix entry.</pre>

 

=={{header|J}}==

for_i. i.<.-:#b=. (1+y){.0 1 do.

if. i{b do. b=. 1 ((#~ y&>)1+2 3*i)} b end.

end.

I.b

 

1215307

100{.kr7e7

2911581

(1e6-1){kr7e7

 

 

=={{header|Julia}}==

 

function KlarnerRado(N)

foreach(n -> println("The ", format(n, commas=true), "th Klarner-Rado number is ",

format(kr1m[n], commas=true)), [1000, 10000, 100000, 1000000])

<pre>

First 100 Klarner-Rado numbers:

=== Faster version ===

Probably does get an overabundance, but no sorting. `falses()` is implemented as a bit vector, so huge arrays are not needed. From ALGOL.

 

function KlamerRado(N)

foreach(n -> println("The ", format(n, commas=true), "th Klarner-Rado number is ",

format(kr1m[n], commas=true)), [1000, 10000, 100000, 1000000])

 

=={{header|Phix}}==

{{trans|ALGOL_68}}

<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>

<span style="color: #008080;">constant</span> <span style="color: #000000;">limit</span> <span style="color: #0000FF;">=</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;">10_000_000</span><span style="color: #0000FF;">:</span><span style="color: #000000;">100_000_000</span><span style="color: #0000FF;">)</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>

{{out}}

<pre>

</pre>

Unfortunately JavaScript can't quite cope/runs out of memory with a 100 million element sieve, so it only goes to the 10^5th under p2js.

 

=={{header|PL/M}}==

<br>

As PL/M only handles unsigned 8 and 16 bit integers, this only finds the first 1000 elements. This is based on the Algol 68 sample, but as with the VB.NET sample, uses a "bit vector" (here an array of bytes) - as suggested by the Julia sample.

/* - IF N IS AN ELEMENT, SO ARE 2N+1 AND 3N+!, 1 IS AN ELEMENT */

 

END;

 

{{out}}

<pre>

 

=={{header|Python}}==

K = [1]

for i in range(N):

for n in [1000, 10_000, 100_000]:

print(f'The {n :,}th Klarner-Rado number is {kr1m[n-1] :,}')

<pre>

First 100 Klarner-Rado sequence numbers:

 

=== faster version ===

 

def KlarnerRado(N):

for n in [1000, 10_000, 100_000, 1_000_000]:

print(f'The {n :,}th Klarner-Rado number is {kr1m[n-1] :,}')

 

=={{header|Raku}}==

my @klarner-rado = 1;

my @next = x2, x3;

put '';

put (($_».Int».&ordinal».tc »~» ' element: ').List Z~ |(List.new: (Klarner-Rado ($_ »-» 1))».&comma)

{{out}}

<pre>First 100 elements of Klarner-Rado sequence:

One hundred thousandth element: 2,911,581

One millionth element: 54,381,285</pre>

 

=={{header|Visual Basic .NET}}==

Based on the ALGOL 68 sample, but using a "bit vector" (array of integers), as suggested by the Julia sample. Simplifies printing "the powers of ten" elements, as in the Phix sample.

Option Explicit On

 

End Sub

 

{{out}}

<pre>

 

=={{header|Wren}}==

{{libheader|Wren-sort}}

{{libheader|Wren-fmt}}

There's no actual sorting here. The Find class (and its binary search methods) just happen to be in Wren-sort.

import "./fmt" for Fmt

 

for (limit in limits) {

Fmt.print("The $,r element: $,d", limit, kr[limit-1])

 

{{out}}

The 100,000th element: 2,911,581

The 1,000,000th element: 54,381,285

</pre>