वैन एक सीक्वेंस का नौवां कार्यकाल

Question

वैन ईक सीक्वेंस के एनटी शब्द का आउटपुट।

वैन ईक सीक्वेंस को इस प्रकार परिभाषित किया गया है:

• 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,2,1,6,0,5,0,2, ...

टेस्ट:

इनपुट | उत्पादन

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

संपादित करें

1 अनुक्रमित को प्राथमिकता दी जाती है, 0 अनुक्रमित स्वीकार्य है; यह पहले से ही प्रस्तुत समाधानों में से कुछ को बदल सकता है।

कृपया केवल Nth शब्द।

समान (सिवाय यह देखने के लिए कि यह पहले से ही पोस्ट किया गया हिस्सा है), ऐसा लगता है कि कोड गोल्फर्स और नंबरी वॉचर्स में एक अच्छा ओवरलैप है।

Comments

काम पर numpherphile वीडियो देखा और जब मैं घर गया तो यह पोस्ट करने जा रहा था। पहले वहां पहुंचने के लिए आपको कोसा। : पी

— ड्रेको 18

क्या इसे 1-अनुक्रमित किया जाना है, या हम 0-इंडेक्सिंग का उपयोग कर सकते हैं?

— रॉबिन राइडर

क्या हम बदले या अनंत अनुक्रम को आउटपुट कर सकते हैं?

— जो किंग

... या पहली nशर्तें?

— झबरा

@ Draco18s वही, मैं यह देखने के लिए यहाँ आया था जब मैं यह देख रहा था, नम्बरवन वीडियो देखने के बाद।

— गीज़ा केर्केसेनी

Answer 1

जावास्क्रिप्ट (ईएस 6),  46 41  37 बाइट्स

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

इसे ऑनलाइन आज़माएं!

कैसे?

हमें पूर्ण अनुक्रम संग्रहीत करने की आवश्यकता नहीं है। हमें केवल अनुक्रम में दिखाई देने वाले प्रत्येक पूर्णांक की अंतिम स्थिति पर नज़र रखने की आवश्यकता है। हम उस उद्देश्य के लिए पुनरावर्ती फ़ंक्शन $g$ के अंतर्निहित ऑब्जेक्ट का उपयोग करते हैं ।

$p$$g[p]$$n$

$g[p]-n$$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

Answer 2

पायथन 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

इसे ऑनलाइन आज़माएं!

_{नोट: जैसा कि Erik Outgolfer ने बताया है, यह कोड Python 2 में भी ठीक काम करता है।}

0 से इंडैक्स (हालांकि, बस पूरी तरह से विकृत हो, तो आप यह कर सकते हैं बदलकर -1 अनुक्रमित if nकरने के लिए if~n: पी)

nशून्य तक पहुंचने तक, श्रृंखला को फिर से बनाने के लिए पायथन के भव्य अनपैकिंग "स्टार ऑपरेटर" का उपयोग करता है।

फ़ंक्शन रिवर्स क्रम में श्रृंखला का निर्माण करता है, ताकि खोज के लिए इसे उलटने से बचा जा सके। इसके अतिरिक्त, यह वास्तव में सभी तत्वों की उपेक्षा को संग्रहीत करता है, क्योंकि उन्हें अंत में वापस परिवर्तित करना नि: शुल्क था (अन्यथा -एक स्थान होना चाहिए था) और यह हमारे साथ एक बाइट बचाता है, ~s.index(l)इसके बजाय का उपयोग करके -~s.index(l)।

51 बाइट्स हो सकते हैं यदि पाइथन टुपल्स के समान findकार्य होते हैं (कोई त्रुटि के बजाय-यदि नहीं मिला तो -1 लौटता है), लेकिन ऐसा कोई भाग्य नहीं है ...

Comments

वास्तव में, आप जिस "स्टार ऑपरेटर" का उपयोग कर रहे हैं, वह पायथन 3 के अनपैकिंग ऑपरेटर नहीं है, बल्कि वरग ऑपरेटर जो कि पायथन 2 में भी मौजूद है,

— आउटगोल्फर

पहला एक है, लेकिन sपुनरावर्ती कॉल के लिए दूसरा नहीं है ?

— ArBo

मैंने इसे पायथन 2 में परीक्षण किया है और यह काम करता है।

— आउटगोल्फर

@EriktheOutgolfer हम्म, लेकिन हालांकि अनपैकिंग का दूसरा उपयोग नहीं है? फ़ंक्शन को ऐसे सिंटैक्स का उपयोग करने के लिए varargs का समर्थन नहीं करना पड़ता है।

— अरबो

@ArBo: यह किसी से अलग नहीं है def func(f, *args): f(*args); फ़ंक्शन कॉल के अंदर अनपैकिंग मान्य py2 है। क्या py3 केवल सूची / तानाशाही समझ (यानी [1, 2, *s]) या unpacking चर के अंदर unpacking है a, *b = [1,2,3,4]:।

— एहसान किआ

Answer 3

आर , 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और लूप 0के पहले पास पर ले जाया जाता है while।

Comments

matchजब आप इसका इस तरह से निर्माण करते हैं तो मैं इस समस्या के लिए कितना अच्छा हूँ । वास्तव में साफ।

— क्रिमिनल

क्या दूसरी लाइन पर प्लस यहां कुछ भी करता है? मैंने मान लिया कि यह एक किनारे का मामला तय कर रहा है, लेकिन मैं इसके लिए एक खोज नहीं कर सकता।

— क्रिमिनलवल्गर

@CriminallyVulgar यह विवश करना चाहिए Fकरने के लिए 0जब n==1किसी और यह वापसी होगी FALSE।

— ग्यूसेप

हाँ! मैंने देखा। समझ में आता है, मैं बहुत सारी सीमाएँ आज़मा रहा था लेकिन एकल मूल्य नहीं।

— क्रिमिनलवल्गर

Answer 4

पर्ल 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

Answer 5

बॉर्न शेल, 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

इसे ऑनलाइन आज़माएं

Comments

PPCG में आपका स्वागत है!

— अरनुलद

Answer 6

स्टैक्स , 10 9 बाइट्स

é"▬π²"ô↕j

इसे चलाएं और डीबग करें

यदि 0-आधारित अनुक्रमण की अनुमति है:

स्टैक्स , 8 बाइट्स

à┐æ8Å/[┤

इसे चलाएं और डीबग करें

Answer 7

जे , ²⁹ 23 बाइट्स

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

इसे ऑनलाइन आज़माएं!

वास्तविक कार्य शक्ति क्रिया के पुनरावृत्ति क्रिया में किया जाता है ^:, जो तर्क के रूप में कई बार [पुनरावृत्ति करता है, निरंतर मान 0 के साथ पुनरावृत्ति शुरू कर रहा है &0...

• (#|1+}.i.{.)यह वही है जो इसकी पुनरावृत्ति करता है। इसे तोड़कर ...
• }.i.{.i.सूची {.की पूंछ के भीतर सूची के प्रमुख का सूचकांक ढूंढें }.। यह 0-आधारित इंडेक्स लौटाएगा, इसलिए यदि वर्तमान आइटम 1 पाया जाता है, तो यह 0. वापस आ जाएगा। यदि यह नहीं मिला है, तो यह सूची की लंबाई, यानी, पूंछ की लंबाई वापस कर देगा।
• 1+0-आधारित अनुक्रमण के लिए सही करने के लिए एक में जोड़ें, चूंकि वें ईक की "कितनी दूर वापस" 1-आधारित है। ध्यान दें कि अगर यह नहीं मिला, तो मूल्य अब पूरी सूची की लंबाई होगी।
• #|पूर्ण सूची की लंबाई से विभाजित होने पर, पिछले चरण में गणना की गई शेष राशि लौटाएं। ध्यान दें कि यह "नहीं मिला" 0 में बदल जाता है, लेकिन अन्य सभी मूल्यों को अपरिवर्तित छोड़ देता है।
• ,~सूची के सामने नए मान को जोड़ें। हम सामने वाले का उपयोग केवल सुविधा के लिए करते हैं।
• 1{ सूची में दूसरा आइटम लौटाएं, क्योंकि हमने कई बार गणना की है क्योंकि यह इस तरह से छोटा है।

Answer 8

पायथन , 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 या उससे ऊपर के इनपुट के लिए बहुत धीमी गति से चलाता है।

Answer 9

एपीएल (डायलॉग यूनिकोड) , 19 17 बाइट्स ^{एसबीसीएस}

Ngn, Adám, रिचर्ड पार्क और 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.

Answer 10

वोल्फ्राम भाषा (गणितज्ञ) , 48 बाइट्स

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

इसे ऑनलाइन आज़माएं!

Nonzero मानों को सिंगलटन सूचियों के रूप में लौटाया जाता है ।

Answer 11

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)

Comments

यह अपवित्रता को सेंसर करने का एक अजीब तरीका है!

— नकारात्मक सात

@negativeseven Lol, मुझे यह जानने में कुछ मिनट लगे कि आपका क्या मतलब है, लेकिन मुझे लगता है कि आप इसका जिक्र कर रहे हैं F¯Rćk? ;)

— केविन क्रूज़सेन

Answer 12

जावा, 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;
};

Comments

लूप को फॉर लूप में बदलकर आपको कुछ बाइट्स निकालने में सक्षम होना चाहिए।

— मेगाटॉम

हैलो, आप गोल्फ की घोषणा इनलाइन करने से अधिक कर सकता है int[]में intघोषणा, और यह भी का उपयोग <1करने के बजाय ==0। उदाहरण:int f(int n){int l[]=new int[n],i=0,j,v=0;while(++i<n){j=l[v];l[v]=i;v=j<1?0:i-j;}return v;}

— ओलिवियर ग्रेजायर

और अब एक लैम्ब्डा, साथ ही साथ गोल्फ का उल्लेख @MegaTom द्वारा कुल 80 बाइट्स के लिए किया गया:n->{int l[]=new int[n],i=0,j,v=0;for(;++i<n;l[v]=i,v=j<1?0:i-j)j=l[v];return v;}

— ओलिवियर

अंत में, आप जावा में गोल्फिंग के लिए युक्तियों की जांच कर सकते हैं ।

— ओलिवियर ग्रेजायर

Answer 13

चारकोल , 23 बाइट्स

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

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। स्पष्टीकरण:

≔⁰θ

पहला शब्द 0 पर सेट करें।

Ｆ⊖Ｎ«

लूप n-1समय। (यदि 1-अनुक्रमण स्वीकार्य है, तो ⊖1-बाइट बचत के लिए हटाया जा सकता है।)

≔⊕⌕⮌υθη

अगला शब्द पिछली शर्तों की प्रत्यावर्तित सूची में वर्तमान पद का बढ़ा हुआ सूचकांक है।

⊞υθ

वर्तमान शब्द को पिछली शर्तों की सूची में जोड़ें।

≔ηθ

वर्तमान शब्द को अगले पद पर सेट करें।

»Ｉθ

लूप के अंत में वर्तमान शब्द प्रिंट करें।

Answer 14

जेली , 7 बाइट्स

Ḷ߀ṚiḢ$

इसे ऑनलाइन आज़माएं!

0 अनुक्रमित।

Answer 15

जेली , 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]

Answer 16

सी (जीसीसी) , 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 अनुक्रमित।

Answer 17

हास्केल , 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

इसे ऑनलाइन आज़माएं!

Answer 18

हास्केल, 61 बाइट्स

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

0-आधारित अनुक्रमण।

इसे ऑनलाइन आज़माएं!

Answer 19

जाप -h , 11 बाइट्स

@ÒZÔÅbX}hTo

कोशिश करो

Answer 20

सी # (विजुअल सी # इंटरएक्टिव कंपाइलर) , 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;}

इसे ऑनलाइन आज़माएं!

इस बिंदु पर जावा उत्तर का बहुत अधिक भाग।

Answer 21

पायथन 3 , 128 114 111 102 99 बाइट्स

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]

इसे ऑनलाइन आज़माएं!

Comments

आप एक बाइट को बचाने के -बजाय अपनी स्थिति और उपयोग को नकार सकते हैं !=।

— जोनाथन फ्रेच

इसके अलावा, चूंकि आपका गोल्फ साइड-इफ़ेक्ट-कम प्रतीत होता है, इसलिए आप ट्यूल के बजाय सूचियों का उपयोग कर सकते हैं।

— जोनाथन फ्रेच

@JonathanFrech लेकिन अगर मेरे पास डिफ़ॉल्ट तर्क के रूप में एक सूची है तो यह लगातार कॉल के लिए सही ढंग से काम नहीं करेगा?

— रूहोला

ऐसा क्यों नहीं होना चाहिए?

— जोनाथन फ्रेच

सबसे अधिक संभावना है क्योंकि आपकी पिछली स्क्रिप्ट ने सूची को संशोधित किया, अर्थात साइड-इफेक्ट-कम नहीं था: उदाहरण ।

— जोनाथन फ्रीच

Answer 22

पर्ल 5 ( -p), 42 बाइट्स

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

इसे ऑनलाइन आज़माएं!

Answer 23

पायथन 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 के लिए धन्यवाद

Comments

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]3 बाइट बचाने के लिए दूसरी लाइन बन सकती है ।

— मायप्लेनियन

@mypetlion धन्यवाद

— HyperNeutrino 16

Answer 24

लाल , 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]

इसे ऑनलाइन आज़माएं!

Answer 25

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

Answer 26

क्लोजर, 69 बाइट्स

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

अफसोस की बात है कि अधिक कार्यात्मक दृष्टिकोण अधिक लंबा लगता है।

Answer 27

डीसी, 94 91 90 बाइट्स

कार्यक्रम के दौरान इनपुट लिया जाता है। इसे एक फ़ाइल में सहेजें और फिर चलाने के लिए "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
```

Answer 28

सी ++ (क्लैंग) , 241 235 234 219 197 189 बाइट्स

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

इसे ऑनलाइन आज़माएं!

Answer 29

पायथ , 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]