# Nth term of Van Eck Sequence

Output the Nth term of the Van Eck Sequence.

Van Eck Sequence is defined as:

• Starts with 0.
• If the last term is the first occurrence of that term the next term is 0.
• If the last term has occurred previously the next term is how many steps back was the most recent occurrence.

https://oeis.org/A181391

Sequence: 0,0,1,0,2,0,2,2,1,6,0,5,0,2,...

Tests:

Input | Output

• 1 | 0
• 8 | 2
• 19 | 5
• 27 | 9
• 52 | 42
• 64 | 0

EDIT

1 indexed is preferred, 0 indexed is acceptable; that might change some of the already submitted solutions.

Same (except for the seeing it already posted part), it seems code golfers and numberphile watchers have a decent overlap.

• Watched the numpherphile video at work and was going to post this when I got home. Curse you for getting there first. :P – Draco18s Jun 10 at 21:27
• Does it have to be 1-indexed, or may we use 0-indexing? – Robin Ryder Jun 10 at 22:02
• May we return or output the infinite sequence instead? – Jo King Jun 11 at 2:10
• ... or the first n terms? – Shaggy Jun 11 at 15:11
• @Draco18s Same, I came here to post it after seeing the Numberphile video, when I saw this. – Geza Kerecsenyi Jun 11 at 16:52

# JavaScript (ES6),  46 41  37 bytes

n=>(g=p=>--n?g(g[p]-n|0,g[p]=n):p)(0)

Try it online!

### How?

We don't need to store the full sequence. We only need to keep track of the last position of each integer that appears in the sequence. We use the underlying object of the recursive function $$\g\$$ for that purpose.

For a given term $$\p\$$, we don't need either to set $$\g[p]\$$ to its actual absolute position in the sequence because we're only interested in the distance with the current position. That's why we can just store the current value of the input $$\n\$$, which is used as a decrementing counter in the code.

Therefore, the distance is given by $$\g[p]-n\$$. Conveniently, this evaluates to NaN if this is the first occurrence of $$\p\$$, which can be easily turned into the expected $$\0\$$.

### Commented

n => (             // n = input
g = p =>         // g = recursive function taking p = previous term of the sequence
//     g is also used as an object to store the last position of
//     each integer found in the sequence
--n ?          // decrement n; if it's not equal to 0:
g(           //   do a recursive call:
g[p] - n   //     subtract n from the last position of p
//     if g[p] is undefined, the above expression evaluates to NaN
| 0,       //     in which case we coerce it to 0 instead
g[p] = n   //     update g[p] to n
)            //   end of recursive call
:              // else:
p            //   we've reached the requested term: stop recursion and return it
)(0)               // initial call to g with p = 0

# Python 3, 6963 62 bytes

f=lambda n,l=0,*s:f(n-1,l in s and~s.index(l),l,*s)if n else-l

Try it online!

Note: as Erik the Outgolfer mentioned, this code works fine in Python 2 as well.

0-indexed (although, just to be utterly perverse, you can make it -1-indexed by changing if n to if~n :P)

Makes use of Python's gorgeous unpacking "star operator", to recursively build up the series, until n reaches zero.

The function builds up the series in the reverse order, to avoid having to reverse it for the search. Additionally, it actually stores the negations of all the elements, because converting them back at the end was free (else the - would have had to be a space) and it saves us a byte along the way, by using ~s.index(l) instead of -~s.index(l).

Could be 51 bytes if Python tuples had the same find functions strings do (returning -1 if not found, instead of raising an error), but no such luck...

• Actually, the "star operator" you're using isn't Python 3's unpacking operator, but rather the vararg operator which also exists in Python 2. – Erik the Outgolfer Jun 10 at 22:56
• The first one is, but isn't the second one unpacking s for the recursive call? – ArBo Jun 10 at 23:08
• I've tested it in Python 2 and it works. – Erik the Outgolfer Jun 11 at 11:06
• @EriktheOutgolfer hmm, but isn't the second use unpacking though? The function doesn't have to support varargs to use such syntax. – ArBo Jun 11 at 12:43
• @ArBo: It's no different than def func(f, *args): f(*args); unpacking inside function calls is valid py2. What's py3-only is unpacking inside list/dict comprehensions (i.e. [1, 2, *s]) or unpacking variables: a, *b = [1,2,3,4]. – Ehsan Kia Jun 13 at 17:27

# R, 62 bytes

function(n){while(sum(F|1)<n)F=c(match(F[1],F[-1],0),F)
+F[1]}

Try it online!

Builds the list in reverse; match returns the first index of F[1] (the previous value) in F[-1] (the remainder of the list), returning 0 if no match is found.

F is initialized to FALSE and is coerced to 0 on the first pass of the while loop.

• I'm kind of in awe of how good match is for this problem when you construct it this way. Really clean. – CriminallyVulgar Jun 12 at 9:50
• Does the plus on the second line do anything here? I assumed it fixed an edge case, but I can't find one for it. – CriminallyVulgar Jun 12 at 9:56
• @CriminallyVulgar it should coerce F to 0 when n==1 else it would return FALSE. – Giuseppe Jun 12 at 11:20
• Ahh, I see. Makes sense, I was trying lots of ranges but not the single value. – CriminallyVulgar Jun 12 at 12:20

# Perl 6, 47 42 bytes

-5 bytes thanks to nwellnhof

{({+grep(@_[*-1],:k,[R,] @_)[1]}...*)[$_]} Try it online! Anonymous codeblock that outputs the 0-indexed element in the sequence. ### Explanation: { } # Anonymous codeblock ( )[$_]  # Return the nth element
...*       # Of the infinite sequence
{                            }  # Where each element is
grep(        :k        )[1]   # The key of the second occurrence
@_[*-1],                 # Of the most recent element
,[R,] @_       # In the reversed sequence so far
+     # And numify the Nil to 0 if the element is not found

Try it online!

0-indexed.

# Jelly, 8 bytes

ẎiḢ$;µ¡Ḣ A monadic Link accepting a positive integer, $$\n\$$, which yields the $$\n^{th}\$$ term of the Van Eck Sequence. Try it online! ### How? ẎiḢ$;µ¡Ḣ - Link: n
- (call the current argument L)
Ẏ        -   tighten (ensures we have a copy of L, so that Ḣ doesn't alter it)

Try it online!

# Python 3, 112 bytes

a=[0]
for _ in a*int(input()):k=a[-1];a+=k in a[:-1]and[a[::-1].index(k)+~a[-2::-1].index(k)]or[0]
print(-a[-2])

Try it online!

-3 bytes thanks to mypetlion

• Second line can become for _ in a*int(input()):k=a[-1];a+=k in a[:-1]and[a[::-1].index(k)+~a[-2::-1].index(k)]or[0] to save 3 bytes. – mypetlion Jun 11 at 16:38
• @mypetlion thanks – HyperNeutrino Jun 11 at 16:52

# Red, 106 95 bytes

func[n][b: copy[0]loop n[insert b either not find t: next b
b/1[0][-1 + index? find t b/1]]b/2]

Try it online!

## CJam (15 bytes)

0a{_(#)\+}qi*0=

Online demo. This is a full program and 0-indexed.

### Dissection

0a      e# Push the array [0]
{       e# Loop...
_(#   e#   Copy the array, pop the first element, and find its index in the array
)\+   e#   Increment and prepend
}qi*    e# ... n times, where n is read from stdin
0=      e# Take the first element of the array

## Clojure, 69 bytes

#((fn f[i c t](if(= i 1)t(f(dec i)(assoc c t i)(-(or(c t)i)i))))%{}0)

Sadly a more functional approach seems to be longer.

# DC, 94 91 90 bytes

Input is taken during the program. Save this to a file and then do "dc " to run. Definitely not the shortest, but I have fun with challenges like these in dc. Input is 1-based index, as preferred.

[st1si0swlbxltlwlu1-sulu0!=m]sm[dlt=qSsli1+siz0!=b0siLs]sb[0pq]sf[lisw2Q]sq?2-dsu1>f0dlmxp

Main control macro
[st                         ]sm   save top value as target
[  1si0sw                   ]sm   reset i to 1 and w to 0
[        lbx                ]sm   execute macro b to get next value in w
[           ltlw            ]sm   restore target to the stack and add w to the stack
[               lu1-su      ]sm   decrement the user inputted variable
[                     lu0!=m]sm   if the user inputted variable is not 0 recurse

Next value finder macro
[dlt=q                  ]sb     if the value on the stack is the target, quit
[     Ss                ]sb     save top value to s register
[       li1+si          ]sb     increment i register
[             z0!=b     ]sb     recurse if still more values
[                  0si  ]sb     set i to 0 (will be saved to w if relevant)
[                     Ls]sb     move top value of s register to stack

[lisw2Q]sq   Load i, save it to w, and then quit this macro and the one that called it

[0pq]sf print 0 and quit the program
$$`$$

# C++ (clang), 241235234219197 189 bytes

197 -> 189 bytes, thanks to ceilingcat

#import<bits/stdc++.h>
int f(int n,int i=0,std::vector<int>l={0}){return~-n>i?l.push_back(find(begin(l),end(l)-1,l[i])-end(l)+1?find(rbegin(l)+1,rend(l),l[i])-rbegin(l):0),f(n,i+1,l):l[i];}

Try it online!