Recaman's sequence: Difference between revisions

{{trans|Python}}

‘The successor for a given Recaman term,

given the set of Recaman terms seen so far.’

print("First duplicated Recaman:\n "recamanUntil((seen, n, r, blnNew) -> !blnNew).last)

V setK = Set(enumFromTo(0)(1000))

{{out}}

=={{header|ALGOL W}}==

% calculate Recaman's sequence values %

end

{{out}}

<pre>

=={{header|APL}}==

{{works with|Dyalog APL}}

genNext←{

R←⍵[N-1]-N←≢⍵

⎕←'Length of sequence containing [0..1000]:'

⎕←≢reca←genNext⍣{(⍳1001)∧.∊⊂⍺}⊢reca

{{out}}

The third of these tasks probably stretches Applescript a bit beyond the point of its usefulness – it takes about 1 minute to find the result, and even that requires the use of NSMutableSet, from the Apple Foundation classes.

use framework "Foundation"

use scripting additions

on unwords(xs)

intercalateS(space, xs)

{{Out}}

<pre>First 15 Recamans:

=={{header|Arturo}}==

{{trans|Python}}

back: r - n

(or? 0 > back contains? seen back)? -> n + r

print ""

print "First duplicate Recaman number:"

{{out}}

=={{header|AWK}}==

# syntax: GAWK -f RECAMANS_SEQUENCE.AWK

# converted from Microsoft Small Basic

exit(0)

}

{{out}}

<pre>

=={{header|BASIC}}==

20 PRINT "First 15 terms:"

30 FOR N=0 TO 14: GOSUB 100: PRINT A(N);: NEXT

140 NEXT

150 A(N)=X: RETURN

{{out}}

=={{header|BCPL}}==

// Generate the N'th term of the Recaman sequence

writef("a!%N = %N*N", rep, a!rep)

{{out}}

<pre>First 15 members:

{{libheader|GLib}}

{{trans|Go}}

#include <stdlib.h>

#include <gmodule.h>

free(a);

return 0;

{{out}}

=={{header|C sharp|C#}}==

{{trans|Kotlin}}

using System.Collections.Generic;

}

}

{{out}}

<pre>The first 15 terms of the Recaman sequence are: [0, 1, 3, 6, 2, 7, 13, 20, 12, 21, 11, 22, 10, 23, 9]

=={{header|C++}}==

{{trans|C#}}

#include <ostream>

#include <set>

return 0;

{{out}}

<pre>The first 15 terms of the Recaman sequence are: [0, 1, 3, 6, 2, 7, 13, 20, 12, 21, 11, 22, 10, 23, 9]

=={{header|CLU}}==

recaman = cluster is new, fetch

rep = array[int]

|| int$unparse(n))

end

{{out}}

<pre>First 15 items: 0 1 3 6 2 7 13 20 12 21 11 22 10 23 9

=={{header|Comal}}==

0020 //

0030 // Print the first 15 items

0250 RETURN 0

0260 ENDFUNC find#

{{out}}

<pre>First 15 items: 0 1 3 6 2 7 13 20 12 21 11 22 10 23 9

=={{header|COBOL}}==

PROGRAM-ID. RECAMAN.

COLLATE-ITEM.

MOVE A(I) TO OUTN.

{{out}}

<pre>First 15 items: 0 1 3 6 2 7 13 20 12 21 11 22 10 23 9

=={{header|D}}==

{{trans|Kotlin}}

void main() {

n++;

}

{{out}}

<pre>The first 15 terms of the Recaman sequence are: [0, 1, 3, 6, 2, 7, 13, 20, 12, 21, 11, 22, 10, 23, 9]

=={{header|Draco}}==

word i;

bool found;

while not find(A, i, gen_next(A, i)) do i := i + 1 od;

writeln("First repeated item: A(", i:2, ") = ", A[i]:2)

{{out}}

<pre>First 15 items: 0 1 3 6 2 7 13 20 12 21 11 22 10 23 9

{{works with|gforth|0.7.3}}

create cells allot

does> swap cells + ;

100 sequence-gen

15 sequence.

{{out}}

=={{header|FreeBASIC}}==

' compile with: fbc -s console

Print : Print "hit any key to end program"

Sleep

{{out}}

<pre>The first 15 terms are 0 0 1 3 6 2 7 13 20 12 21 11 22 10 23 9

=={{header|FOCAL}}==

01.20 F N=0,14;D 2;T %2,A(N)

01.30 T !"FIRST REPEATED"

02.50 I (Y)2.6,2.7,2.6

02.60 S A(N)=X;R

{{out}}

=={{header|Go}}==

import "fmt"

}

}

{{out}}

===Recursion===

A basic recursive function for the first N terms,

recaman n = fst <$> reverse (go n)

where

main :: IO ()

{{Out}}

<pre>[0,1,3,6,2,7,13,20,12,21,11,22,10,23,9]</pre>

Or, a little more flexibly, a '''recamanUpto''' (predicate) function.

{{Trans|JavaScript}}

import Data.Bool (bool)

, "Length of Recaman series required to include [0..1000]:"

, (show . length . recamanSuperset) $ fromList [0 .. 1000]

{{Out}}

<pre>First 15 Recamans:

For the third task, it would be enough to search through an infinite stream of Recaman-generated integer '''sets''' of increasing size, until we find the first that contains [0..1000] as a subset.

import Data.Maybe (fromJust)

import Data.Set (Set, fromList, insert, isSubsetOf, member)

"Length of Recaman series required to include [0..1000]:",

show . fromJust $ findIndex (\(setR, _) -> isSubsetOf setK setR) rSets

{{Out}}

<pre>First 15 Recamans:

</pre>

Let's write a binary search adverb.

average =: +/ % #

NB. extra_data u Bsearch bounds

NB. u is invoked as a dyad

Bsearch =: 1 :'((0 1 + (u <.@:average)) { ({. , <.@:average, {:)@:])^:_'

<pre>

NB. f expresses "not all [0, 1000] are in the first y members of list x"

=={{header|Java}}==

{{Trans|Kotlin}}

import java.util.HashSet;

import java.util.List;

}

}

{{out}}

<pre>The first 15 terms of the Recaman sequence are : [0, 1, 3, 6, 2, 7, 13, 20, 12, 21, 11, 22, 10, 23, 9]

=={{header|JavaScript}}==

{{Trans|Haskell}}

const main = () => {

// MAIN ------------------------------------------------

return main();

{{Out}}

<pre>First 15 Recaman:

the main function only retains the first few elements of the sequence

required to print them as an array.

# Let R[n] be the Recaman sequence, n >= 0, so R[0]=0.

# Input: a number, $required, specifying the required range of integers, [1 .. $required]

| "The first \($capture) terms of Recaman's sequence are: \(.a)",

"The first duplicated term is a[\(.foundDupAt)] = \(.foundDup)",

{{out}}

<pre>

</pre>

=== A stream-oriented solution===

# Output: the stream of elements in the Recaman sequence, beginning with 0.

def recaman:

else .

end;

'''The three tasks:'''

"First 15:", limit(15; recaman),

"\Index of first element to include 0 to 1000 inclusive:",

(1000|covers(recaman))

{{out}}

<pre>

=={{header|Julia}}==

{{trans|Go}}

a = Vector{Int}([0])

used = Dict{Int, Bool}(0 => true)

recaman()

The first 15 terms of the Recaman sequence are [0, 1, 3, 6, 2, 7, 13, 20, 12, 21, 11, 22, 10, 23, 9]

The first duplicated term is a[25] = 42.

=={{header|Kotlin}}==

{{trans|Go}}

fun main(args: Array<String>) {

n++

}

{{output}}

This runs out of memory determining the final part :(

{{trans|C++}}

local used = {[0]=true}

local used1000 = {[0]=true}

end

n = n + 1

{{out}}

<pre>The first 15 terms of the Recaman sequence are: 0 1 3 6 2 7 13 20 12 21 11 22 10 23 9

=={{header|MAD}}==

VECTOR VALUES ELEMF = $2HA(,I2,4H) = ,I2*$

DIMENSION A(100)

FUNCTION RETURN A(N)

END OF FUNCTION

{{out}}

<pre>FIRST 15 ELEMENTS

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

f[s_List] := Block[{a = s[[-1]], len = Length@s},

Append[s, If[a > len && ! MemberQ[s, a - len], a - len, a + len]]]; g = Nest[f, {0}, 70]

p = Select[Tally[g], Last /* EqualTo[2]][[All, 1]]

p = Flatten[Position[g, #]] & /@ p;

{{out}}

<pre>{0,1,3,6,2,7,13,20,12,21,11,22,10,23,9}

=={{header|Microsoft Small Basic}}==

Inefficency of associative array allocation in Small Basic ban to provide the optional task.

nn=15

TextWindow.WriteLine("Recaman's sequence for the first " + nn + " numbers:")

EndFor

exitsub:

{{out}}

<pre>

=={{header|Nim}}==

iterator recaman(num: Positive = Natural.high): tuple[n, a: int; duplicate: bool] =

if target.card == 0:

echo "All numbers from 0 to 1000 generated after $1 terms.".format(n)

{{out}}

=={{header|Objeck}}==

{{trans|Java}}

class RecamanSequence {

return out;

}

{{output}}

=={{header|Perl}}==

$max = 1000;

print "First fifteen terms of Recaman's sequence: " . join(' ', @recamans[0..14]) . "\n";

print "First duplicate at term: a[$dup]\n";

{{out}}

<pre>First fifteen terms of Recaman's sequence: 0 1 3 6 2 7 13 20 12 21 11 22 10 23 9

=={{header|Phix}}==

{{trans|D}}

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

<span style="color: #004080;">bool</span> <span style="color: #000000;">found_duplicate</span> <span style="color: #0000FF;">=</span> <span style="color: #004600;">false</span>

<span style="color: #000000;">n</span> <span style="color: #0000FF;">+=</span> <span style="color: #000000;">1</span>

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

{{out}}

<pre>

=={{header|PHP}}==

{{trans|Java}}

$a = array();

array_push($a, 0);

$n++;

}

{{out}}

=={{header|PL/I}}==

declare A(0:30) fixed;

do i=15 repeat(i+1) while(^find(generate(i), i)); end;

put edit('A(',i,') = ',A(i)) (A,F(2),A,F(2));

{{out}}

<pre>First 15 members: 0 1 3 6 2 7 13 20 12 21 11 22 10 23 9

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

BDOS: PROCEDURE(F,A); DECLARE F BYTE, A ADDRESS; GO TO 5; END BDOS;

EXIT: PROCEDURE; CALL BDOS(0,0); END EXIT;

CALL PRINT$STR(.(13,10,'$'));

CALL EXIT;

{{out}}

<pre>FIRST 15 MEMBERS: 0 1 3 6 2 7 13 20 12 21 11 22 10 23 9

=={{header|PureBasic}}==

Dim a.i(#MAX)

Dim b.b(1)

PrintN("Number of Recaman terms needed to generate all integers from [0..1000]: "+Str(fit1000))

Input()

{{out}}

<pre>First 15 terms: 0 1 3 6 2 7 13 20 12 21 11 22 10 23 9

=={{header|Python}}==

===Conditional iteration over a generator===

class Recamans():

if setn.issubset(recamans.a):

print(f"Range 0 ..{n} is covered by terms up to a({recamans.n})")

{{out}}

( This turns out to be c. 8X faster than than the ''iteration over generator'' approach above, on a simple start to end measure using ''time.time()'')

if __name__ == '__main__':

{{Out}}

<pre>First 15 Recaman:

( This version is still c. 8X faster than the ''conditional iteration over generator'' version, as measured by a simple start and end test using ''time.time()'' ).

from itertools import (islice)

# MAIN ---

if __name__ == '__main__':

<pre>First 15 Recaman:

[0, 1, 3, 6, 2, 7, 13, 20, 12, 21, 11, 22, 10, 23, 9]

=={{header|Quackery}}==

[ stack 0 ] is seennumbers ( --> s )

1000 allseen? until ]

nip 1 - echo cr

{{out}}

=={{header|R}}==

A bit slow because the append() function is expensive.

visited <- vector('logical', 1e8)

}

}

{{out}}

<pre>

{{works with|Rakudo|2018.06}}

state %seen;

state $term;

@seen[$this] = 1;

say "Range 0..1000 covered by terms up to a[{$i - 1}]" and last if ++$ == 1001;

{{out}}

<pre>First fifteen terms of Recaman's sequence: 0 1 3 6 2 7 13 20 12 21 11 22 10 23 9

could've been replaced with:

if !.z | z<0 then z= _ + #

parse arg N h . /*obtain optional arguments from the CL*/

if N=='' | N=="," then N= 15 /*Not specified? Then use the default.*/

end

$= $ z /*add number to $ list?*/

{{out|output|text=&nbsp; when using the default input:}}

===version 2===

/*improved using version 1's method for task 3 */

Call time 'R' /* Start timer */

Have.temp=1

End

{{out}}

<pre>the first 15 elements: 0 1 3 6 2 7 13 20 12 21 11 22 10 23 9

=={{header|Ring}}==

load "zerolib.ring"

see "" + dupnr + "] = " + duplicate + nl

see "done..." + nl

{{out}}

<pre>

=={{header|Ruby}}==

{{trans|Kotlin}}

a = [0]

end

n = n + 1

{{out}}

<pre>The first 15 terms of the Recaman's sequence are [0, 1, 3, 6, 2, 7, 13, 20, 12, 21, 11, 22, 10, 23, 9]

=={{header|Scala}}==

{{Out}}Best seen in running your browser either by [https://scalafiddle.io/sf/xjLHy7m/0 ScalaFiddle (ES aka JavaScript, non JVM)] or [https://scastie.scala-lang.org/FdJaIB68S8i5OSndpigBtA Scastie (remote JVM)].

object RecamansSequence extends App {

println(s"The first 15 terms of the Recaman sequence are : ${a.take(15)}")

=={{header|Scheme}}==

{{works with|Chez Scheme}}

; Returns a procedure that takes a variable number of arguments:

; 0 : () --> Returns the vector from index 0 through the maximum index set.

(printf

"Terms of Recaman's sequence to generate all integers 0..~a, inclusive: ~a~%"

{{out}}

<pre>First 15 Recaman's numbers: #(0 1 3 6 2 7 13 20 12 21 11 22 10 23 9)

=={{header|Sidef}}==

var term = 0

}

}

{{out}}

<pre>First 15 terms of the Recaman's sequence: 0, 1, 3, 6, 2, 7, 13, 20, 12, 21, 11, 22, 10, 23, 9

=={{header|uBasic/4tH}}==

Print "First 15 numbers:"

_Poke Param(2) : Return (Or(@(a@), Shl(1, b@)))

_Peek Param(1) : Return (And(@(a@/32), Shl(1, a@%32))>0)

{{out}}

<pre>

{{trans|Rexx}}

To run in console mode with cscript.

nx=15

h=1000

next 'n

recaman=list

{{out}}

<pre>

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

{{trans|C#}}

Imports System.Collections.Generic

Next

End Sub

<pre>The first 15 terms of the Recamán sequence are: (0, 1, 3, 6, 2, 7, 13, 20, 12, 21, 11, 22, 10, 23, 9)

The first duplicated term is a(24) = 42

=={{header|Wren}}==

{{trans|Kotlin}}

var used = { 0: true }

var used1000 = { 0: true }

}

n = n + 1

{{out}}

=={{header|zkl}}==

Walker.tweak(fcn(rn,rp,d){

n,p,a := rn.value, rp.value, p - n;

return(rn.inc(),a,d[a]>1);

}.fp(Ref(0),Ref(0),Dictionary()) )

recamanW().walk(15).apply("get",1).println();

rw,ns,n,a,dup := recamanW(),1000,0,0,0;

do{ n,a,dup=rw.next(); if(not dup and a<1000) ns-=1; }while(ns);

{{out}}

<pre>