aparler/RosettaCodeData
1
0
Fork 0
Code Issues 12 Pull requests 3 Projects Releases Packages Wiki Activity Actions

Initial data commit

Browse source
This commit is contained in:
Ingy döt Net 2023-07-01 11:58:00 -04:00
parent 72d218235f
commit f23f22d71c
199087 changed files with 3378941 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

2
Task/Van-Eck-sequence/00-META.yaml Normal file
View file

@ -0,0 +1,2 @@
---
from: http://rosettacode.org/wiki/Van_Eck_sequence

46
Task/Van-Eck-sequence/00-TASK.txt Normal file
View file

@ -0,0 +1,46 @@
The sequence is generated by following this pseudo-code:
<pre>
A: The first term is zero.
Repeatedly apply:
If the last term is *new* to the sequence so far then:
B: The next term is zero.
Otherwise:
C: The next term is how far back this last term occured previously.
</pre>
;Example:
Using A:
:<code>0</code>
Using B:
:<code>0 0</code>
Using C:
:<code>0 0 1</code>
Using B:
:<code>0 0 1 0</code>
Using C: (zero last occurred two steps back - before the one)
:<code>0 0 1 0 2</code>
Using B:
:<code>0 0 1 0 2 0</code>
Using C: (two last occurred two steps back - before the zero)
:<code>0 0 1 0 2 0 2 2</code>
Using C: (two last occurred one step back)
:<code>0 0 1 0 2 0 2 2 1</code>
Using C: (one last appeared six steps back)
:<code>0 0 1 0 2 0 2 2 1 6</code>
...
;Task:
# Create a function/procedure/method/subroutine/... to generate the Van Eck sequence of numbers.
# Use it to display here, on this page:
:# The first ten terms of the sequence.
:# Terms 991 - to - 1000 of the sequence.
;References:
* [https://www.youtube.com/watch?v=etMJxB-igrc Don't Know (the Van Eck Sequence) - Numberphile video].
* [[wp:Van_Eck%27s_sequence|Wikipedia Article: Van Eck's Sequence]].
* [[OEIS:A181391| OEIS sequence: A181391]].
<br><br>

18
Task/Van-Eck-sequence/11l/van-eck-sequence.11l Normal file
View file

@ -0,0 +1,18 @@
F van_eck(c)
[Int] r
V n = 0
V seen = [0]
V val = 0
L
r.append(val)
I r.len == c
R r
I val C seen[1..]
val = seen.index(val, 1)
E
val = 0
seen.insert(0, val)
n++
print(‘Van Eck: first 10 terms: ’van_eck(10))
print(‘Van Eck: terms 991 - 1000: ’van_eck(1000)[(len)-10..])

110
Task/Van-Eck-sequence/8080-Assembly/van-eck-sequence.8080 Normal file
View file

@ -0,0 +1,110 @@
org 100h
lxi h,ecks ; Zero out 2000 bytes
lxi b,0
lxi d,2000
zero: mov m,b
inx h
dcx d
mov a,d
ora e
jnz zero
lxi b,-1 ; BC = Outer loop variable
outer: inx b
mvi a,3 ; Are we there yet? 1000 = 03E8h
cmp b ; Compare high byte
jnz go
mvi a,0E8h ; Compare low byte
cmp c
jz done
go: mov d,b ; DE = Inner loop variable
mov e,c
inner: dcx d
mov a,d ; <= 0?
ral
jc outer
push b ; Keep both pointers
push d
mov h,b ; Load BC = eck[BC]
mov l,c
call eck
mov c,m
inx h
mov b,m
xchg ; Load HL = -eck[DE]
call eck
xchg
ldax d
cma
mov l,a
inx d
ldax d
cma
mov h,a
inx h ; Two's complement
dad b ; -eck[DE] + eck[BC]
mov a,h ; Unfortunately this does not set flags
ora l ; Check zero
pop d ; Meanwhile, restore the pointers
pop b
jnz inner ; If no match, continue with inner loop
mov h,b ; If we _did_, then get &eck[BC + 1]
mov l,c
inx h
call eck
mov a,c ; Store BC - DE at that address
sub e
mov m,a
inx h
mov a,b
sbb d
mov m,a
jmp outer ; And continue the outer loop
done: lxi h,0 ; Print first 10 terms
call p10
lxi h,990 ; Print last 10 terms
p10: mvi b,10 ; Print 10 terms starting at term HL
call eck
ploop: mov e,m ; Load term into DE
inx h
mov d,m
inx h
push b ; Keep counter
push h ; Keep pointer
xchg ; Term in HL
call printn ; Print term
pop h ; Restore pointer and counter
pop b
dcr b
jnz ploop
lxi d,nl ; Print a newline afterwards
jmp prints
eck: push b ; Set HL = &eck[HL]
lxi b,ecks ; Base address
dad h ; Multiply by two
dad b ; Add base
pop b
ret
printn: lxi d,buf ; Print the number in HL
push d ; Buffer pointer on stack
lxi b,-10 ; Divisor
pdigit: lxi d,-1 ; Quotient
pdiv: inx d
dad b
jc pdiv
mvi a,'0'+10
add l ; Make ASCII digit
pop h
dcx h ; Store digit
mov m,a
push h
xchg
mov a,h ; Quotient nonzero?
ora l
jnz pdigit ; Then there are more digits
pop d ; Otherwise, print string using CP/M
prints: mvi c,9
jmp 5
nl: db 13,10,'$'
db '.....'
buf: db ' $'
ecks: equ $

62
Task/Van-Eck-sequence/8086-Assembly/van-eck-sequence.8086 Normal file
View file

@ -0,0 +1,62 @@
LIMIT: equ 1000
cpu 8086
org 100h
section .text
mov di,eck ; Zero out the memory
xor ax,ax
mov cx,LIMIT
rep stosw
mov bx,eck ; Base address
mov cx,LIMIT ; Limit
xor ax,ax
mov si,-1 ; Outer loop index
outer: inc si
dec cx
jcxz done
mov di,si ; Inner loop index
inner: dec di
js outer
shl si,1 ; Shift the loop indices (each entry is 2 bytes)
shl di,1
mov ax,[si+bx] ; Find a match?
cmp ax,[di+bx]
je match
shr si,1 ; If not, shift SI and DI back and keep going
shr di,1
jmp inner
match: mov ax,si ; Calculate the new value
sub ax,di
shr ax,1 ; Compensate for shift
mov [si+bx+2],ax ; Store value
shr si,1 ; Shift SI back and calculate next value
jmp outer
done: xor si,si ; Print first 10 elements
call p10
mov si,LIMIT-10 ; Print last 10 elements⌈
p10: mov cx,10 ; Print 10 elements starting at SI
shl si,1 ; Items are 2 bytes wide
add si,eck
.item: lodsw ; Retrieve item
call printn ; Print it
loop .item
mov dx,nl ; Print a newline afterwards
jmp prints
printn: mov bx,buf ; Print AX
mov bp,10
.digit: xor dx,dx ; Extract digit
div bp
add dl,'0' ; ASCII digit
dec bx
mov [bx],dl ; Store in buffer
test ax,ax ; Any more digits?
jnz .digit
mov dx,bx
prints: mov ah,9 ; Print string in buffer
int 21h
ret
section .data
nl: db 13,10,'$'
db '.....'
buf: db ' $'
section .bss
eck: resw LIMIT

100
Task/Van-Eck-sequence/AArch64-Assembly/van-eck-sequence.aarch64 Normal file
View file

@ -0,0 +1,100 @@
/* ARM assembly AARCH64 Raspberry PI 3B */
/* program vanEckSerie64.s */
/*******************************************/
/* Constantes file */
/*******************************************/
/* for this file see task include a file in language AArch64 assembly */
.include "../includeConstantesARM64.inc"
.equ MAXI, 1000
/*********************************/
/* Initialized data */
/*********************************/
.data
sMessResultElement: .asciz " @ "
szCarriageReturn: .asciz "\n"
/*********************************/
/* UnInitialized data */
/*********************************/
.bss
sZoneConv: .skip 24
TableVanEck: .skip 8 * MAXI
/*********************************/
/* code section */
/*********************************/
.text
.global main
main: // entry of program
mov x2,#0 // begin first element
mov x3,#0 // current counter
ldr x4,qAdrTableVanEck // table address
str x2,[x4,x3,lsl 3] // store first zéro
1: // begin loop
mov x5,x3 // init current indice
2:
sub x5,x5,1 // decrement
cmp x5,0 // end table ?
blt 3f
ldr x6,[x4,x5,lsl 3] // load element
cmp x6,x2 // and compare with the last element
bne 2b // not equal
sub x2,x3,x5 // else compute gap
b 4f
3:
mov x2,#0 // first, move zero to next element
4:
add x3,x3,#1 // increment counter
str x2,[x4,x3,lsl 3] // and store new element
cmp x3,MAXI
blt 1b
mov x2,0
5: // loop display ten elements
ldr x0,[x4,x2,lsl 3]
ldr x1,qAdrsZoneConv
bl conversion10 // call décimal conversion
ldr x0,qAdrsMessResultElement
ldr x1,qAdrsZoneConv // insert conversion in message
bl strInsertAtCharInc
mov x1,0 // final zéro
strb w1,[x0,5] //
bl affichageMess // display message
add x2,x2,1 // increment indice
cmp x2,10 // end ?
blt 5b // no -> loop
ldr x0,qAdrszCarriageReturn
bl affichageMess
mov x2,MAXI - 10
6: // loop display ten elements 990-999
ldr x0,[x4,x2,lsl 3]
ldr x1,qAdrsZoneConv
bl conversion10 // call décimal conversion
ldr x0,qAdrsMessResultElement
ldr x1,qAdrsZoneConv // insert conversion in message
bl strInsertAtCharInc
mov x1,0 // final zéro
strb w1,[x0,5] //
bl affichageMess // display message
add x2,x2,1 // increment indice
cmp x2,MAXI // end ?
blt 6b // no -> loop
ldr x0,qAdrszCarriageReturn
bl affichageMess
100: // standard end of the program
mov x0, 0 // return code
mov x8, EXIT // request to exit program
svc 0 // perform the system call
qAdrszCarriageReturn: .quad szCarriageReturn
qAdrsMessResultElement: .quad sMessResultElement
qAdrsZoneConv: .quad sZoneConv
qAdrTableVanEck: .quad TableVanEck
/********************************************************/
/* File Include fonctions */
/********************************************************/
/* for this file see task include a file in language AArch64 assembly */
.include "../includeARM64.inc"

27
Task/Van-Eck-sequence/ALGOL-68/van-eck-sequence.alg Normal file
View file

@ -0,0 +1,27 @@
BEGIN # find elements of the Van Eck Sequence - first term is 0, following #
# terms are 0 if the previous was the first appearance of the element #
# or how far back in the sequence the last element appeared #
# returns the first n elements of the Van Eck sequence #
OP VANECK = ( INT n )[]INT:
BEGIN
[ 1 : IF n < 0 THEN 0 ELSE n FI ]INT result; FOR i TO n DO result[ i ] := 0 OD;
[ 0 : UPB result ]INT pos; FOR i FROM 0 TO n DO pos[ i ] := 0 OD;
FOR i FROM 2 TO n DO
INT j = i - 1;
INT prev = result[ j ];
IF pos[ prev ] /= 0 THEN
# not a new element #
result[ i ] := j - pos[ prev ]
FI;
pos[ prev ] := j
OD;
result
END # VANECK # ;
# construct the first 1000 terms of the sequence #
[]INT seq = VANECK 1000;
# show the first and last 10 elements #
FOR i TO 10 DO print( ( " ", whole( seq[ i ], 0 ) ) ) OD;
print( ( newline ) );
FOR i FROM UPB seq - 9 TO UPB seq DO print( ( " ", whole( seq[ i ], 0 ) ) ) OD;
print( ( newline ) )
END

23
Task/Van-Eck-sequence/ALGOL-M/van-eck-sequence.alg Normal file
View file

@ -0,0 +1,23 @@
begin
integer array eck[1:1000];
integer i, j;
for i := 1 step 1 until 1000 do
eck[i] := 0;
for i := 1 step 1 until 999 do
begin
j := i - 1;
while j > 0 and eck[i] <> eck[j] do
j := j - 1;
if j <> 0 then
eck[i+1] := i - j;
end;
for i := 1 step 1 until 10 do
writeon(eck[i]);
write("");
for i := 991 step 1 until 1000 do
writeon(eck[i]);
end

33
Task/Van-Eck-sequence/ALGOL-W/van-eck-sequence.alg Normal file
View file

@ -0,0 +1,33 @@
begin % find elements of the Van Eck Sequence - first term is 0, following %
% terms are 0 if the previous was the first appearance of the element %
% or how far back in the sequence the last element appeared %
% sets s to the first n elements of the Van Eck sequence %
procedure VanEck ( integer array s ( * ) ; integer value n ) ;
begin
integer array pos ( 0 :: n );
for i := 1 until n do s( i ) := 0;
for i := 0 until n do pos( i ) := 0;
for i := 2 until n do begin
integer j, prev;
j := i - 1;
prev := s( j );
if pos( prev ) not = 0 then begin
% not a new element %
s( i ) := j - pos( prev )
end if_pos_prev_ne_0 ;
pos( prev ) := j
end for_j;
end VanEck ;
% construct the first 1000 terms of the sequence %
integer MAX_VAN_ECK;
MAX_VAN_ECK := 1000;
begin
integer array seq ( 1 :: MAX_VAN_ECK );
VanEck( seq, MAX_VAN_ECK );
% show the first and last 10 elements %
for i := 1 until 10 do writeon( i_w := 1, s_w := 0, " ", seq( i ) );
write();
for i := MAX_VAN_ECK - 9 until MAX_VAN_ECK do writeon( i_w := 1, s_w := 0, " ", seq( i ) );
write()
end
end.

1
Task/Van-Eck-sequence/APL/van-eck-sequence.apl Normal file
View file

@ -0,0 +1 @@
(10∘↑,[.5]¯10∘↑)(⊢,(⊃∘⌽∊¯1∘↓)∧(1↓⌽)⍳⊃∘⌽)⍣999⊢,0

102
Task/Van-Eck-sequence/ARM-Assembly/van-eck-sequence.arm Normal file
View file

@ -0,0 +1,102 @@
/* ARM assembly Raspberry PI */
/* program vanEckSerie.s */
/* REMARK 1 : this program use routines in a include file
see task Include a file language arm assembly
for the routine affichageMess conversion10
see at end of this program the instruction include */
/* for constantes see task include a file in arm assembly */
/************************************/
/* Constantes */
/************************************/
.include "../constantes.inc"
.equ MAXI, 1000
/*********************************/
/* Initialized data */
/*********************************/
.data
sMessResultElement: .asciz " @ "
szCarriageReturn: .asciz "\n"
/*********************************/
/* UnInitialized data */
/*********************************/
.bss
sZoneConv: .skip 24
TableVanEck: .skip 4 * MAXI
/*********************************/
/* code section */
/*********************************/
.text
.global main
main: @ entry of program
mov r2,#0 @ begin first element
mov r3,#0 @ current counter
ldr r4,iAdrTableVanEck @ table address
str r2,[r4,r3,lsl #2] @ store first zéro
1: @ begin loop
mov r5,r3 @ init current indice
2:
sub r5,#1 @ decrement
cmp r5,#0 @ end table ?
movlt r2,#0 @ yes, move zero to next element
blt 3f
ldr r6,[r4,r5,lsl #2] @ load element
cmp r6,r2 @ and compare with the last element
bne 2b @ not equal
sub r2,r3,r5 @ else compute gap
3:
add r3,r3,#1 @ increment counter
str r2,[r4,r3,lsl #2] @ and store new element
cmp r3,#MAXI
blt 1b
mov r2,#0
4: @ loop display ten elements
ldr r0,[r4,r2,lsl #2]
ldr r1,iAdrsZoneConv
bl conversion10 @ call décimal conversion
ldr r0,iAdrsMessResultElement
ldr r1,iAdrsZoneConv @ insert conversion in message
bl strInsertAtCharInc
mov r1,#0 @ final zéro
strb r1,[r0,#5] @
bl affichageMess @ display message
add r2,#1 @ increment indice
cmp r2,#10 @ end ?
blt 4b @ no -> loop
ldr r0,iAdrszCarriageReturn
bl affichageMess
mov r2,#MAXI - 10
5: @ loop display ten elements 990-999
ldr r0,[r4,r2,lsl #2]
ldr r1,iAdrsZoneConv
bl conversion10 @ call décimal conversion
ldr r0,iAdrsMessResultElement
ldr r1,iAdrsZoneConv @ insert conversion in message
bl strInsertAtCharInc
mov r1,#0 @ final zéro
strb r1,[r0,#5] @
bl affichageMess @ display message
add r2,#1 @ increment indice
cmp r2,#MAXI @ end ?
blt 5b @ no -> loop
ldr r0,iAdrszCarriageReturn
bl affichageMess
100: @ standard end of the program
mov r0, #0 @ return code
mov r7, #EXIT @ request to exit program
svc #0 @ perform the system call
iAdrszCarriageReturn: .int szCarriageReturn
iAdrsMessResultElement: .int sMessResultElement
iAdrsZoneConv: .int sZoneConv
iAdrTableVanEck: .int TableVanEck
/***************************************************/
/* ROUTINES INCLUDE */
/***************************************************/
.include "../affichage.inc"

23
Task/Van-Eck-sequence/AWK/van-eck-sequence.awk Normal file
View file

@ -0,0 +1,23 @@
# syntax: GAWK -f VAN_ECK_SEQUENCE.AWK
# converted from Go
BEGIN {
limit = 1000
for (i=0; i<limit; i++) {
arr[i] = 0
}
for (n=0; n<limit-1; n++) {
for (m=n-1; m>=0; m--) {
if (arr[m] == arr[n]) {
arr[n+1] = n - m
break
}
}
}
printf("terms 1-10:")
for (i=0; i<10; i++) { printf(" %d",arr[i]) }
printf("\n")
printf("terms 991-1000:")
for (i=990; i<1000; i++) { printf(" %d",arr[i]) }
printf("\n")
exit(0)
}

39
Task/Van-Eck-sequence/Action-/van-eck-sequence.action Normal file
View file

@ -0,0 +1,39 @@
INT FUNC LastPos(INT ARRAY a INT count,value)
INT pos
pos=count-1
WHILE pos>=0 AND a(pos)#value
DO
pos==-1
OD
RETURN (pos)
PROC Main()
DEFINE MAX="1000"
INT ARRAY seq(MAX)
INT i,pos
seq(0)=0
FOR i=1 TO MAX-1
DO
pos=LastPos(seq,i-1,seq(i-1))
IF pos>=0 THEN
seq(i)=i-1-pos
ELSE
seq(i)=0
FI
OD
PrintE("Van Eck first 10 terms:")
FOR i=0 TO 9
DO
PrintI(seq(i)) Put(32)
OD
PutE() PutE()
PrintE("Van Eck terms 991-1000:")
FOR i=990 TO 999
DO
PrintI(seq(i)) Put(32)
OD
RETURN

35
Task/Van-Eck-sequence/Ada/van-eck-sequence.ada Normal file
View file

@ -0,0 +1,35 @@
with Ada.Text_IO;
procedure Van_Eck_Sequence is
Sequence : array (Natural range 1 .. 1_000) of Natural;
procedure Calculate_Sequence is
begin
Sequence (Sequence'First) := 0;
for Index in Sequence'First .. Sequence'Last - 1 loop
Sequence (Index + 1) := 0;
for I in reverse Sequence'First .. Index - 1 loop
if Sequence (I) = Sequence (Index) then
Sequence (Index + 1) := Index - I;
exit;
end if;
end loop;
end loop;
end Calculate_Sequence;
procedure Show (First, Last : in Positive) is
use Ada.Text_IO;
begin
Put ("Element" & First'Image & " .." & Last'Image & " of Van Eck sequence: ");
for I in First .. Last loop
Put (Sequence (I)'Image);
end loop;
New_Line;
end Show;
begin
Calculate_Sequence;
Show (First => 1, Last => 10);
Show (First => 991, Last => 1_000);
end Van_Eck_Sequence;

173
Task/Van-Eck-sequence/AppleScript/van-eck-sequence-1.applescript Normal file
View file

@ -0,0 +1,173 @@
use AppleScript version "2.4"
use scripting additions
-- vanEck :: Int -> [Int]
on vanEck(n)
-- First n terms of the vanEck sequence.
script go
on |λ|(xns, i)
set {x, ns} to xns
set prev to item (1 + x) of ns
if 0 ≠ prev then
set v to i - prev
else
set v to 0
end if
{{v, insert(ns, x, i)}, v}
end |λ|
end script
{0} & item 2 of mapAccumL(go, ¬
{0, replicate(n, 0)}, enumFromTo(1, n - 1))
end vanEck
--------------------------- TEST ---------------------------
on run
unlines({¬
"First 10 terms:", ¬
showList(vanEck(10)), ¬
"", ¬
"Terms 990 to 1000:", ¬
showList(items -10 thru -1 of vanEck(1000))})
end run
------------------------- GENERIC --------------------------
-- enumFromTo :: Int -> Int -> [Int]
on enumFromTo(m, n)
if m ≤ n then
set lst to {}
repeat with i from m to n
set end of lst to i
end repeat
lst
else
{}
end if
end enumFromTo
-- foldl :: (a -> b -> a) -> a -> [b] -> a
on foldl(f, startValue, xs)
tell mReturn(f)
set v to startValue
set lng to length of xs
repeat with i from 1 to lng
set v to |λ|(v, item i of xs, i, xs)
end repeat
return v
end tell
end foldl
-- insert :: [Int] -> Int -> Int -> [Int]
on insert(xs, i, v)
-- A list updated at position i with value v.
set item (1 + i) of xs to v
xs
end insert
-- intercalate :: String -> [String] -> String
on intercalate(delim, xs)
set {dlm, my text item delimiters} to ¬
{my text item delimiters, delim}
set s to xs as text
set my text item delimiters to dlm
s
end intercalate
-- map :: (a -> b) -> [a] -> [b]
on map(f, xs)
-- The list obtained by applying f
-- to each element of xs.
tell mReturn(f)
set lng to length of xs
set lst to {}
repeat with i from 1 to lng
set end of lst to |λ|(item i of xs, i, xs)
end repeat
return lst
end tell
end map
-- mReturn :: First-class m => (a -> b) -> m (a -> b)
on mReturn(f)
-- 2nd class handler function lifted into 1st class script wrapper.
if script is class of f then
f
else
script
property |λ| : f
end script
end if
end mReturn
-- 'The mapAccumL function behaves like a combination of map and foldl;
-- it applies a function to each element of a list, passing an
-- accumulating parameter from |Left| to |Right|, and returning a final
-- value of this accumulator together with the new list.' (see Hoogle)
-- mapAccumL :: (acc -> x -> (acc, y)) -> acc -> [x] -> (acc, [y])
on mapAccumL(f, acc, xs)
script
on |λ|(a, x, i)
tell mReturn(f) to set pair to |λ|(item 1 of a, x, i)
{item 1 of pair, (item 2 of a) & {item 2 of pair}}
end |λ|
end script
foldl(result, {acc, []}, xs)
end mapAccumL
-- Egyptian multiplication - progressively doubling a list, appending
-- stages of doubling to an accumulator where needed for binary
-- assembly of a target length
-- replicate :: Int -> a -> [a]
on replicate(n, a)
set out to {}
if 1 > n then return out
set dbl to {a}
repeat while (1 < n)
if 0 < (n mod 2) then set out to out & dbl
set n to (n div 2)
set dbl to (dbl & dbl)
end repeat
return out & dbl
end replicate
-- showList :: [a] -> String
on showList(xs)
"[" & intercalate(", ", map(my str, xs)) & "]"
end showList
-- str :: a -> String
on str(x)
x as string
end str
-- unlines :: [String] -> String
on unlines(xs)
-- A single string formed by the intercalation
-- of a list of strings with the newline character.
set {dlm, my text item delimiters} to ¬
{my text item delimiters, linefeed}
set s to xs as text
set my text item delimiters to dlm
s
end unlines

28
Task/Van-Eck-sequence/AppleScript/van-eck-sequence-2.applescript Normal file
View file

@ -0,0 +1,28 @@
on vanEckSequence(limit)
script o
property sequence : {}
property lookup : {}
end script
set term to 0
repeat with i from 1 to (limit - 1) -- 1-based indices.
set end of o's sequence to term
set t to term + 1 -- 1-based index.
repeat (t - (count o's lookup)) times
set end of o's lookup to missing value
end repeat
set previous_i to item t of o's lookup
set item t of o's lookup to i
if (previous_i is missing value) then
set term to 0
else
set term to i - previous_i
end if
end repeat
set end of o's sequence to term
return o's sequence
end vanEckSequence
-- Task code:
tell vanEckSequence(1000) to return {items 1 thru 10, items 991 thru 1000}

1
Task/Van-Eck-sequence/AppleScript/van-eck-sequence-3.applescript Normal file
View file

@ -0,0 +1 @@
{{0, 0, 1, 0, 2, 0, 2, 2, 1, 6}, {4, 7, 30, 25, 67, 225, 488, 0, 10, 136}}

20
Task/Van-Eck-sequence/Arturo/van-eck-sequence.arturo Normal file
View file

@ -0,0 +1,20 @@
Max: 1000
a: array.of: Max 0
loop 0..Max-2 'n [
if 0 =< n-1 [
loop (n-1)..0 'm [
if a\[m]=a\[n] [
a\[n+1]: n-m
break
]
]
]
]
print "The first ten terms of the Van Eck sequence are:"
print first.n:10 a
print ""
print "Terms 991 to 1000 of the sequence are:"
print last.n:10 a

11
Task/Van-Eck-sequence/BASIC/van-eck-sequence.basic Normal file
View file

@ -0,0 +1,11 @@
10 DEFINT A-Z
20 DIM E(1000)
30 FOR I=0 TO 999
40 FOR J=I-1 TO 0 STEP -1
50 IF E(J)=E(I) THEN E(I+1)=I-J: GOTO 80
60 NEXT J
70 E(I+1)=0
80 NEXT I
90 FOR I=0 TO 9: PRINT E(I);: NEXT
95 PRINT
100 FOR I=990 TO 999: PRINT E(I);: NEXT

18
Task/Van-Eck-sequence/BCPL/van-eck-sequence.bcpl Normal file
View file

@ -0,0 +1,18 @@
get "libhdr"
let start() be
$( let eck = vec 999
for i = 0 to 999 do eck!i := 0
for i = 0 to 998 do
for j = i-1 to 0 by -1 do
if eck!i = eck!j then
$( eck!(i+1) := i-j
break
$)
for i = 0 to 9 do writed(eck!i, 4)
wrch('*N')
for i = 990 to 999 do writed(eck!i, 4)
wrch('*N')
$)

3
Task/Van-Eck-sequence/BQN/van-eck-sequence.bqn Normal file
View file

@ -0,0 +1,3 @@
EckStep ← ⊢∾(⊑⊑∘⌽∊1↓⌽)◶(0˙)‿((⊑1+⊑⊐˜ 1↓⊢)⌽)
Eck ← {(EckStep⍟(𝕩-1))⥊0}
(Eck 10)≍990↓Eck 1000

34
Task/Van-Eck-sequence/C++/van-eck-sequence.cpp Normal file
View file

@ -0,0 +1,34 @@
#include <iostream>
#include <map>
class van_eck_generator {
public:
int next() {
int result = last_term;
auto iter = last_pos.find(last_term);
int next_term = (iter != last_pos.end()) ? index - iter->second : 0;
last_pos[last_term] = index;
last_term = next_term;
++index;
return result;
}
private:
int index = 0;
int last_term = 0;
std::map<int, int> last_pos;
};
int main() {
van_eck_generator gen;
int i = 0;
std::cout << "First 10 terms of the Van Eck sequence:\n";
for (; i < 10; ++i)
std::cout << gen.next() << ' ';
for (; i < 990; ++i)
gen.next();
std::cout << "\nTerms 991 to 1000 of the sequence:\n";
for (; i < 1000; ++i)
std::cout << gen.next() << ' ';
std::cout << '\n';
return 0;
}

7
Task/Van-Eck-sequence/C-sharp/van-eck-sequence.cs Normal file
View file

@ -0,0 +1,7 @@
using System.Linq; class Program { static void Main() {
int a, b, c, d, e, f, g; int[] h = new int[g = 1000];
for (a = 0, b = 1, c = 2; c < g; a = b, b = c++)
for (d = a, e = b - d, f = h[b]; e <= b; e++)
if (f == h[d--]) { h[c] = e; break; }
void sho(int i) { System.Console.WriteLine(string.Join(" ",
h.Skip(i).Take(10))); } sho(0); sho(990); } }

23
Task/Van-Eck-sequence/C/van-eck-sequence.c Normal file
View file

@ -0,0 +1,23 @@
#include <stdlib.h>
#include <stdio.h>
int main(int argc, const char *argv[]) {
const int max = 1000;
int *a = malloc(max * sizeof(int));
for (int n = 0; n < max - 1; n ++) {
for (int m = n - 1; m >= 0; m --) {
if (a[m] == a[n]) {
a[n+1] = n - m;
break;
}
}
}
printf("The first ten terms of the Van Eck sequence are:\n");
for (int i = 0; i < 10; i ++) printf("%d ", a[i]);
printf("\n\nTerms 991 to 1000 of the sequence are:\n");
for (int i = 990; i < 1000; i ++) printf("%d ", a[i]);
putchar('\n');
return 0;
}

31
Task/Van-Eck-sequence/CLU/van-eck-sequence.clu Normal file
View file

@ -0,0 +1,31 @@
% Generate the first N elements of the Van Eck sequence
eck = proc (n: int) returns (array[int])
ai = array[int]
e: ai := ai$fill(0, n, 0)
for i: int in int$from_to(ai$low(e), ai$high(e)-1) do
for j: int in int$from_to_by(i-1, ai$low(e), -1) do
if e[i] = e[j] then
e[i+1] := i-j
break
end
end
end
return(e)
end eck
% Show 0..9 and 990..999
start_up = proc ()
po: stream := stream$primary_output()
e: array[int] := eck(1000)
stream$puts(po, " 0 - 9: ")
for i: int in int$from_to(0,9) do
stream$putright(po, int$unparse(e[i]), 4)
end
stream$puts(po, "\n990 - 999: ")
for i: int in int$from_to(990,999) do
stream$putright(po, int$unparse(e[i]), 4)
end
stream$putl(po, "")
end start_up

46
Task/Van-Eck-sequence/COBOL/van-eck-sequence.cobol Normal file
View file

@ -0,0 +1,46 @@
IDENTIFICATION DIVISION.
PROGRAM-ID. VAN-ECK.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 CALCULATION.
02 ECK PIC 999 OCCURS 1000 TIMES.
02 I PIC 9999.
02 J PIC 9999.
01 OUTPUT-FORMAT.
02 ITEM PIC ZZ9.
02 IDX PIC ZZZ9.
PROCEDURE DIVISION.
B. PERFORM GENERATE-ECK.
PERFORM SHOW VARYING I FROM 1 BY 1 UNTIL I = 11.
PERFORM SHOW VARYING I FROM 991 BY 1 UNTIL I = 1001.
STOP RUN.
SHOW.
MOVE I TO IDX.
MOVE ECK(I) TO ITEM.
DISPLAY 'ECK(' IDX ') = ' ITEM.
GENERATE-ECK SECTION.
B. SET ECK(1) TO 0.
SET I TO 1.
PERFORM GENERATE-TERM
VARYING I FROM 2 BY 1 UNTIL I = 1001.
GENERATE-TERM SECTION.
B. SUBTRACT 2 FROM I GIVING J.
LOOP.
IF J IS LESS THAN 1 GO TO TERM-IS-NEW.
IF ECK(J) = ECK(I - 1) GO TO TERM-IS-OLD.
SUBTRACT 1 FROM J.
GO TO LOOP.
TERM-IS-NEW.
SET ECK(I) TO 0.
GO TO DONE.
TERM-IS-OLD.
COMPUTE ECK(I) = (I - J) - 1.
DONE. EXIT.

12
Task/Van-Eck-sequence/Clojure/van-eck-sequence.clj Normal file
View file

@ -0,0 +1,12 @@
(defn van-eck
([] (van-eck 0 0 {}))
([val n seen]
(lazy-seq
(cons val
(let [next (- n (get seen val n))]
(van-eck next
(inc n)
(assoc seen val n)))))))
(println "First 10 terms:" (take 10 (van-eck)))
(println "Terms 991 to 1000 terms:" (take 10 (drop 990 (van-eck))))

12
Task/Van-Eck-sequence/Comal/van-eck-sequence.comal Normal file
View file

@ -0,0 +1,12 @@
0010 DIM eck#(0:1000)
0020 FOR i#:=1 TO 999 DO
0030 j#:=i#-1
0040 WHILE j#>0 AND eck#(i#)<>eck#(j#) DO j#:-1
0050 IF j#<>0 THEN eck#(i#+1):=i#-j#
0060 ENDFOR i#
0070 ZONE 5
0080 FOR i#:=1 TO 10 DO PRINT eck#(i#),
0090 PRINT
0100 FOR i#:=991 TO 1000 DO PRINT eck#(i#),
0110 PRINT
0120 END

19
Task/Van-Eck-sequence/Common-Lisp/van-eck-sequence-1.lisp Normal file
View file

@ -0,0 +1,19 @@
;;Tested using CLISP
(defun VanEck (x) (reverse (VanEckh x 0 0 '(0))))
(defun VanEckh (final index curr lst)
(if (eq index final)
lst
(VanEckh final (+ index 1) (howfar curr lst) (cons curr lst))))
(defun howfar (x lst) (howfarh x lst 0))
(defun howfarh (x lst runningtotal)
(cond
((null lst) 0)
((eq x (car lst)) (+ runningtotal 1))
(t (howfarh x (cdr lst) (+ runningtotal 1)))))
(format t "The first 10 elements are ~a~%" (VanEck 9))
(format t "The 990-1000th elements are ~a~%" (nthcdr 990 (VanEck 999)))

8
Task/Van-Eck-sequence/Common-Lisp/van-eck-sequence-2.lisp Normal file
View file

@ -0,0 +1,8 @@
(defun van-eck-nm-sequence (n m)
(loop with ac repeat m
for i = (position (car ac) (cdr ac)) do
(push (if i (1+ i) 0) ac)
finally (return (nthcdr (1- n) (nreverse ac)))))
(format t "The first 10 elements are: ~{~a ~}~%" (van-eck-nm-sequence 1 10))
(format t "The 991-1000th elements are: ~{~a ~}" (van-eck-nm-sequence 991 1000))

33
Task/Van-Eck-sequence/Cowgol/van-eck-sequence.cowgol Normal file
View file

@ -0,0 +1,33 @@
include "cowgol.coh";
sub print_list(ptr: [uint16], n: uint8) is
while n > 0 loop
print_i16([ptr]);
print_char(' ');
n := n - 1;
ptr := @next ptr;
end loop;
print_nl();
end sub;
const LIMIT := 1000;
var eck: uint16[LIMIT];
MemZero(&eck as [uint8], @bytesof eck);
var i: @indexof eck;
var j: @indexof eck;
i := 0;
while i < LIMIT-1 loop
j := i-1;
while j != -1 loop
if eck[i] == eck[j] then
eck[i+1] := i-j;
break;
end if;
j := j - 1;
end loop;
i := i + 1;
end loop;
print_list(&eck[0], 10);
print_list(&eck[LIMIT-10], 10);

42
Task/Van-Eck-sequence/Craft-Basic/van-eck-sequence.basic Normal file
View file

@ -0,0 +1,42 @@
define limit = 1000
dim list[limit]
print "calculating van eck sequence..."
for n = 0 to limit - 1
for m = n - 1 to 0 step -1
if list[m] = list[n] then
let c = n + 1
let list[c] = n - m
break m
endif
wait
next m
next n
print "first 10 terms: "
for i = 0 to 9
print list[i]
next i
print "terms 991 to 1000: "
for i = 990 to 999
print list[i]
next i
end

25
Task/Van-Eck-sequence/D/van-eck-sequence.d Normal file
View file

@ -0,0 +1,25 @@
import std.stdio;
void vanEck(int firstIndex, int lastIndex) {
int[int] vanEckMap;
int last = 0;
if (firstIndex == 1) {
writefln("VanEck[%d] = %d", 1, 0);
}
for (int n = 2; n <= lastIndex; n++) {
int vanEck = last in vanEckMap ? n - vanEckMap[last] : 0;
vanEckMap[last] = n;
last = vanEck;
if (n >= firstIndex) {
writefln("VanEck[%d] = %d", n, vanEck);
}
}
}
void main() {
writeln("First 10 terms of Van Eck's sequence:");
vanEck(1, 10);
writeln;
writeln("Terms 991 to 1000 of Van Eck's sequence:");
vanEck(991, 1000);
}

28
Task/Van-Eck-sequence/Draco/van-eck-sequence.draco Normal file
View file

@ -0,0 +1,28 @@
/* Fill array with Van Eck sequence */
proc nonrec make_eck([*] word eck) void:
int i, j, max;
max := dim(eck,1)-1;
for i from 0 upto max do eck[i] := 0 od;
for i from 0 upto max-1 do
j := i - 1;
while j >= 0 and eck[i] ~= eck[j] do
j := j - 1
od;
if j >= 0 then
eck[i+1] := i - j
fi
od
corp
/* Print eck[0..9] and eck[990..999] */
proc nonrec main() void:
word i;
[1000] word eck;
make_eck(eck);
for i from 0 upto 9 do write(eck[i]:4) od;
writeln();
for i from 990 upto 999 do write(eck[i]:4) od;
writeln()
corp

14
Task/Van-Eck-sequence/Dyalect/van-eck-sequence.dyalect Normal file
View file

@ -0,0 +1,14 @@
let max = 1000
var a = Array.Empty(max, 0)
for n in 0..(max-2) {
var m = n - 1
while m >= 0 {
if a[m] == a[n] {
a[n+1] = n - m
break
}
m -= 1
}
}
print("The first ten terms of the Van Eck sequence are: \(a[0..10].ToArray())")
print("Terms 991 to 1000 of the sequence are: \(a[991..999].ToArray())")

16
Task/Van-Eck-sequence/EasyLang/van-eck-sequence.easy Normal file
View file

@ -0,0 +1,16 @@
len arr[] 1000
for n to 1000 - 1
for m = n - 1 downto 1
if arr[m] = arr[n]
arr[n + 1] = n - m
break 1
.
.
.
for i to 10
write arr[i] & " "
.
print ""
for i = 991 to 1000
write arr[i] & " "
.

3
Task/Van-Eck-sequence/F-Sharp/van-eck-sequence-1.fs Normal file
View file

@ -0,0 +1,3 @@
// Generate Van Eck's Sequence. Nigel Galloway: June 19th., 2019
let ecK()=let n=System.Collections.Generic.Dictionary<int,int>()
Seq.unfold(fun (g,e)->Some(g,((if n.ContainsKey g then let i=n.[g] in n.[g]<-e;e-i else n.[g]<-e;0),e+1)))(0,0)

1
Task/Van-Eck-sequence/F-Sharp/van-eck-sequence-2.fs Normal file
View file

@ -0,0 +1 @@
ecK() |> Seq.take 50 |> Seq.iter(printf "%d "); printfn "";;

1
Task/Van-Eck-sequence/F-Sharp/van-eck-sequence-3.fs Normal file
View file

@ -0,0 +1 @@
ecK() |> Seq.skip 990 |> Seq.take 50|> Seq.iter(printf "%d "); printfn "";;

21
Task/Van-Eck-sequence/F-Sharp/van-eck-sequence-4.fs Normal file
View file

@ -0,0 +1,21 @@
open System.Collections.Generic
let VanEck() =
let rec _vanEck (num:int) (pos:int) (lastOccurence:Dictionary<int, int>) =
match lastOccurence.TryGetValue num with
| (true, position) ->
set num pos (pos - position) lastOccurence
| _ ->
set num pos 0 lastOccurence
and set num pos next lastOccurenceByNumber = seq {
lastOccurenceByNumber.[num] <- pos
yield next
yield! _vanEck next (pos + 1) lastOccurenceByNumber
}
seq {
yield 0
yield! _vanEck 0 1 (new Dictionary<int, int>())
}
VanEck() |> Seq.take 10 |> Seq.map (sprintf "%i") |> String.concat " " |> printfn "The first ten terms of the sequence : %s"
VanEck() |> Seq.skip 990 |> Seq.take 10 |> Seq.map (sprintf "%i") |> String.concat " " |> printfn "Terms 991 - to - 1000 of the sequence : %s"

12
Task/Van-Eck-sequence/Factor/van-eck-sequence.factor Normal file
View file

@ -0,0 +1,12 @@
USING: assocs fry kernel make math namespaces prettyprint
sequences ;
: van-eck ( n -- seq )
[
0 , 1 - H{ } clone '[
building get [ length 1 - ] [ last ] bi _ 3dup
2dup key? [ at - ] [ 3drop 0 ] if , set-at
] times
] { } make ;
1000 van-eck 10 [ head ] [ tail* ] 2bi [ . ] bi@

24
Task/Van-Eck-sequence/Fortran/van-eck-sequence.f Normal file
View file

@ -0,0 +1,24 @@
program VanEck
implicit none
integer eck(1000), i, j
eck(1) = 0
do 20 i=1, 999
do 10 j=i-1, 1, -1
if (eck(i) .eq. eck(j)) then
eck(i+1) = i-j
go to 20
end if
10 continue
eck(i+1) = 0
20 continue
do 30 i=1, 10
30 write (*,'(I4)',advance='no') eck(i)
write (*,*)
do 40 i=991, 1000
40 write (*,'(I4)',advance='no') eck(i)
write (*,*)
end program

20
Task/Van-Eck-sequence/FreeBASIC/van-eck-sequence.basic Normal file
View file

@ -0,0 +1,20 @@
Const limite = 1000
Dim As Integer a(limite), n, m, i
For n = 0 To limite-1
For m = n-1 To 0 Step -1
If a(m) = a(n) Then a(n+1) = n-m: Exit For
Next m
Next n
Print "Secuencia de Van Eck:" &Chr(10)
Print "Primeros 10 terminos: ";
For i = 0 To 9
Print a(i) &" ";
Next i
Print Chr(10) & "Terminos 991 al 1000: ";
For i = 990 To 999
Print a(i) &" ";
Next i
End

20
Task/Van-Eck-sequence/Go/van-eck-sequence-1.go Normal file
View file

@ -0,0 +1,20 @@
package main
import "fmt"
func main() {
const max = 1000
a := make([]int, max) // all zero by default
for n := 0; n < max-1; n++ {
for m := n - 1; m >= 0; m-- {
if a[m] == a[n] {
a[n+1] = n - m
break
}
}
}
fmt.Println("The first ten terms of the Van Eck sequence are:")
fmt.Println(a[:10])
fmt.Println("\nTerms 991 to 1000 of the sequence are:")
fmt.Println(a[990:])
}

19
Task/Van-Eck-sequence/Go/van-eck-sequence-2.go Normal file
View file

@ -0,0 +1,19 @@
package main
import "fmt"
func main() {
const max = 1000
a := make([]int, max) // all zero by default
seen := make(map[int]int)
for n := 0; n < max-1; n++ {
if m, ok := seen[a[n]]; ok {
a[n+1] = n - m
}
seen[a[n]] = n
}
fmt.Println("The first ten terms of the Van Eck sequence are:")
fmt.Println(a[:10])
fmt.Println("\nTerms 991 to 1000 of the sequence are:")
fmt.Println(a[990:])
}

13
Task/Van-Eck-sequence/Haskell/van-eck-sequence-1.hs Normal file
View file

@ -0,0 +1,13 @@
import Data.List (elemIndex)
import Data.Maybe (maybe)
vanEck :: Int -> [Int]
vanEck n = reverse $ iterate go [] !! n
where
go [] = [0]
go xxs@(x:xs) = maybe 0 succ (elemIndex x xs) : xxs
main :: IO ()
main = do
print $ vanEck 10
print $ drop 990 (vanEck 1000)

22
Task/Van-Eck-sequence/Haskell/van-eck-sequence-2.hs Normal file
View file

@ -0,0 +1,22 @@
{-# LANGUAGE TupleSections #-}
import Data.List (mapAccumL)
import qualified Data.Map.Strict as M hiding (drop)
import Data.Maybe (maybe)
--------------------- VAN ECK SEQUENCE -------------------
vanEck :: [Int]
vanEck = 0 : snd (mapAccumL go (0, M.empty) [1 ..])
where
go (x, dct) i =
((,) =<< (, M.insert x i dct))
(maybe 0 (i -) (M.lookup x dct))
--------------------------- TEST -------------------------
main :: IO ()
main =
mapM_ print $
fmap
((drop . subtract 10) <*> flip take vanEck)
[10, 1000, 10000, 100000, 1000000]

1
Task/Van-Eck-sequence/J/van-eck-sequence-1.j Normal file
View file

@ -0,0 +1 @@
VanEck=. (, (<:@:# - }: i: {:))^:(]`0:)

5
Task/Van-Eck-sequence/J/van-eck-sequence-2.j Normal file
View file

@ -0,0 +1,5 @@
VanEck 9
0 0 1 0 2 0 2 2 1 6
990 }. VanEck 999
4 7 30 25 67 225 488 0 10 136

2
Task/Van-Eck-sequence/J/van-eck-sequence-3.j Normal file
View file

@ -0,0 +1,2 @@
next =. <:@:# - }: i: {: NB. Next term of the sequence
VanEck=. (, next)^:(]`0:) f. NB. Appending terms and fixing the verb

31
Task/Van-Eck-sequence/Java/van-eck-sequence.java Normal file
View file

@ -0,0 +1,31 @@
import java.util.HashMap;
import java.util.Map;
public class VanEckSequence {
public static void main(String[] args) {
System.out.println("First 10 terms of Van Eck's sequence:");
vanEck(1, 10);
System.out.println("");
System.out.println("Terms 991 to 1000 of Van Eck's sequence:");
vanEck(991, 1000);
}
private static void vanEck(int firstIndex, int lastIndex) {
Map<Integer,Integer> vanEckMap = new HashMap<>();
int last = 0;
if ( firstIndex == 1 ) {
System.out.printf("VanEck[%d] = %d%n", 1, 0);
}
for ( int n = 2 ; n <= lastIndex ; n++ ) {
int vanEck = vanEckMap.containsKey(last) ? n - vanEckMap.get(last) : 0;
vanEckMap.put(last, n);
last = vanEck;
if ( n >= firstIndex ) {
System.out.printf("VanEck[%d] = %d%n", n, vanEck);
}
}
}
}

81
Task/Van-Eck-sequence/JavaScript/van-eck-sequence-1.js Normal file
View file

@ -0,0 +1,81 @@
(() => {
'use strict';
// vanEck :: Int -> [Int]
const vanEck = n =>
reverse(
churchNumeral(n)(
xs => 0 < xs.length ? cons(
maybe(
0, succ,
elemIndex(xs[0], xs.slice(1))
),
xs
) : [0]
)([])
);
// TEST -----------------------------------------------
const main = () => {
console.log('VanEck series:\n')
showLog('First 10 terms', vanEck(10))
showLog('Terms 991-1000', vanEck(1000).slice(990))
};
// GENERIC FUNCTIONS ----------------------------------
// Just :: a -> Maybe a
const Just = x => ({
type: 'Maybe',
Nothing: false,
Just: x
});
// Nothing :: Maybe a
const Nothing = () => ({
type: 'Maybe',
Nothing: true,
});
// churchNumeral :: Int -> (a -> a) -> a -> a
const churchNumeral = n => f => x =>
Array.from({
length: n
}, () => f)
.reduce((a, g) => g(a), x)
// cons :: a -> [a] -> [a]
const cons = (x, xs) => [x].concat(xs)
// elemIndex :: Eq a => a -> [a] -> Maybe Int
const elemIndex = (x, xs) => {
const i = xs.indexOf(x);
return -1 === i ? (
Nothing()
) : Just(i);
};
// maybe :: b -> (a -> b) -> Maybe a -> b
const maybe = (v, f, m) =>
m.Nothing ? v : f(m.Just);
// reverse :: [a] -> [a]
const reverse = xs =>
'string' !== typeof xs ? (
xs.slice(0).reverse()
) : xs.split('').reverse().join('');
// showLog :: a -> IO ()
const showLog = (...args) =>
console.log(
args
.map(JSON.stringify)
.join(' -> ')
);
// succ :: Int -> Int
const succ = x => 1 + x;
// MAIN ---
return main();
})();

108
Task/Van-Eck-sequence/JavaScript/van-eck-sequence-2.js Normal file
View file

@ -0,0 +1,108 @@
(() => {
"use strict";
// vanEck :: Int -> [Int]
const vanEck = n =>
// First n terms of the vanEck series.
[0].concat(mapAccumL(
([x, seen]) => i => {
const
prev = seen[x],
v = Boolean(prev) ? (
i - prev
) : 0;
return [
[v, (seen[x] = i, seen)], v
];
})(
[0, {}]
)(
enumFromTo(1)(n - 1)
)[1]);
// ----------------------- TEST ------------------------
const main = () =>
fTable(
"Terms of the VanEck series:\n"
)(
n => `${str(n - 10)}-${str(n)}`
)(
xs => JSON.stringify(xs.slice(-10))
)(
vanEck
)([10, 1000, 10000]);
// ----------------- GENERIC FUNCTIONS -----------------
// enumFromTo :: Int -> Int -> [Int]
const enumFromTo = m =>
n => Array.from({
length: 1 + n - m
}, (_, i) => m + i);
// fTable :: String -> (a -> String) ->
// (b -> String) -> (a -> b) -> [a] -> String
const fTable = s =>
// Heading -> x display function ->
// fx display function ->
// f -> values -> tabular string
xShow => fxShow => f => xs => {
const
ys = xs.map(xShow),
w = Math.max(...ys.map(y => [...y].length)),
table = zipWith(
a => b => `${a.padStart(w, " ")} -> ${b}`
)(ys)(
xs.map(x => fxShow(f(x)))
).join("\n");
return `${s}\n${table}`;
};
// mapAccumL :: (acc -> x -> (acc, y)) -> acc ->
// [x] -> (acc, [y])
const mapAccumL = f =>
// A tuple of an accumulation and a list
// obtained by a combined map and fold,
// with accumulation from left to right.
acc => xs => [...xs].reduce(
([a, bs], x) => second(
v => bs.concat(v)
)(
f(a)(x)
),
[acc, []]
);
// second :: (a -> b) -> ((c, a) -> (c, b))
const second = f =>
// A function over a simple value lifted
// to a function over a tuple.
// f (a, b) -> (a, f(b))
([x, y]) => [x, f(y)];
// str :: a -> String
const str = x => x.toString();
// zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]
const zipWith = f =>
// A list constructed by zipping with a
// custom function, rather than with the
// default tuple constructor.
xs => ys => xs.map(
(x, i) => f(x)(ys[i])
).slice(
0, Math.min(xs.length, ys.length)
);
// MAIN ---
return main();
})();

19
Task/Van-Eck-sequence/Jq/van-eck-sequence-1.jq Normal file
View file

@ -0,0 +1,19 @@
# Input: an array
# If the rightmost element, .[-1], does not occur elsewhere, return 0;
# otherwise return the "depth" of its rightmost occurrence in .[0:-2]
def depth:
.[-1] as $x
| length as $length
| first(range($length-2; -1; -1) as $i
| select(.[$i] == $x) | $length - 1 - $i)
// 0 ;
# Generate a stream of the first $n van Eck integers:
def vanEck($n):
def v:
recurse( if length == $n then empty
else . + [depth] end );
[0] | v | .[-1];
# The task:
[vanEck(10)], [vanEck(1000)][990:1001]

2
Task/Van-Eck-sequence/Jq/van-eck-sequence-2.jq Normal file
View file

@ -0,0 +1,2 @@
[0,0,1,0,2,0,2,2,1,6]
[4,7,30,25,67,225,488,0,10,136]

14
Task/Van-Eck-sequence/Julia/van-eck-sequence-1.julia Normal file
View file

@ -0,0 +1,14 @@
function vanecksequence(N, startval=0)
ret = zeros(Int, N)
ret[1] = startval
for i in 1:N-1
lastseen = findlast(x -> x == ret[i], ret[1:i-1])
if lastseen != nothing
ret[i + 1] = i - lastseen
end
end
ret
end
println(vanecksequence(10))
println(vanecksequence(1000)[991:1000])

12
Task/Van-Eck-sequence/Julia/van-eck-sequence-2.julia Normal file
View file

@ -0,0 +1,12 @@
function vanecksequence(N, startval=0)
ret = zeros(Int, N)
ret[1] = startval
lastseen = Dict{Int, Int}()
for i in 1:N-1
if haskey(lastseen, ret[i])
ret[i + 1] = i - lastseen[ret[i]]
end
lastseen[ret[i]] = i
end
ret
end

23
Task/Van-Eck-sequence/Kotlin/van-eck-sequence.kotlin Normal file
View file

@ -0,0 +1,23 @@
fun main() {
println("First 10 terms of Van Eck's sequence:")
vanEck(1, 10)
println("")
println("Terms 991 to 1000 of Van Eck's sequence:")
vanEck(991, 1000)
}
private fun vanEck(firstIndex: Int, lastIndex: Int) {
val vanEckMap = mutableMapOf<Int, Int>()
var last = 0
if (firstIndex == 1) {
println("VanEck[1] = 0")
}
for (n in 2..lastIndex) {
val vanEck = if (vanEckMap.containsKey(last)) n - vanEckMap[last]!! else 0
vanEckMap[last] = n
last = vanEck
if (n >= firstIndex) {
println("VanEck[$n] = $vanEck")
}
}
}

32
Task/Van-Eck-sequence/Lua/van-eck-sequence.lua Normal file
View file

@ -0,0 +1,32 @@
-- Return a table of the first n values of the Van Eck sequence
function vanEck (n)
local seq, foundAt = {0}
while #seq < n do
foundAt = nil
for pos = #seq - 1, 1, -1 do
if seq[pos] == seq[#seq] then
foundAt = pos
break
end
end
if foundAt then
table.insert(seq, #seq - foundAt)
else
table.insert(seq, 0)
end
end
return seq
end
-- Show the set of values in table t from key numbers lo to hi
function showValues (t, lo, hi)
for i = lo, hi do
io.write(t[i] .. " ")
end
print()
end
-- Main procedure
local sequence = vanEck(1000)
showValues(sequence, 1, 10)
showValues(sequence, 991, 1000)

63
Task/Van-Eck-sequence/MACRO-11/van-eck-sequence.macro11 Normal file
View file

@ -0,0 +1,63 @@
.TITLE VANECK
.MCALL .TTYOUT,.EXIT
; CALCULATE VAN ECK SEQUENCE
VANECK::MOV #ECKBUF,R5
MOV R5,R0
CLR (R0)
1$: MOV R0,R1
BR 3$
2$: CMP (R0),(R1)
BEQ 4$
3$: SUB #2,R1
CMP R1,R5
BGE 2$
CLR R3
BR 5$
4$: MOV R0,R3
SUB R1,R3
ASR R3
5$: ADD #2,R0
MOV R3,(R0)
CMP R0,#BUFEND
BLE 1$
; PRINT VALUES
MOV #ECKBUF,R3
JSR PC,PR10
MOV #ECKBUF+<2*^D990>,R3
JSR PC,PR10
.EXIT
; PRINT 10 VALUES STARTING AT R3
PR10: MOV #^D10,R4
1$: MOV (R3)+,R0
JSR PC,PR0
SOB R4,1$
MOV #15,R0
.TTYOUT
MOV #12,R0
.TTYOUT
RTS PC
; PRINT NUMBER IN R0 AS DECIMAL
PR0: MOV #4$,R1
1$: MOV #-1,R2
2$: INC R2
SUB #12,R0
BCC 2$
ADD #72,R0
MOVB R0,-(R1)
MOV R2,R0
BNE 1$
3$: MOVB (R1)+,R0
.TTYOUT
BNE 3$
RTS PC
.ASCII /...../
4$: .ASCIZ / /
.EVEN
ECKBUF: .BLKW ^D1000
BUFEND = .
.END VANECK

16
Task/Van-Eck-sequence/MAD/van-eck-sequence.mad Normal file
View file

@ -0,0 +1,16 @@
NORMAL MODE IS INTEGER
DIMENSION E(1000)
E(0)=0
THROUGH L1, FOR I=0, 1, I.GE.1000
THROUGH L2, FOR J=I-1, -1, J.L.0
WHENEVER E(J).E.E(I)
E(I+1) = I-J
TRANSFER TO L1
END OF CONDITIONAL
L2 CONTINUE
E(I+1)=0
L1 CONTINUE
THROUGH S, FOR I=0, 1, I.GE.10
S PRINT FORMAT FMT, I, E(I), I+990, E(I+990)
VECTOR VALUES FMT = $2HE(,I3,2H)=,I3,S5,2HE(,I3,2H)=,I3*$
END OF PROGRAM

1
Task/Van-Eck-sequence/Mathematica/van-eck-sequence.math Normal file
View file

@ -0,0 +1 @@
TakeList[Nest[If[MemberQ[#//Most, #//Last], Join[#, Length[#] - Last@Position[#//Most, #//Last]], Append[#, 0]]&, {0}, 999], {10, -10}] // Column

16
Task/Van-Eck-sequence/Miranda/van-eck-sequence.miranda Normal file
View file

@ -0,0 +1,16 @@
main :: [sys_message]
main = [ Stdout (show list ++ "\n")
| list <- [take 10 eck, take 10 (drop 990 eck)]
]
eck :: [num]
eck = 0 : map item [1..]
where item n = find last (tl sofar)
where sofar = reverse (take n eck)
last = hd sofar
find :: *->[*]->num
find i = find' 1
where find' n [] = 0
find' n (a:as) = n, if a = i
= find' (n+1) as, otherwise

30
Task/Van-Eck-sequence/Modula-2/van-eck-sequence.mod2 Normal file
View file

@ -0,0 +1,30 @@
MODULE VanEck;
FROM InOut IMPORT WriteCard, WriteLn;
VAR i, j: CARDINAL;
eck: ARRAY [1..1000] OF CARDINAL;
BEGIN
FOR i := 1 TO 1000 DO
eck[i] := 0;
END;
FOR i := 1 TO 999 DO
j := i-1;
WHILE (j > 0) AND (eck[i] <> eck[j]) DO
DEC(j);
END;
IF j <> 0 THEN
eck[i+1] := i-j;
END;
END;
FOR i := 1 TO 10 DO
WriteCard(eck[i], 4);
END;
WriteLn();
FOR i := 991 TO 1000 DO
WriteCard(eck[i], 4);
END;
WriteLn();
END VanEck.

12
Task/Van-Eck-sequence/Nim/van-eck-sequence.nim Normal file
View file

@ -0,0 +1,12 @@
const max = 1000
var a: array[max, int]
for n in countup(0, max - 2):
for m in countdown(n - 1, 0):
if a[m] == a[n]:
a[n + 1] = n - m
break
echo "The first ten terms of the Van Eck sequence are:"
echo a[..9]
echo "\nTerms 991 to 1000 of the sequence are:"
echo a[990..^1]

46
Task/Van-Eck-sequence/PL-M/van-eck-sequence.plm Normal file
View file

@ -0,0 +1,46 @@
100H:
BDOS: PROCEDURE (FN, ARG); DECLARE FN BYTE, ARG ADDRESS; GO TO 5; END BDOS;
EXIT: PROCEDURE; CALL BDOS(0,0); END EXIT;
PRINT: PROCEDURE (S); DECLARE S ADDRESS; CALL BDOS(9,S); END PRINT;
PRINT$NUMBER: PROCEDURE (N);
DECLARE S (7) BYTE INITIAL ('..... $');
DECLARE (N, P) ADDRESS, C BASED P BYTE;
P = .S(5);
DIGIT:
P = P - 1;
C = N MOD 10 + '0';
N = N / 10;
IF N > 0 THEN GO TO DIGIT;
CALL PRINT(P);
END PRINT$NUMBER;
PRINT$SLICE: PROCEDURE (LIST, N);
DECLARE (I, N, LIST, L BASED LIST) ADDRESS;
DO I=0 TO N-1;
CALL PRINT$NUMBER(L(I));
END;
CALL PRINT(.(13,10,'$'));
END PRINT$SLICE;
DECLARE ECK (1000) ADDRESS;
DECLARE (I, J) ADDRESS;
ECK(0) = 0;
DO I=0 TO LAST(ECK)-1;
J = I - 1;
DO WHILE J <> 0FFFFH; /* WHAT IS SIGNED MATH */
IF ECK(I) = ECK(J) THEN DO;
ECK(I+1) = I-J;
GO TO NEXT;
END;
J = J - 1;
END;
ECK(I+1) = 0;
NEXT:
END;
CALL PRINT$SLICE(.ECK(0), 10);
CALL PRINT$SLICE(.ECK(990), 10);
CALL EXIT;
EOF

99
Task/Van-Eck-sequence/Pascal/van-eck-sequence.pas Normal file
View file

@ -0,0 +1,99 @@
program VanEck;
{
* A: The first term is zero.
Repeatedly apply:
If the last term is *new* to the sequence so far then:
B: The next term is zero.
Otherwise:
C: The next term is how far back this last term occured previousely.}
uses
sysutils;
const
MAXNUM = 32381775;//1000*1000*1000;
MAXSEENIDX = (1 shl 7)-1;
var
PosBefore : array of UInt32;
LastSeen : array[0..MAXSEENIDX]of UInt32;// circular buffer
SeenIdx,HaveSeen : Uint32;
procedure OutSeen(Cnt:NativeInt);
var
I,S_Idx : NativeInt;
Begin
IF Cnt > MAXSEENIDX then
Cnt := MAXSEENIDX;
If Cnt > HaveSeen then
Cnt := HaveSeen;
S_Idx := SeenIdx;
S_Idx := (S_Idx-Cnt);
IF S_Idx < 0 then
inc(S_Idx,MAXSEENIDX);
For i := 1 to Cnt do
Begin
write(' ',LastSeen[S_Idx]);
S_Idx:= (S_Idx+1) AND MAXSEENIDX;
end;
writeln;
end;
procedure Test(MaxTestCnt: Uint32);
var
i, actnum, Posi, S_Idx: Uint32;
{$IFDEF FPC}
pPosBef, pSeen: pUint32;
{$ELSE}
pPosBef, pSeen: array of UInt32;
{$ENDIF}
begin
HaveSeen := 0;
if MaxTestCnt > MAXNUM then
EXIT;
Fillchar(LastSeen, SizeOf(LastSeen), #0);
//setlength and clear
setlength(PosBefore, 0);
setlength(PosBefore, MaxTestCnt);
{$IFDEF FPC}
pPosBef := @PosBefore[0];
pSeen := @LastSeen[0];
{$ELSE}
SetLength(pSeen, SizeOf(LastSeen));
setlength(pPosBef, MaxTestCnt);
move(PosBefore[0], pPosBef[0], length(pPosBef));
move(LastSeen[0], pSeen[0], length(pSeen));
{$ENDIF}
S_Idx := 0;
i := 1;
actnum := 0;
repeat
// save value
pSeen[S_Idx] := actnum;
S_Idx := (S_Idx + 1) and MAXSEENIDX;
//examine new value often out of cache
Posi := pPosBef[actnum];
pPosBef[actnum] := i;
// if Posi=0 ? actnum = 0:actnum = i-Posi
if Posi = 0 then
actnum := 0
else
actnum := i - Posi;
inc(i);
until i > MaxTestCnt;
HaveSeen := i - 1;
SeenIdx := S_Idx;
{$IFNDEF FPC}
move(pPosBef[0], PosBefore[0], length(pPosBef));
move(pSeen[0], LastSeen[0], length(pSeen));
{$ENDIF}
end;
Begin
Test(10) ; OutSeen(10000);
Test(1000); OutSeen(10);
Test(MAXNUM); OutSeen(28);
setlength(PosBefore,0);
end.

36
Task/Van-Eck-sequence/Perl/van-eck-sequence.pl Normal file
View file

@ -0,0 +1,36 @@
use strict;
use warnings;
use feature 'say';
sub van_eck {
my($init,$max) = @_;
my(%v,$k);
my @V = my $i = $init;
for (1..$max) {
$k++;
my $t = $v{$i} ? $k - $v{$i} : 0;
$v{$i} = $k;
push @V, $i = $t;
}
@V;
}
for (
['A181391', 0],
['A171911', 1],
['A171912', 2],
['A171913', 3],
['A171914', 4],
['A171915', 5],
['A171916', 6],
['A171917', 7],
['A171918', 8],
) {
my($seq, $start) = @$_;
my @seq = van_eck($start,1000);
say <<~"END";
Van Eck sequence OEIS:$seq; with the first term: $start
First 10 terms: @{[@seq[0 .. 9]]}
Terms 991 through 1000: @{[@seq[990..999]]}
END
}

15
Task/Van-Eck-sequence/Phix/van-eck-sequence.phix Normal file
View file

@ -0,0 +1,15 @@
(phixonline)-->
<span style="color: #008080;">constant</span> <span style="color: #000000;">lim</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">1000</span>
<span style="color: #004080;">sequence</span> <span style="color: #000000;">van_eck</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">repeat</span><span style="color: #0000FF;">(</span><span style="color: #000000;">0</span><span style="color: #0000FF;">,</span><span style="color: #000000;">lim</span><span style="color: #0000FF;">),</span>
<span style="color: #000000;">pos_before</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">repeat</span><span style="color: #0000FF;">(</span><span style="color: #000000;">0</span><span style="color: #0000FF;">,</span><span style="color: #000000;">lim</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">for</span> <span style="color: #000000;">n</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #000000;">lim</span><span style="color: #0000FF;">-</span><span style="color: #000000;">1</span> <span style="color: #008080;">do</span>
<span style="color: #004080;">integer</span> <span style="color: #000000;">vn</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">van_eck</span><span style="color: #0000FF;">[</span><span style="color: #000000;">n</span><span style="color: #0000FF;">]+</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span>
<span style="color: #000000;">prev</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">pos_before</span><span style="color: #0000FF;">[</span><span style="color: #000000;">vn</span><span style="color: #0000FF;">]</span>
<span style="color: #008080;">if</span> <span style="color: #000000;">prev</span><span style="color: #0000FF;">!=</span><span style="color: #000000;">0</span> <span style="color: #008080;">then</span>
<span style="color: #000000;">van_eck</span><span style="color: #0000FF;">[</span><span style="color: #000000;">n</span><span style="color: #0000FF;">+</span><span style="color: #000000;">1</span><span style="color: #0000FF;">]</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">n</span> <span style="color: #0000FF;">-</span> <span style="color: #000000;">prev</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
<span style="color: #000000;">pos_before</span><span style="color: #0000FF;">[</span><span style="color: #000000;">vn</span><span style="color: #0000FF;">]</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">n</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"The first ten terms of the Van Eck sequence are:%v\n"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">van_eck</span><span style="color: #0000FF;">[</span><span style="color: #000000;">1</span><span style="color: #0000FF;">..</span><span style="color: #000000;">10</span><span style="color: #0000FF;">]})</span>
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"Terms 991 to 1000 of the sequence are:%V\n"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">van_eck</span><span style="color: #0000FF;">[</span><span style="color: #000000;">991</span><span style="color: #0000FF;">..</span><span style="color: #000000;">1000</span><span style="color: #0000FF;">]})</span>
<!--

13
Task/Van-Eck-sequence/Picat/van-eck-sequence-1.picat Normal file
View file

@ -0,0 +1,13 @@
main =>
Limit = 1000,
A = new_array(Limit+1),
bind_vars(A,0),
foreach(N in 1..Limit-1)
M = find_last_of(A[1..N],A[N+1]),
if M > 0 then
A[N+2] := N-M+1
end
end,
println(A[1..10]),
println(A[991..1000]),
nl.

11
Task/Van-Eck-sequence/Picat/van-eck-sequence-2.picat Normal file
View file

@ -0,0 +1,11 @@
main =>
L = a(1000),
println(L[1..10]),
println(L[991..1000]),
nl.
a(0) = {0}.
a(1) = {0,0}.
a(N) = A ++ {cond(M > 0, N-M, 0)} =>
A = a(N-1),
M = find_last_of(slice(A,1,N-1),A.last).

48
Task/Van-Eck-sequence/Prolog/van-eck-sequence.pro Normal file
View file

@ -0,0 +1,48 @@
van_eck_init(v(0, 0, _assoc)):-
empty_assoc(_assoc).
van_eck_next(v(Index, Last_term, Last_pos), v(Index1, Next_term, Last_pos1)):-
(get_assoc(Last_term, Last_pos, V) ->
Next_term is Index - V
;
Next_term = 0
),
Index1 is Index + 1,
put_assoc(Last_term, Last_pos, Index, Last_pos1).
van_eck_sequence(N, Seq):-
van_eck_init(V),
van_eck_sequence(N, V, Seq).
van_eck_sequence(0, _, []):-!.
van_eck_sequence(N, V, [Term|Rest]):-
V = v(_, Term, _),
van_eck_next(V, V1),
N1 is N - 1,
van_eck_sequence(N1, V1, Rest).
write_list(From, To, _, _):-
To < From,
!.
write_list(_, _, _, []):-!.
write_list(From, To, N, [_|Rest]):-
From > N,
!,
N1 is N + 1,
write_list(From, To, N1, Rest).
write_list(From, To, N, [E|Rest]):-
writef('%t ', [E]),
F1 is From + 1,
N1 is N + 1,
write_list(F1, To, N1, Rest).
write_list(From, To, List):-
write_list(From, To, 1, List),
nl.
main:-
van_eck_sequence(1000, Seq),
writeln('First 10 terms of the Van Eck sequence:'),
write_list(1, 10, Seq),
writeln('Terms 991 to 1000 of the Van Eck sequence:'),
write_list(991, 1000, Seq).

12
Task/Van-Eck-sequence/Python/van-eck-sequence-1.py Normal file
View file

@ -0,0 +1,12 @@
def van_eck():
n, seen, val = 0, {}, 0
while True:
yield val
last = {val: n}
val = n - seen.get(val, n)
seen.update(last)
n += 1
#%%
if __name__ == '__main__':
print("Van Eck: first 10 terms: ", list(islice(van_eck(), 10)))
print("Van Eck: terms 991 - 1000:", list(islice(van_eck(), 1000))[-10:])

12
Task/Van-Eck-sequence/Python/van-eck-sequence-2.py Normal file
View file

@ -0,0 +1,12 @@
def van_eck():
n = 0
seen = [0]
val = 0
while True:
yield val
if val in seen[1:]:
val = seen.index(val, 1)
else:
val = 0
seen.insert(0, val)
n += 1

99
Task/Van-Eck-sequence/Python/van-eck-sequence-3.py Normal file
View file

@ -0,0 +1,99 @@
'''Van Eck sequence'''
from functools import reduce
from itertools import repeat
# vanEck :: Int -> [Int]
def vanEck(n):
'''First n terms of the van Eck sequence.'''
return churchNumeral(n)(
lambda xs: cons(
maybe(0)(succ)(
elemIndex(xs[0])(xs[1:])
)
)(xs) if xs else [0]
)([])[::-1]
# TEST ----------------------------------------------------
def main():
'''Terms of the Van Eck sequence'''
print(
main.__doc__ + ':\n\n' +
'First 10: '.rjust(18, ' ') + repr(vanEck(10)) + '\n' +
'991 - 1000: '.rjust(18, ' ') + repr(vanEck(1000)[990:])
)
# GENERIC -------------------------------------------------
# Just :: a -> Maybe a
def Just(x):
'''Constructor for an inhabited Maybe (option type) value.
Wrapper containing the result of a computation.
'''
return {'type': 'Maybe', 'Nothing': False, 'Just': x}
# Nothing :: Maybe a
def Nothing():
'''Constructor for an empty Maybe (option type) value.
Empty wrapper returned where a computation is not possible.
'''
return {'type': 'Maybe', 'Nothing': True}
# churchNumeral :: Int -> (a -> a) -> a -> a
def churchNumeral(n):
'''n applications of a function
'''
return lambda f: lambda x: reduce(
lambda a, g: g(a), repeat(f, n), x
)
# cons :: a -> [a] -> [a]
def cons(x):
'''Construction of a list from a head and a tail.
'''
return lambda xs: [x] + xs
# elemIndex :: Eq a => a -> [a] -> Maybe Int
def elemIndex(x):
'''Just the index of the first element in xs
which is equal to x,
or Nothing if there is no such element.
'''
def go(xs):
try:
return Just(xs.index(x))
except ValueError:
return Nothing()
return go
# maybe :: b -> (a -> b) -> Maybe a -> b
def maybe(v):
'''Either the default value v, if m is Nothing,
or the application of f to x,
where m is Just(x).
'''
return lambda f: lambda m: v if None is m or m.get('Nothing') else (
f(m.get('Just'))
)
# succ :: Enum a => a -> a
def succ(x):
'''The successor of a value.
For numeric types, (1 +).
'''
return 1 + x
# MAIN ---
if __name__ == '__main__':
main()

79
Task/Van-Eck-sequence/Python/van-eck-sequence-4.py Normal file
View file

@ -0,0 +1,79 @@
'''Van Eck series by map-accumulation'''
from functools import reduce
from itertools import repeat
# vanEck :: Int -> [Int]
def vanEck(n):
'''First n terms of the vanEck sequence.'''
def go(xns, i):
x, ns = xns
prev = ns[x]
v = i - prev if 0 is not prev else 0
return (
(v, insert(ns, x, i)),
v
)
return [0] + mapAccumL(go)((0, list(repeat(0, n))))(
range(1, n)
)[1]
# -------------------------- TEST --------------------------
# main :: IO ()
def main():
'''The last 10 of the first N vanEck terms'''
print(
fTable(main.__doc__ + ':\n')(
lambda m: 'N=' + str(m), repr,
lambda n: vanEck(n)[-10:], [10, 1000, 10000]
)
)
# ----------------------- FORMATTING -----------------------
# fTable :: String -> (a -> String) ->
# (b -> String) -> (a -> b) -> [a] -> String
def fTable(s):
'''Heading -> x display function -> fx display function ->
f -> xs -> tabular string.
'''
def go(xShow, fxShow, f, xs):
ys = [xShow(x) for x in xs]
w = max(map(len, ys))
return s + '\n' + '\n'.join(map(
lambda x, y: y.rjust(w, ' ') + ' -> ' + fxShow(f(x)),
xs, ys
))
return go
# ------------------------ GENERIC -------------------------
# insert :: Array Int -> Int -> Int -> Array Int
def insert(xs, i, v):
'''An array updated at position i with value v.'''
xs[i] = v
return xs
# mapAccumL :: (acc -> x -> (acc, y)) -> acc -> [x] -> (acc, [y])
def mapAccumL(f):
'''A tuple of an accumulation and a list derived by a
combined map and fold,
with accumulation from left to right.
'''
def go(a, x):
tpl = f(a[0], x)
return (tpl[0], a[1] + [tpl[1]])
return lambda acc: lambda xs: (
reduce(go, xs, (acc, []))
)
# MAIN ---
if __name__ == '__main__':
main()

9
Task/Van-Eck-sequence/Quackery/van-eck-sequence.quackery Normal file
View file

@ -0,0 +1,9 @@
[ ' [ 0 ]
swap 1 - times
[ dup behead swap find
1+ 2dup swap found *
swap join ]
reverse ] is van-eck ( n --> [ )
10 van-eck echo cr
1000 van-eck -10 split echo drop

10
Task/Van-Eck-sequence/REXX/van-eck-sequence-1.rexx Normal file
View file

@ -0,0 +1,10 @@
/*REXX pgm generates/displays the 'start ──► end' elements of the Van Eck sequence.*/
parse arg LO HI $ . /*obtain optional arguments from the CL*/
if LO=='' | LO=="," then LO= 1 /*Not specified? Then use the default.*/
if HI=='' | HI=="," then HI= 10 /* " " " " " " */
if $=='' | $=="," then $= 0 /* " " " " " " */
$$=; z= $ /*$$: old seq: $: initial value of seq*/
do HI-1; z= wordpos( reverse(z), reverse($$) ); $$= $; $= $ z
end /*HI-1*/ /*REVERSE allows backwards search in $.*/
/*stick a fork in it, we're all done. */
say 'terms ' LO " through " HI ' of the Van Eck sequence are: ' subword($,LO,HI-LO+1)

14
Task/Van-Eck-sequence/REXX/van-eck-sequence-2.rexx Normal file
View file

@ -0,0 +1,14 @@
/*REXX pgm generates/displays the 'start ──► end' elements of the Van Eck sequence.*/
parse arg LO HI sta . /*obtain optional arguments from the CL*/
if LO=='' | LO=="," then LO= 1 /*Not specified? Then use the default.*/
if HI=='' | HI=="," then HI= 10 /* " " " " " " */
if sta=='' | sta=="," then sta= 0 /* " " " " " " */
$.0= sta; x= sta; @.=. /*$.: the Van Eck sequence as a list.*/
do #=1 for HI-1 /*X: is the last term being examined. */
if @.x==. then do; @.x= #; $.#= 0; x= 0; end /*new term.*/
else do; z= # - @.x; $.#= z; @.x= #; x= z; end /*old term.*/
end /*#*/ /*Z: the new term being added to list.*/
LOw= LO - 1; out= $.LOw /*initialize the output value. */
do j=LO to HI-1; out= out $.j /*build a list for the output display. */
end /*j*/ /*stick a fork in it, we're all done. */
say 'terms ' LO " through " HI ' of the Van Eck sequence are: ' out

16
Task/Van-Eck-sequence/Racket/van-eck-sequence.rkt Normal file
View file

@ -0,0 +1,16 @@
#lang racket
(require racket/stream)
(define (van-eck)
(define (next val n seen)
(define val1 (- n (hash-ref seen val n)))
(stream-cons val (next val1 (+ n 1) (hash-set seen val n))))
(next 0 0 (hash)))
(define (get m n s)
(stream->list
(stream-take (stream-tail s m)
(- n m))))
"First 10 terms:" (get 0 10 (van-eck))
"Terms 991 to 1000 terms:" (get 990 1000 (van-eck)) ; counting from 0

33
Task/Van-Eck-sequence/Raku/van-eck-sequence.raku Normal file
View file

Internal server error - Forgejo: Beyond coding. We Forge.

500

Internal server error

Forgejo version: 11.0.14+gitea-1.22.0

 @ -0,0 +1,33 @@
sub n-van-ecks ($init) {
$init, -> $i, {
state %v;
state $k;
$k++;
my $t = %v{$i}.defined ?? $k - %v{$i} !! 0;
%v{$i} = $k;
$t
} ... *
}
for <
A181391 0
A171911 1
A171912 2
A171913 3
A171914 4
A171915 5
A171916 6
A171917 7
A171918 8
> -> $seq, $start {
my @seq = n-van-ecks($start);
# The task