Van Eck 시퀀스의 N 번째 항을 출력합니다.

Van Eck Sequence는 다음과 같이 정의됩니다.

• 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 학기 만주세요.

코드 골퍼와 숫자 파수꾼은 이미 중첩 된 부분을 제외하고는 똑같습니다.

자바 스크립트 (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

파이썬 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- 인덱싱 (완전히 왜곡 되기는하지만 : P 로 변경 if n하여 1- 인덱싱 할 수 있음 if~n)

파이썬의 화려한 포장 풀기 "별 연산자"를 사용하여 n0에 도달 할 때까지 시리즈를 재귀 적으로 구축합니다 .

이 기능은 검색을 위해 역순을 피하기 위해 역순으로 계열을 구성합니다. 또한 실제로 모든 요소의 부정을 저장합니다. 왜냐하면 마지막에 다시 변환하는 것이 자유 롭기 때문에 ( -공간이 아니 어야 했음) ~s.index(l)대신 대신 사용하여 바이트를 절약 할 수 있기 때문 입니다 -~s.index(l).

파이썬 튜플과 동일한 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

펄 6 , 47 42 바이트

nwellnhof 덕분에 -5 바이트

{({+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 쉘, 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

온라인으로 사용해보십시오!

실제 작업은 power verb의 반복 동사에서 수행되며 ^:인수는 여러 번 [반복되며 상수 값 0으로 반복을 시작합니다 &0...

• (#|1+}.i.{.)이것이 반복되는 것입니다. 그것을 분해 ...
• }.i.{.i.목록 {.의 꼬리 에서 목록의 머리의 색인을 찾으십시오 }.. 이것은 0부터 시작하는 색인을 리턴하므로 현재 항목이 1 이전에 발견되면 0을 리턴합니다. 발견되지 않으면 목록의 길이, 즉 꼬리의 길이를 리턴합니다.
• 1+Ven Eck의 "얼마나 멀리"가 1 기반이므로 0 기반 색인화를 정정하려면 값에 1을 추가하십시오. 찾을 수 없으면 값이 전체 목록의 길이가됩니다.
• #|전체 목록의 길이로 나눈 경우 이전 단계에서 계산 된 나머지 값을 반환합니다. 이렇게하면 "찾을 수 없음"이 0으로 바뀌지 만 다른 모든 값은 변경되지 않습니다.
• ,~새로운 값을 목록 앞에 추가하십시오. 우리는 단지 편의를 위해 마지막보다 앞면을 사용합니다.
• 1{ 두 번째 항목은 너무 짧아 계산했기 때문에 목록의 두 번째 항목을 반환합니다.

파이썬 , 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

APL 을 배우고 APL의 도움을받을 수있는 좋은 장소 인 APL Orchard 에서이 답변을 작성하고 골프를 치는 데 도움을 주신 ngn, Adám, Richard Park 및 H.PWiz에게 많은 감사를드립니다 .

편집 : 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 Language (Mathematica) , 48 바이트

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

온라인으로 사용해보십시오!

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)

자바, 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입니다.

하스켈 , 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

온라인으로 사용해보십시오!

하스켈, 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의 포트가 거의 응답합니다.

파이썬 (3) , 128 (114) 111 (102) 99 바이트

Jonathan Frech 덕분에 102-> 99 바이트

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]

온라인으로 사용해보십시오!

펄 5 ( -p), 42 바이트

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

온라인으로 사용해보십시오!

파이썬 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])

온라인으로 사용해보십시오!

mypetlion 덕분에 -3 바이트

빨간색 , 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

클로저, 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 ++ (연타) , 241 (235) 234 219 197 189 바이트

ceilingcat 덕분에 197-> 189 바이트

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