输出Van Eck序列的第N个项。

Van Eck序列定义为：

• 从0开始。
• 如果最后一项是该项的首次出现，则下一项为0。
• 如果上一个术语先前已发生，则下一个术语是最近一次发生的退后几步。

https://oeis.org/A181391

https://www.youtube.com/watch?v=etMJxB-igrc

https://www.youtube.com/watch?v=8VrnqRU7BVU

顺序：0,0,1,0,2,0,2,2,1,6,0,5,0,2，...

测试：

输入| 输出量

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

编辑

首选1索引，可接受0索引；这可能会改变一些已经提交的解决方案。

请只是第N个学期。

相同（除了看到已经发布的部分），似乎代码高尔夫球手和亲密电视爱好者之间有相当大的重叠。

JavaScript（ES6）， 46 41  37字节

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

在线尝试！

怎么样？

我们不需要存储完整序列。我们只需要跟踪序列中出现的每个整数的最后位置。为此，我们使用递归函数的基础对象。$g$

对于给定的项，我们不需要将设置为其序列中的实际绝对位置，因为我们只对与当前位置的距离感兴趣。这就是为什么我们可以只存储输入的当前值，该值在代码中用作递减计数器。$p$$g[p]$$n$

因此，该距离由。方便的是，如果这是的首次出现，则此值为NaN，可以很容易地将其转换为预期的。$g[p]-n$p 0$p$$0$

已评论

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中，69个 63 62字节

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

在线尝试！

_{注意：正如Outgolfer的Erik所提到的，此代码在Python 2中也能正常工作。}

0索引（尽管完全不正确，您可以通过更改if n为if~n：P 使其成为-1索引）

利用Python出色的解压缩“明星算子”，以递归方式建立系列，直至n达到零。

该函数以相反的顺序构建序列，以避免为了搜索而不得不将其反转。此外，它实际上存储了所有元素的取反，因为最后将它们转换回是免费的（否则，-它们本来必须是一个空格），并且通过使用~s.index(l)代替来节省了我们一个字节-~s.index(l)。

如果Python元组具有与find字符串相同的功能（可能会返回-1，而不是引发错误），则可能为51个字节，但是没有这种运气...

R，62个字节

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

在线尝试！

反向建立列表；match返回（列表的其余部分）中（先前值）的第一个索引，如果未找到匹配项，则返回。F[1]F[-1]0

F在循环的第一遍被初始化为FALSE并被强制为。0while

Perl 6的，47 42个字节

-5字节归功于nwellnhof

{({+grep(@_[*-1],:k,[R,] @_)[1]}...*)[$_]}

在线尝试！

匿名代码块，该代码块输出序列中的0索引元素。

说明：

{                                            } # 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

Bourne Shell，102个字节

until [ 0"$i" -eq $1 ];do i=$((${i:-0}+1)) a=${n:-0};eval 'n=$(($i-${m'$a:-$i'}))' m$a=$i;done;echo $a

在线尝试

Stax，10 9 字节

é"▬π²"ô↕j

运行并调试

如果允许从0开始的索引：

Stax，8 个字节

à┐æ8Å/[┤

运行并调试

J，²⁹ 23字节

1{(,~#|1+}.i.{.)@]^:[&0

在线尝试！

真正的工作是在幂动词的迭代动词中完成的，该动词^:迭代次数为自变量多次[，并从常数值0开始迭代&0...

• (#|1+}.i.{.)这就是迭代。分解...
• }.i.{.i.在列表{.的末尾找到列表头的索引}.。这将返回从0开始的索引，因此，如果当前项在上一个之前被发现，它将返回0。如果未找到，则将返回列表的长度，即尾部的长度。
• 1+由于Ven Eck的“多远”是基于1的，因此将值加1可以更正基于0的索引。请注意，如果找不到，则该值现在将是完整列表的长度。
• #|当除以完整列表的长度时，返回上一步中计算出的值的余数。请注意，这会将“未找到”变为0，但所有其他值保持不变。
• ,~将新值追加到列表的前面。为了方便起见，我们使用正面而不是最后。
• 1{ 返回列表中的第二个项目，因为我们计算了太多次，因为这种方式更短。

Python，51字节

f=lambda n,i=1:n>i and[f(n,i+1),i][f(n-1)==f(n+~i)]

在线尝试！

输出False的0。从字面上实现规范，寻找最低的正整数，i例如f(n-1)==f(n-i-1)。如果这样的搜索导致i>=n以前的元素以前没有出现，我们就产生了0。

该函数不会执行诸如将早期值存储在列表中之类的合理操作，而是仅在需要时（有时在不需要时）从头开始递归地重新计算它们。这使得该功能对于输入大于10的输入非常慢。

APL（Dyalog Unicode），19个 17 字节^SBCS

非常感谢ngn，Adám，Richard Park和H.PWiz在The APL Orchard（这是学习APL并获得APL帮助的好地方）的写作和打高尔夫球方面的帮助。

编辑：从Adám-2个字节。

⊃(⊢,⍨≢|1∘↓⍳⊃)⍣⎕-1

在线尝试！

说明

⊃(⊢,⍨≢|1∘↓⍳⊃)⍣⎕-1

                 -1  We initialize our array of results with -1.
 (           )⍣⎕    ⍣ repeats the train (in parentheses) our input, ⎕, times.
        1∘↓⍳⊃        We take the index of the head (our last element in the sequence).
                     To signify "element not found", this returns the length of the array.
      ≢|             We take our index modulo the length of the array.
                     This turns our "element not found" from the length of the array to 0.
  ⊢,⍨                And we prepend to our array.
⊃                    Finally, we return the first element of the array,
                     which is the most recently-generated.
                     This is the ⍵-th element of the Van Eck sequence.

Wolfram语言（Mathematica），48个字节

#<1||Last[#-1-Array[#0,#-2]~Position~#0[#-1],0]&

在线尝试！

非零值作为单例列表返回。

05AB1E，8 个字节

F¯Rćk>Dˆ

$n$

说明：

F         # Loop the (implicit) input amount of times:
 ¯        #  Push the global array
  R       #  Reverse it
   ć      #  Extract the head; push the remainder and the head to the stack
    k     #  Get the 0-based index of the head in the remainder (-1 if not found)
     >    #  Increase it by 1 to make it 1-indexed (or 0 if not found)
      Dˆ  #  Add a copy to the global array
          # (after the loop, output the top of the stack implicitly as result,
          #  which is why we need the `D`/duplicate)

Java，96 80 76字节

n->{int i,v=0,m[]=new int[n];for(;--n>0;m[v]=n,v=i<1?0:i-n)i=m[v];return v;}

不混淆：

Function<Integer, Integer> vanEck =
n -> {

    int i;                  // i is the value of n when v was previously encountered
    int v = 0;              // v is the current element of vanEck sequence
    int[] m = new int[n];   // m[v] is the value of n when v was previously encountered

    while (--n > 0) {       // n is used as a decrementing counter

        i = m[v];
        m[v] = n;
        v = i == 0 ? 0 : i - n;
    }

    return v;
};

木炭，23字节

≔⁰θＦ⊖Ｎ«≔⊕⌕⮌υθη⊞υθ≔ηθ»Ｉθ

在线尝试！链接是详细版本的代码。说明：

≔⁰θ

将第一项设置为0。

Ｆ⊖Ｎ«

循环n-1时间。（如果可接受0索引，则⊖可以将其删除以节省1个字节。）

≔⊕⌕⮌υθη

下一项是前一项的反向列表中当前项的递增索引。

⊞υθ

将当前术语添加到以前的术语列表中。

≔ηθ

将当前术语设置为下一个术语。

»Ｉθ

在循环末尾打印当前项。

果冻，7个字节

Ḷ߀ṚiḢ$

在线尝试！

0索引。

果冻，8 字节

ẎiḢ$;µ¡Ḣ

$n$$n^{th}$

在线尝试！

怎么样？

ẎiḢ$;µ¡Ḣ - Link: n
     µ¡  - repeat this monadic link n times - i.e. f(f(...f(n)...)):
         - (call the current argument L)
Ẏ        -   tighten (ensures we have a copy of L, so that Ḣ doesn't alter it)
   $     -   last two links as a monad:
  Ḣ      -     head (pop off & yield leftmost of the copy)
 i       -     first index (of that in the rest) or 0 if not found
    ;    -   concatenate with L
       Ḣ - head

请注意，没有决赛，Ḣ我们实际上已经收集了[a(n), a(n-1), ..., a(2), a(1), n]

C（gcc），63个字节

f(n){n=g(n,--n);}g(n,i){n=n>0?f(--n)-f(i)?g(n,i)+!!g(n,i):1:0;}

在线尝试！

0索引。

Haskell，68 67 66字节

相当简单的实现（使用基于0的索引）。

f n|all((/=f(n-1)).f)[0..n-2]=0|m<-n-1=[k|k<-[1..],f(m-k)==f m]!!0

在线尝试！

Haskell，61个字节

(([]#0)1!!)
(l#n)i=n:(((n,i):l)#maybe 0(i-)(lookup n l))(i+1)

基于0的索引。

在线尝试！

Japt -h，11个字节

@ÒZÔÅbX}hTo

试试吧

C＃（Visual C＃交互式编译器），77字节

n=>{int i,v=0;for(var m=new int[n];--n>0;m[v]=n,v=i<1?0:i-n)i=m[v];return v;}

在线尝试！

在这一点上，Java答案几乎是端口。

Python 3中，128个 114 111 102 99字节

102-> 99个字节，感谢Jonathan Frech

f=lambda n,i=1,l=[0]:f(n,i+1,l+[l[i-2::-1].index(l[-1])+1if l[-1]in l[:-1]else 0])if n>i else l[-1]

在线尝试！

Perl 5（-p），42个字节

map{($\,$\{$\})=0|$\{$\};$_++for%\}1..$_}{

在线尝试！

Python 3，112字节

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])

在线尝试！

-3个字节归功于mypetlion

红色，106 95字节

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]

在线尝试！

CJam（15字节）

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

在线演示。这是一个完整的程序，索引为0。

解剖

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个字节

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

可悲的是，一种更实用的方法似乎更长。

DC，94 91 90字节

在程序执行期间进行输入。将其保存到文件，然后执行“ dc”运行。绝对不是最短的，但我对DC中的此类挑战感到很开心。输入是基于1的索引，这是首选。

[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），241 235 234 219 197 189字节

197-> 189字节，感谢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];}

在线尝试！

Pyth，18个字节

VQ=Y+?YhxtYhY0Y;hY

在线尝试！

反向建立序列并打印第一个元素（序列的最后一项）。

VQ                 # for N in range(Q) (Q=input)
  =Y+         Y    # Y.prepend(
        xtY        #   Y[1:].index(    )
           hY      #               Y[0]
       h           #                     +1
     ?Y      0     #                        if Y else 0)
               ;hY # end for loop and print Y[0]