शीर्षक 'अनुक्रम सूचकांक अंक नहीं' से बना है।

चुनौती:

पूर्णांक को देखते हुए , nजो निम्न अनुक्रम का 'वें नंबर' है। यहां पहले 50 आइटम हैं, इसके ऊपर (0-अनुक्रमित) सूचकांक है:>= 0n

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50
1 0 3 2 5 4 7 6 9 8 22 20 30 24 23 26 25 28 27 32 11 33 10 14 13 16 15 18 17 31 12 29 19 21 50 40 41 42 44 45 35 36 37 51 38 39 52 53 55 56 34

यह क्रम कैसे काम करता है?

सूचकांक में संख्या nपहले क्रम में होनी चाहिए, जिसमें कोई भी अंक सामान्य के साथ nन हो, और पिछले सूचकांक के लिए अभी तक नहीं हुआ है। इसलिए जब हम इस तरह से सामान्य क्रम को देखते हैं 0-60:

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60

हम nइस तरह 'वें मूल्यों को परिभाषित करते हैं :

0: पहली संख्या ( 0) में एक ही अंक होता है, इसलिए हम अगले ( 1) की तलाश करते हैं, जिसमें समान अंक नहीं होता है। तो n=0आउटपुट 1।
1: पहले नंबर ( 0) में एक ही अंक नहीं है, इसलिए n=1आउटपुट 0।
2: हम पहले से ही सामना किया है 0और 1, और अगले अंकों ( 2), एक ही अंकों में शामिल है तो हम अगले (देखने के लिए 3) है, जो एक ही अंकों शामिल नहीं है। तो n=2आउटपुट 3।
...
10: हमने पहले ही सामना कर लिया है 0-9, इसलिए अगली पंक्ति में है 10। 10-19मिलान अंक होना 1, 20मिलान अंकों शामिल 0, 21मिलान अंकों शामिल 1फिर से, 22मान्य है, तो n=10आउटपुट 22।
आदि।

चुनौती नियम:

यदि आपकी भाषा 1-अनुक्रमित है (या आप चुनते हैं) तो आपको अनुक्रम को शुरू करने की अनुमति है 3 2 5 4 7 ...( 1एट n=0और एट को छोड़ 0देना n=1)।
आपके द्वारा समर्थित न्यूनतम न्यूनतम सूचकांक है 25,000। नोट: अनुक्रम इंडेक्स पर रुक जाता है 1,023,456,788, क्योंकि लाइन में अगले इंडेक्स में सभी 10 अंक होते हैं।
nयदि आप चाहें तो पूरे अनुक्रम की एक सरणी / सूची को आउटपुट / वापस करने की अनुमति देते हैं और यदि आप चाहते हैं तो सूचकांक सहित ।

सामान्य नियम:

यह कोड-गोल्फ है , इसलिए बाइट्स जीत में सबसे छोटा जवाब है।
कोड-गोल्फ भाषाओं को गैर-कोडगॉल्फिंग भाषाओं के साथ उत्तर पोस्ट करने से हतोत्साहित न करें। 'किसी भी' प्रोग्रामिंग भाषा के लिए यथासंभव संक्षिप्त उत्तर के साथ आने का प्रयास करें।
मानक नियम आपके उत्तर के लिए लागू होते हैं , इसलिए आपको उचित पैरामीटर और रिटर्न-टाइप, पूर्ण कार्यक्रमों के साथ STDIN / STDOUT, फ़ंक्शन / विधि का उपयोग करने की अनुमति दी जाती है। तुम्हारा कॉल।
डिफ़ॉल्ट ढीले निषिद्ध हैं।
यदि संभव हो, तो कृपया अपने कोड के लिए एक परीक्षण के साथ एक लिंक जोड़ें।
इसके अलावा, यदि आवश्यक हो तो एक स्पष्टीकरण जोड़ें।

परीक्षण के मामलों:

इस अनुक्रम ने वास्तव में सूचकांक और आउटपुट के संबंध में जोड़े बनाए। यदि इंडेक्स nआउटपुट o, इंडेक्स oआउटपुट n। तो आप या तो बाएं या दाएं इनपुट कर सकते हैं, और आउटपुट दूसरी तरफ होगा:

0      <->  1       (this test case is optional)
2      <->  3
10     <->  22
12     <->  30
34     <->  50
89     <->  100
111    <->  200
112    <->  300
199    <->  322
2231   <->  4456
9605   <->  11118
19235  <->  46000
23451  <->  60668
25000  <->  13674

यदि आप दूसरों को आज़माना चाहते हैं, तो पहले 25,001 परीक्षण मामलों का एक पेस्टबिन है।

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

संबंधित, लेकिन एक ठग नहीं।

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

3

संबंधित चुनौती के साथ, स्कैल्पलॉट काफी मजेदार है । :)

— मार्टिन एंडर

@MartinEnder जब मैंने संबंधित चुनौती के बिखराव को देखा, तो मुझे लगा कि यह वास्तव में ऐसा ही होगा। यह वास्तव में समान है, लेकिन अभी भी अलग है। :)

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

ऐसा महत्वपूर्ण अनुक्रम ओईएस पर कैसे नहीं है?

— स्टिव ग्रिफ़िन

@StewieGriffin अच्छा सवाल। वास्तव में, मुझे लगता है कि मेरी सारी अनुक्रम-चुनौतियाँ अब तक OEIS (अभी तक) में नहीं थीं, जब मैंने उन्हें पोस्ट किया था। ;)

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

3

पायथ , 18 बाइट्स

u+Gf!|}TG@`H`T0hQY

यहाँ कोशिश करो! या अधिक परीक्षण मामलों की जाँच करें!

ध्यान दें कि यह संपूर्ण अनुक्रम को अनुक्रमणिका N तक लौटाता है, लेकिन लिंक केवल e(अंतिम) को प्रस्तुत करके अंतिम संख्या देता है । यदि आप इस प्रोग्राम द्वारा लौटाए गए कच्चे मान को देखना चाहते हैं, तो इसे हटा दें ।

यह काम किस प्रकार करता है

u + Gf!!} TG @ `H`T0hQY - पूर्ण कार्यक्रम।

यू ... एचक्यूवाई - एचक्यू (इनपुट बढ़ा हुआ) को बाएं से दाएं, के साथ घटाएं
                       फ़ंक्शन ... (G, H), प्रारंभिक मूल्य Y (खाली सूची) के साथ।
                       जी वर्तमान मूल्य है और एच पुनरावृत्ति सूचकांक है।
   f 0 - पहला पूर्णांक 0 से शुरू होता है, जो निम्नलिखित को संतुष्ट करता है:
      } टीजी - जी में दिखाई देता है ...
     | @ `H`T - या इसके (स्ट्रिंग) चौराहे के साथ वर्तमान सूचकांक (H) है
                        गैर खाली।
    ! - लॉजिकल नॉट (बूलियन नेगशन)।
 + जी - ऊपर प्राप्त मूल्य को वर्तमान मूल्य (जी) पर लागू करें।
                      यह अगले पुनरावृत्ति के लिए दिया गया मान बन जाता है।
                    - सभी मध्यवर्ती परिणाम प्रिंट करें, या प्रिंट करने के लिए ई जोड़ें 
                      आखरी वाला।

— श्री एक्सकोडर
स्रोत

6

पायथन 2 , 92 91 89 88 बाइट्स

a=()
i=0
exec"x=0\nwhile set(`x`)&set(`i`)or x in a:x+=1\na+=x,;i+=1;"*-~input()
print a

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

पहले n+1नंबरों की सूची प्रिंट करता है

विभिन्न दृष्टिकोण, जो बहुत तेज है:

पायथन 2 , 96 बाइट्स

n=input()
r=range(9*n)
i=0
exec"x=0\nwhile set(`r[x]`)&set(`i`):x+=1\nprint r.pop(x),;i+=1;"*-~n

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

— TFeld
स्रोत

1

एक ट्यूपल का उपयोग करते हुए 88 बाइट्स

— मिस्टर एक्सकोडर

3

हास्केल, 80 69 बाइट्स

f n=[x|x<-[0..],all(`notElem`show n)$show x,all(/=x)$f<$>[0..n-1]]!!0

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

बड़े के लिए बहुत धीमी n।

f n=
    [x|x<-[0..]     ] !!0          -- pick the first of all 'x' from [0..]
                                   -- where
      all(`notElem`show n)$show x  -- no digit of 'n' appears in 'x', and
      all(/=x)                     -- 'x' is not seen before, i.e. not in the list
               f<$>[0..n-1]        -- 'f' mapped to [0..n-1]

संपादित करें: @ लिकोनी ने 10 बाइट्स बचाए। धन्यवाद!

— nimi
स्रोत

अनुक्रम में अनुक्रमित करने के बजाय सीधे nth शब्द की गणना करना कम है: इसे ऑनलाइन आज़माएं!

— लाकोनी

2

एपीएल (डायलॉग) , 39 बाइट्स

0∘{0=⍵:1⋄(~⍺∊0∇¨⍳⍵)∧⊃∧/≠/⍕¨⍺⍵:⍺⋄⍵∇⍨⍺+1}

उपयोग करता है ⎕IO←0।

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

कैसे?

प्रत्यावर्तन।

0=⍵:1 - अनुमान तो लगाओ।

~⍺∊0∇¨⍳⍵ - बाएं आर्ग (संचायक) पहले से ही पिछले परिणामों में नहीं है

∧⊃∧/≠/⍕¨⍺⍵- और संचायक के स्ट्रिंग प्रतिनिधित्व और nअलग हैं

:⍺ - इसके बाद संचायक को लौटाएं।

⍵∇⍨⍺+1 - अन्यथा, वृद्धि संचायक और पुनर्खरीद।

— Uriel
स्रोत

वाह .. मुझे पता है कि डिफ़ॉल्ट नियम "स्मृति और समय की किसी भी राशि को दिया जाता है", लेकिन आपका कोड पहले से ही n=10TIO के लिए बाहर है ..: S यह एक बहुत प्रदर्शन-भारी ऑपरेशन होना चाहिए जो आप वहां कर रहे हैं। क्या यह पुनरावृत्ति है जो इसका कारण बनता है, या कुछ और अड़चन है?

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

2

@KevinCruijssen दूसरी शर्त मूल रूप से 0..n-1 की सीमा पर फ़ंक्शन को लागू करती है, और हर कॉल के लिए एक ही आवेदन पर विचार करते हुए, जो मोटे तौर पर एक विशाल O (2 ^ n) पर आएगा। बेशक यह एक अधिक उचित कोड के साथ कम होगा, लेकिन यह वह जगह है जहाँ अड़चन बैठता है

— उरियेल

2

पायथन 3 , 92 बाइट्स

o=1,
for i in range(int(input())):
 x=0
 while{*str(x),x}&{*str(~i),*o}:x+=1
 o+=x,
print(o)

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

यह सभी नियम N वें तक प्रिंट करता है। के लिए धन्यवाद डेनिस के लिए -4 -5 बाइट्स!

— श्री एक्सकोडर
स्रोत

2

जावा (ओपनजेडके 8) , 218 217 213 210 202 200 172 171 170 168 167 बाइट्स

मुझे विश्वास नहीं हो रहा है कि मैं kइस समय वापस नहीं आया ...

i->{int j=-1,k=0,y=1;for(String r=" ",e=r;j++<i;r+=~-k+e,y=1)for(k=0;y>0;k++)for(int f:(k+(y=0)+"").getBytes())y+=(e+j).indexOf(f)<0&!r.contains(e+k+e)?0:1;return~-k;}

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

— रॉबर्टो ग्राहम
स्रोत

हम्म, यह काफी अलग दृष्टिकोण है तब मैं तब उपयोग कर रहा था जब मैंने अपने जावा प्रोग्राम के साथ पास्टबिन बनाया था। और ऐसा लगता है आप गोल्फ कर सकते हैं for(char f:(""+k).toCharArray())करने के लिए for(int f:(""+k).getBytes()), r.substring(-~r.trim().lastIndexOf(32));और करने के लिए r.substring(r.lastIndexOf(32)-1)।

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

LastIndexOf से पहले ट्रिम होना चाहिए क्योंकि अंत में एक जगह है

— रॉबर्टो ग्राहम

आह, मैंने वास्तव में एक गलती की है .. मुझे पता था कि स्ट्रिंग में एक अग्रणी और अनुगामी दोनों जगह थी, लेकिन मेरे गलत तरीके से सुझाए गए परिवर्तन केवल पहले 10 एकल अंकों की संख्या के लिए काम करते हैं .. मेरा बुरा

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

2

गो , 217 205 बाइट्स

package g;import("fmt";"strconv";"strings");var(
d=make(map[int]int)
a=strconv.Itoa)
func G(L int){k,i:=0,0;for;i<=L;i++{s:=a(i);k=0;for d[k]>0||strings.ContainsAny(a(k),s){k++;}
d[k]=1;}
fmt.Print(a(k));}

वैकल्पिक संस्करण (पैकेज के बजाय कार्यक्रम): इसे ऑनलाइन आज़माएं!

सुधार:

के forलिए कई असाइनमेंट का उपयोग करके बाहरी के बाद स्थान हटा दिया गयाi,k
आयात "fmt";+ fmt.Printसे कम है os.Stdout.WriteString( package mainजब ऑस्कर की आवश्यकता थी ( होल्डओवर से )

— Riking
स्रोत

अच्छा, आपका जवाब पहला है जो 1 मिनट के बाद बाहर नहीं निकलता है जब मैं 25000परीक्षण मामले की कोशिश करता हूं । :) तो न केवल एक वैध समाधान है, बल्कि अपेक्षाकृत अच्छा प्रदर्शन भी है। मुझ से +1! (PS: आपके TIO- लिंक में यह वह तर्क है जिसका आप उपयोग करते हैं, इनपुट हटाया जा सकता है / उपयोग नहीं किया जाता है।)

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

2

जावास्क्रिप्ट (ईएस 6), 103 88 81

@Neil द्वारा कई चतुर विचारों सहित संशोधित संशोधित करें

n=>eval("for(r=[j=i=0];i<=n;)j=r[j]||(i+'').match(`[${j}]`)?j+1:!(r[k=j]=++i);k")

प्रस्थान बिंदू

मूल विचार: 0 से n तक एक लूप, और एक आंतरिक लूप जाँच मान अभी भी उपयोग नहीं किए गए हैं

n=>{
  var r=[]
  for(i=0;i<=n;i++)
  {
    s=new Set(i+'')
    for(j=-1;s;)
    {
      if (!r[++j] && ![...j+''].some(d=>s.has(d)))
      {
        r[j]=1
        console.log(i,j)
        s=0
      }
    }
  }
  return j
}

वर्तमान संस्करण अधिक पठनीय है

n=>{
  for(r = [j=i=0]; i <= n; )
    if (r[j] || (i+'').match(`[${j}]`))
      ++j
    else
      r [k=j] = ++i,
      j = 0;
  return k
}

परीक्षा

var f=
n=>eval("for(r=[j=i=0];i<=n;)j=r[j]||(i+'').match(`[${j}]`)?j+1:!(r[k=j]=++i);k")

update=_=>{
  var i=+I.value
  if (i < 1e4 || confirm("Really?")) {
    O.textContent=i + ' -> ...'
    setTimeout(_=>O.textContent=i + ' -> ' + f(i), 100)
  }
}  

update()

<input id=I value=100 type=number max=1023456788>
<button onclick='update()'>Go</button>
(slow when input > 1000)
<pre id=O></pre>

स्निपेट का विस्तार करें

— edc65
स्रोत

चाहेंगे की जगह ~s.search(d)के साथ s.match(d)काम करता है?

— नील

मुझे लगता है कि आप को बदलने के द्वारा एक और बाइट बचा सकते हैं 0करने के लिए j++, को हटाने ++से jयह पहले पर और फिर शुरू हो गया था jसे 0की बजाय -1।

— नील

मुझे लगता है कि मैं एक एकल लूप पर स्विच करने में सक्षम था:n=>eval("for(r=[j=i='0'];i<=n;)r[j]|[...''+j].some(d=>i.match(d))?j++:(i=++i+'',r[k=j]=1,j=0);k")

— नील

@ एक एकल लूप अद्भुत होगा

— edc65

@ एकल पाश महान है, धन्यवाद

— edc65

2

ऑक्टेव , 114 बाइट्स

N=input("");o=[1];for i=1:N;j=0;while(any(o==j)||nnz(ismember(int2str(i),int2str(j))));j++;end;o=[o,j];end;[0:N;o]

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

चरित्र तुलना गोल्फिंग के लिए केविन क्रूज़सेन और डेलोस्क को धन्यवाद ।

Ungolfed

N=input("");o=[1];

for i=1:N;
    j=0;
    while(any(o==j)||nnz(ismember(int2str(i),int2str(j))));
        j++;
    end;
    o=[o,j];
end;
[0:N;o]

मूल व्याख्या:

आउटर लूप और इनर लूप, एक सूचकांक के लिए i, और दूसरा मूल्य जोड़ने के लिएj
प्रत्येक के लिए i, वेतन वृद्धि जारी रखें jयदि दोनों में से कोई भी पूरा हो:
1. jपहले किसी का उपयोग किया गया है
2. यह एक मजेदार हो जाता है। सबसे पहले, अंकों के एक वेक्टर (जैसे, में प्रत्येक संख्यात्मक मान विभाजित 10हो जाता है [1 0]) का उपयोग कर int2str। फिर, दो संख्याओं का उपयोग करके तुलना करें ismember(उदाहरण के लिए, [1 0]और [2 1]वापस आ जाएगी [1 0]) और फिर nnzयह देखने के लिए कि क्या कोई कॉलम मेल खाता है या नहीं।
यदि उपरोक्त में से कोई भी पूरा नहीं हुआ है, तो आपके पास अगला नंबर है! संलग्न करने के लिए o, उत्पादन मैट्रिक्स
आउटपुट मैट्रिक्स के साथ मूल सूचकांकों को प्रिंट करें

— एलन
स्रोत

मुझसे अच्छा जवाब, +1। और लगता है @DLosc सही है, यह दोनों के बिना भी काम करता है -'0'। लेकिन अगर कुछ बढ़त का मामला है, तो हम दोनों के बारे में नहीं सोचा है, -48एक छोटा विकल्प होगा। साथ ही, दोनों sprintf('%d',...)हो सकते हैं int2str(...)।

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

1

पर्ल 5 , 60 बाइट्स

59 बाइट्स कोड + 1 के लिए -p।

$_="@{[0..($;=++$_)*9]}";$_=eval's/\b[^ $-]+ //;$-++;$&;'x$

इसे ऑनलाइन आज़माएं! ( -lदृश्य उद्देश्यों के लिए और $-=0;प्रत्येक पुनरावृत्ति को रीसेट करने के लिए शामिल है)

— डोम हेस्टिंग्स
स्रोत

1

पिप , 30 बाइट्स

-pध्वज के लिए कोड के 29 बाइट्स, +1 ।

Fn,a+1{Y0WyNl|_NyMSn++ylPBy}l

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

पूरी सूची को आउटपुट करता है। चेतावनी: अत्यधिक अक्षम; 2231इनपुट मामले अपने लैपटॉप पर 35 + मिनट के लिए चल रहा है और अभी भी समाप्त नहीं हुआ है।

व्याख्या

                               a is cmdline arg, l is [] (implicit)
Fn,a+1{                    }   For each n in range(a+1):
       Y0                       Yank 0 into y
         W                      While...
          yNl|                  y is in l, or...
              _Ny               lambda function: arg is in y
                 MSn            mapped to digits of n and result list summed
                                (i.e., any digit of n is in y):
                    ++y          Increment y
                       lPBy     Once we have a y that meets the criteria, push it to
                                the back of l
                            l  Output l (formatted with -p flag)

— DLosc
स्रोत

1

Visual Basic .NET (.NET 4.5) , 260 259 बाइट्स

केविन क्रूज़सेन के लिए धन्यवाद

Function A(n)
Dim p=New System.Collections.Generic.List(Of Long),j="0",g=0
For i=0To n
j=0
While 1
If Not p.Contains(j)Then
g=1
For Each c In i.ToString
If j.Contains(c)Then g=0
Next
If g Then Exit While
End If
j+=1
End While
p.Add(j)
Next
A=p(n)
End Function

अनुक्रम में पिछले शब्दों को बनाने के माध्यम से लूप्स, फिर बाद में तुलना करें। फिर मैच की तलाश में एक स्ट्रिंग के रूप में संख्या को पुनरावृत्त करता है।

VB.NET की टाइपिंग प्रणाली का दुरुपयोग करता है। उदाहरण के लिए, jएक स्ट्रिंग है, लेकिन एक जोड़ना मेरे लिए एक पूर्णांक में कनवर्ट करता है। पूर्णांकों Booleans में बदल रही हैं जहां 0है Falseऔर बाकी हैं True।

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

— ब्रायन जे
स्रोत

मैंने विजुअल बेसिक में कभी भी प्रोग्राम नहीं किया है, लेकिन ऐसा लगता है कि आप अंतरिक्ष को If Not p.Contains(j)Thenउसी तरह से हटा सकते हैं जैसे आपने If j.Contains(c)Then g=0नीचे किया था । इसके अलावा, फॉर-लूप में सीधे

If Not p.Contains(j)Then \n g=1 \n For Each c In i.ToString \n If j.Contains(c)Then g=0 \n Next \n If g Then Exit While \n End If

हटाने gऔर उपयोग करके छोटा किया जा सकता है Exit While: If Not p.Contains(j)Then \n For Each c In i.ToString \n If j.Contains(c)Then Exit While \n Next \n End Ifजो कि इसके लुक से 241 बाइट्स बन जाएगा ।

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

@ केविनक्रूजसेन निश्चित रूप से इसे बनाने के लिए स्थान को हटा सकता है Contains(c)Then, मैंने इसे याद किया। मुझे पसंद है कि आप क्या सोच रहे हैं, लेकिन मैं gएक प्रहरी के रूप में यह देखने के लिए उपयोग कर रहा हूं कि क्या स्ट्रिंग में नंबर है या नहीं। आपका लिंक गलत उत्तर देता है, लेकिन मैं देखूंगा कि क्या आप जो सोच रहे हैं उसके साथ कुछ आंतरिक तर्क को पुनः प्राप्त कर सकते हैं।

— ब्रायन जे

आह उफ़ .. यह वास्तव में विफल रहता है .. अब यह केवल इनपुट आउटपुट कर रहा है। मेरी गलती। शाम होने पर मुझे ये टिप्पणियां नहीं करनी चाहिए और मैं काम से थक गया हूं। ;)

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

1

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

^{अजगर जैली की पिटाई करता है। जाओ मिस्टर एक्सकोडर!}

Df⁹LD¤ȯeṆ
0ç1#ɓ;
1Ç¡

एक पूर्ण कार्यक्रम एसटीडीआईएन से इनपुट ले रहा है और जेली की सूची प्रतिनिधित्व * का उपयोग करके सूची प्रारूप विकल्प में आउटपुट कर रहा है। मानक 0 आधारित अनुक्रमण का उपयोग करता है।

* सिंगल एलिमेंट लिस्ट में कोई आसपास नहीं है [], इसलिए 0आउटपुट 1, जबकि 1आउटपुट [1, 0]आदि।

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

कैसे?

Df⁹LD¤ȯeṆ - Link 1, can append n to current? n, number; current, list
D         - convert n to decimal list
     ¤    - nilad followed by link(s) as a nilad:
  ⁹       -   chain's right argument, current
   L      -   length
    D     -   convert to a decimal list
 f        - filter discard from left if not in right
       e  - n exists in current?
      ȯ   - left logical OR right (empty lists are falsey)
        Ṇ - logical NOT

0ç1#ɓ; - Link 2, append next number: current, List
   #   - n find (count up finding first n matches):
  1    - ...finding: 1 match
0      - ...stating at: n=0
 ç     - ...doing: the last link as a dyad (left=n, right=current)
    ɓ  - new swapped-arg-dyadic chain (left = current, right = list of the found n)
     ; - concatenate

1Ç¡ - Main link: no arguments
1   - initialise the return value to 1
  ¡ - repeat input() times:
 Ç  -   last link (2) as a monad
    - implicit print

— जोनाथन एलन
स्रोत

सेकिंडिग्नॉट अनुक्रम

चुनौती:

यह क्रम कैसे काम करता है?

चुनौती नियम:

सामान्य नियम:

परीक्षण के मामलों:

पायथ , 18 बाइट्स

यह काम किस प्रकार करता है

पायथन 2 , 92 91 89 88 बाइट्स

पायथन 2 , 96 बाइट्स

हास्केल, 80 69 बाइट्स

एपीएल (डायलॉग) , 39 बाइट्स

पायथन 3 , 92 बाइट्स

जावा (ओपनजेडके 8) , 218 217 213 210 202 200 172 171 170 168 167 बाइट्स

गो , 217 205 बाइट्स

जावास्क्रिप्ट (ईएस 6), 103 88 81

ऑक्टेव , 114 बाइट्स

Ungolfed

पर्ल 5 , 60 बाइट्स

पिप , 30 बाइट्स

व्याख्या

Visual Basic .NET (.NET 4.5) , 260 259 बाइट्स

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

कैसे?