Van Eck Dizisinin 8. terimini çıkar.

Van Eck Dizisi şöyle tanımlanır:

• 0 ile başlar.
• Son terim, bu terimin ilk oluşuysa, sonraki terim 0'dır.
• Son terim daha önce gerçekleşmişse, bir sonraki terim en son ne zaman geri adım attığını belirtir.

https://oeis.org/A181391

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

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

Sıra: 0,0,1,0,2,0,2,2,1,6,0,5,0,2, ...

Testler:

Giriş | Çıktı

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

DÜZENLE

1 indekslenmiş tercih edilir, 0 indekslenmiş kabul edilebilir; Bu, zaten sunulan çözümlerin bir kısmını değiştirebilir.

Sadece 1. terim lütfen.

Aynı (zaten zaten yayınlanan kısmı görmek hariç), kod golfçüler ve sayı gözlemcilerinin iyi bir örtüşme var gibi görünüyor.

JavaScript (ES6),  46 41  37 bayt

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

Çevrimiçi deneyin!

Nasıl?

Tüm diziyi kaydetmemize gerek yok. Sadece dizide görünen her bir tamsayıdaki son konumunu takip etmemiz gerekir. Bu amaçla, özyinelemeli fonksiyonun $g$ nesnesini kullanırız .

Belirli bir $p$ terimi için , $g[p]$ yi dizideki asıl mutlak konumuna getirmemize gerek yoktur, çünkü sadece mevcut konumla olan mesafeyle ilgileniyoruz. Bu nedenle , kodda azalan bir sayaç olarak kullanılan $n$ girişinin geçerli değerini kaydedebiliriz .

Bu nedenle mesafe $g[p]-n$ . Elverişli bir şekilde, bu kolayca beklenen 0'a dönüştürülebilen ilk p oluşumu ise, NaN olarak değerlendirilir .$p$$0$

Yorumlananlar

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 bayt

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

Çevrimiçi deneyin!

_{Not: Outgolfer Erik'in dediği gibi, bu kod Python 2'de de iyi çalışıyor.}

0 endeksli (sadece tamamen ters olması, her ne kadar, bunu yapabilir değiştirerek -1 endeksli if niçin if~n: P)

Diziyi tekrar tekrar oluşturmak için nsıfıra ulaşana kadar Python'un muhteşem açma "yıldız operatörünü" kullanır .

İşlev, diziyi, arama için ters çevirmek zorunda kalmamak için ters sırayla oluşturur. Ayrıca sonunda geri dönüştürerek (başka özgür olduğu için, aslında, bütün elementlerin müzakerelerine depolayan -bir boşluk olmak zorunda olurdu) ve kullanarak, yol boyunca bize bir byte kaydeder ~s.index(l)yerine -~s.index(l).

Python tuples finddizeleri ile aynı işlevlere sahipse ( bayt , hata üretmek yerine -1 döndürüyorsa) 51 bayt olabilir , ancak böyle bir şans ...

R , 62 bayt

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

Çevrimiçi deneyin!

Listeyi tersten oluşturur; matchdöner ilk dizinini F[1](bir önceki değeri) F[-1]dönen (listenin kalan) 0bir eşleşme bulunursa,.

FFALSEDevrenin 0ilk geçişinde başlatılır ve zorlanır while.

Perl 6 , 47 42 bayt

Nwellnhof sayesinde -5 bayt

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

Çevrimiçi deneyin!

Dizideki 0 dizinli öğeyi çıkaran isimsiz kod bloğu.

Açıklama:

{                                            } # 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 kabuğu, 102 bayt

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

çevrimiçi dene

Stax , 10 9 bayt

é"▬π²"ô↕j

Koş ve hata ayıkla

0 tabanlı dizine izin verilirse:

Stax , 8 bayt

à┐æ8Å/[┤

Koş ve hata ayıkla

J , ²⁹ 23 bayt

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

Çevrimiçi deneyin!

Gerçek iş gücü fiilin fiil yineleme yapılır ^:argüman olarak çok kez yinelenir [sabit değer 0 ile yineleme başlayarak &0...

• (#|1+}.i.{.)İşte yinelediği şey bu. Yıkılıyor ...
• }.i.{.i.Listenin başının dizinini listenin {.kuyruğunda bulun }.. Bu 0 tabanlı bir dizini döndürür, bu nedenle eğer mevcut öğe daha önce 1 bulunursa, 0 değerini döndürür. Bulmazsa, listenin uzunluğunu, yani kuyruğun uzunluğunu döndürür.
• 1+Ven Eck'in "ne kadar geriye" 1 tabanlı olduğundan, 0 tabanlı dizinlemeyi düzeltmek için değere bir tane ekleyin. Bulunamadıysa, değerin şimdi tam listenin uzunluğu olacağını unutmayın.
• #|Tam listenin uzunluğuna bölündüğünde önceki adımda hesaplanan değerin kalanını döndür. Bunun "bulunamadı" yı 0'a çevirdiğini, ancak diğer tüm değerleri değişmeden bıraktığını unutmayın.
• ,~Yeni değeri listenin önüne ekleyin. Cepheyi sadece kolaylık sağlamak için kullanmak yerine kullanıyoruz.
• 1{ Listede 2. maddeyi geri getirin, çünkü çok fazla sayıda hesapladık, çünkü bu daha kısa.

Python , 51 bayt

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

Çevrimiçi deneyin!

Çıkışlar Falseiçin 0. Spesifik olarak oldukça basit bir şekilde uygular, iöyle ki en düşük pozitif tamsayıyı arar f(n-1)==f(n-i-1). Böyle bir arama yol açarsa i>=n, önceki öğe daha önce görünmedi ve biz0 .

Önceki değerleri bir listede saklamak gibi makul bir şey yapmak yerine, işlev yalnızca gerektiğinde sıfırdan tekrar tekrar hesaplar ve bazen de ihtiyaç duyulmadığında yeniden hesaplar. Bu, 10 veya daha üstündeki girişler için işlevi çok yavaş çalıştırır.

APL (Dyalog Unicode) , 19 17 bayt ^SBCS

APL'yi öğrenmek ve APL'den yardım almak için harika bir yer olan APL Orchard'da bu cevabı yazma ve golf oynamadaki yardımları için ngn, Adám, Richard Park ve H.PWiz'e teşekkür ederiz .

Düzenleme: Adám'dan -2 bayt.

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

Çevrimiçi deneyin!

açıklama

⊃(⊢,⍨≢|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 Dili (Mathematica) , 48 bayt

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

Çevrimiçi deneyin!

Sıfır olmayan değerler singleton listeleri olarak döndürülür .

05AB1E , 8 bayt

F¯Rćk>Dˆ

$n$

Açıklama:

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 bayt

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;}

Şaşkın değil:

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;
};

Kömür , 23 bayt

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

Çevrimiçi deneyin! Bağlantı, kodun ayrıntılı bir versiyonudur. Açıklama:

≔⁰θ

İlk terimi 0 olarak ayarlayın.

Ｆ⊖Ｎ«

Döngü n-1zamanları. (0-indekslemesi kabul edilebilir ise, ⊖1-byte tasarruf için kaldırılabilir.)

≔⊕⌕⮌υθη

Bir sonraki terim, önceki terimlerin tersine çevrilmiş listesindeki mevcut terimin artan dizinidir.

⊞υθ

Geçerli terimi önceki terimler listesine ekleyin.

≔ηθ

Geçerli terimi bir sonraki terime ayarlayın.

»Ｉθ

Geçerli terimi döngünün sonunda yazdırın.

Jöle , 7 bayt

Ḷ߀ṚiḢ$

Çevrimiçi deneyin!

0 endeksli.

Jöle , 8 bayt

ẎiḢ$;µ¡Ḣ

$n$$n^{th}$ Van Eck Sekans terimi.

Çevrimiçi deneyin!

Nasıl?

Ẏ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

Final olmadan Ḣtopladığımızı unutmayın[a(n), a(n-1), ..., a(2), a(1), n]

C (gcc) , 63 bayt

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

Çevrimiçi deneyin!

0 endeksli.

Haskell , 68 67 66 bayt

Oldukça basit uygulama (0 tabanlı indeksleme kullanarak).

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

Çevrimiçi deneyin!

Haskell, 61 bayt

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

0 tabanlı indeksleme.

Çevrimiçi deneyin!

Japt -h , 11 bayt

@ÒZÔÅbX}hTo

Dene

C # (Visual C # Etkileşimli Derleyici) , 77 bayt

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;}

Çevrimiçi deneyin!

Java'nın bir limanı hemen hemen bu noktada cevap veriyor.

Python 3 , 128 114 111 102 99 bayt

102 -> 99 bayt, Jonathan Frech sayesinde

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]

Çevrimiçi deneyin!

Perl 5 ( -p), 42 bayt

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

Çevrimiçi deneyin!

Python 3 , 112 bayt

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

Çevrimiçi deneyin!

Mypetlion sayesinde -3 bayt

Kırmızı , 106 95 bayt

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]

Çevrimiçi deneyin!

CJam (15 bayt)

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

Çevrimiçi demo . Bu tam bir program ve 0 dizinli.

teşrih

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 bayt

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

Ne yazık ki daha işlevsel bir yaklaşım daha uzun gibi görünüyor.

DC, 94 91 90 bayt

Program boyunca giriş yapılır. Bunu bir dosyaya kaydedin ve sonra çalıştırmak için "dc" yapın. Kesinlikle en kısa değil, ama dc gibi bu tür zorluklarla eğleniyorum. Giriş, tercih edildiği gibi 1 tabanlı bir dizindir.

[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 bayt

197 -> 189 bayt, ceilingcat sayesinde

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

Çevrimiçi deneyin!

Pyth , 18 bayt

VQ=Y+?YhxtYhY0Y;hY

Çevrimiçi deneyin!

Diziyi tersten oluşturur ve ilk elemanı yazdırır (dizinin son terimi).

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]