54

यह हमारे हाल के मानकों को I / O आवश्यकताओं को समायोजित करने के लिए, एक पुरानी चुनौती का एक प्रतिनिधि है । यह इस लोकप्रिय अनुक्रम के बारे में एक चुनौती में अधिक भाषाओं को भाग लेने की अनुमति देने के प्रयास में किया जाता है। रेपोस्ट की चर्चा के लिए यह मेटा पोस्ट देखें ।

कोलाकोस्की अनुक्रम एक मजेदार आत्म-संदर्भ अनुक्रम है, जिसमें OEIS अनुक्रम A000002 होने का सम्मान है (और A000001 की तुलना में इसे समझना और लागू करना बहुत आसान है)। अनुक्रम 1 से शुरू होता है , इसमें केवल 1 एस और 2 एस होते हैं और अनुक्रम तत्व (एन) अनुक्रम में 1 वें या 2 एस के एन वें रन की लंबाई का वर्णन करता है । यह विशिष्ट रूप से (रन के नीचे के दृश्य के साथ) होने के क्रम को परिभाषित करता है:

1,2,2,1,1,2,1,2,2,1,2,2,1,1,2,1,1,2,2,1,2,1,1,2,1,2,2,1,1,2,1,1,2,...
= === === = = === = === === = === === = = === = = === === = === =
1, 2,  2, 1,1, 2, 1, 2,  2, 1, 2,  2, 1,1, 2, 1,1, 2,  2, 1, 2, 1,...

आपका कार्य, निश्चित रूप से, इस क्रम को लागू करना है। ऐसा करने के लिए आप तीन में से एक प्रारूप चुन सकते हैं:

एक इनपुट n लें और अनुक्रम के n वें शब्द को आउटपुट करें , जहां n 0 या 1 से शुरू होता है ।
एक इनपुट n लें और अनुक्रम के n वें टर्म सहित और उन शब्दों को आउटपुट करें , जहाँ n 0 या 1 से शुरू होता है (यानी या तो पहले n या पहले n + 1 शब्द को प्रिंट करें )।
अनुक्रम से आउटपुट मान अनिश्चित काल के लिए।

दूसरे और तीसरे मामले में, आप किसी भी उचित, असंदिग्ध सूची प्रारूप का चयन कर सकते हैं। यदि तत्वों के बीच कोई विभाजक नहीं है, तो यह ठीक है, क्योंकि वे हमेशा परिभाषा के अनुसार एक ही अंक होते हैं।

तीसरे मामले में, यदि आपका सबमिशन एक फ़ंक्शन है, तो आप उन भाषाओं में एक अनंत सूची या एक जनरेटर भी लौटा सकते हैं जो उनका समर्थन करते हैं।

आप एक प्रोग्राम या फ़ंक्शन लिख सकते हैं और इनपुट प्राप्त करने और आउटपुट प्रदान करने के हमारे किसी भी मानक तरीके का उपयोग कर सकते हैं। ध्यान दें कि इन खामियों को डिफ़ॉल्ट रूप से मना किया गया है।

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

code-golf number sequence

— मार्टिन एंडर
स्रोत

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

— मैजिक ऑक्टोपस Urn

समस्या का सामान्यीकरण , लेकिन अनुक्रम के प्रारंभिक भाग के ठीक होने के बाद से अनुकूलन संभव है।

— Giuseppe

जब हम इस पर हैं, तो मुझे एक और सामान्यीकरण मिल गया है ।

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

17

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

2Rṁxṁµ¡

यह एक पूर्ण कार्यक्रम है जो पहले n शब्दों को प्रिंट करता है ।

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

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

2Rṁxṁµ¡  Main link. Argument: n (integer)

     µ   Combine the preceding links into a monadic chain.
      ¡  Set t = n.  Call the chain n times, updating t with the return value after
         each call. Yield the last value of t.
2R           Set the return value to 2 and take its range. Yields [1, 2].
  ṁ          Mold; cyclically repeat 1 and 2 to match t's length.
             In the first run, ṁ promotes t = n to [1, ..., n].
   x         Repeat the k-th element of the result t[k] times.
             In the first run, x repeats each element t = n times.
    ṁ        Mold; truncate the result to match the length of t.
             In the first run, ṁ promotes t = n to [1, ..., n].

उदाहरण चलाते हैं

आज्ञा देना = ५ ।

श्रृंखला का पहला आह्वान 1, 2 को दोहराता है चक्रीय रूप से लंबाई 5 तक पहुंचने के लिए , फिर प्रत्येक तत्व 5 बार, और अंत में परिणाम को लंबाई 5 तक काट देता है ।

  1         2         1         2         1
x 5         5         5         5         5
---------------------------------------------------
  1 1 1 1 1 2 2 2 2 2 1 1 1 1 1 2 2 2 2 2 1 1 1 1 1

  1 1 1 1 1

इससे लंबाई 5 की सूची मिलती है । पहला तत्व कोलाकोस्की अनुक्रम का पहला तत्व है।

श्रृंखला दोहराता की दूसरी मंगलाचरण 1, 2 चक्रीय लंबाई तक पहुँचने के लिए 5 , फिर दोहराता कश्मीर ^वें तत्व j , बार जहां j है कश्मीर ^वें पिछली सूची के तत्व, और अंत में लंबाई में परिणाम ट्रंकेटस 5 ।

   1 2 1 2 1
x  1 1 1 1 1
------------
   1 2 1 2 1

   1 2 1 2 1

इससे लंबाई 5 की एक और सूची मिलती है । पहले दो तत्व कोलाकोस्की अनुक्रम के पहले दो तत्व हैं।

प्रक्रिया तीन और पुनरावृत्तियों के लिए जारी है।

   1 2   1 2   1
x  1 2   1 2   1
----------------
   1 2 2 1 2 2 1

   1 2 2 1 2

   1 2   1   2 1
x  1 2   2   1 2
------------------
   1 2 2 1 1 2 1 1

   1 2 2 1 1

   1 2   1   2 1
x  1 2   2   1 1
----------------
   1 2 2 1 1 2 1

   1 2 2 1 1

ये कोलाकोस्की अनुक्रम के पहले पांच तत्व हैं।

— डेनिस
स्रोत

12

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

l=[2]
print 1,2,
for x in l:print x,;l+=x*[l[-1]^3]

अनिश्चित काल के लिए प्रिंट। सूची बनाता है जैसे lकि इसके माध्यम से पुनरावृत्त किया जा रहा है। प्रत्येक प्रविष्टि के लिए xकी l, संलग्न कर देता है xकी प्रतियां 1या 2, जो भी वर्तमान पिछले तत्व विपरीत है।

प्रारंभिक आत्म-संदर्भित टुकड़ा के साथ मुख्य कठिनाई काम कर रही है [1,2,2]। यह कोड अभी प्रारंभिक प्रिंट करता है 1,2और वहां से आगे बढ़ता है। अतिरिक्त मुद्रण की लागत 12 बाइट होती है। इसके बिना:

39 बाइट्स , पहली दो प्रविष्टियाँ गायब:

l=[2]
for x in l:print x;l+=x*[l[-1]^3]

एक और दृष्टिकोण विशेष रूप से पहले दो प्रविष्टियों को इनिशियलाइज़ करना है। हम पहले दो प्रविष्टियों को जोड़ने का कारण नहीं है, लेकिन उन्हें शुरू के रूप में मुद्रित किया lजाता है [0,0,2]ताकि हम इनिशियलाइज़ print x or nकरें n।

51 बाइट्स

l=[0,0,2]
n=1
for x in l:print x or n;l+=x*[n];n^=3

एक और फिक्स इनिशियलाइज़ करना है l=[1], अल्टरनेशन को मैन्युअल रूप से ट्रैक करना nऔर प्रिंटिंग को सही करना:

51 बाइट्स

n,=l=[1]
for x in l:print(l==[1,1])+x;l+=x*[n];n^=3

(l==[1,1])+सब के बिना , मुद्रित अनुक्रमों के 1,1,2बजाय सब कुछ काम करता है इसके बजाय शुरू होता है 1,2,2। इस दूसरे चरण में हमें पहचानने का एक बेहतर तरीका होना चाहिए।

और एक और अजीब फिक्स, किसी भी तरह एक ही बाइट गिनती:

51 बाइट्स

l=[1];q=2
for x in l:print x;l+=x*[l[-1]^3]*q;q=q<2

— XNOR
स्रोत

12

वम्पस , 13 11 बाइट्स

=[=)O?=!00.

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

अनुक्रम को बिना विभाजक के अनिश्चित काल के लिए प्रिंट करता है।

मैं वास्तव में आश्चर्यचकित हूं कि यह कितना छोटा है।

व्याख्या

मूल विचार यह है कि अनुक्रम को स्टैक पर रखा जाए और बार-बार नीचे-सबसे तत्व का उपयोग करके एक और रन बनाया जाए और फिर उसे प्रिंट किया जाए। हम यहां पर एक कतार के रूप में स्टैक का प्रभावी रूप से दुरुपयोग कर रहे हैं। हम भी काम करके बाइट्स के एक जोड़े को बचा सकता है 0और 1बजाय (उत्पादन के लिए केवल incrementing) 1और 2है, क्योंकि इस तरह से हम स्पष्ट रूप से एक साथ ढेर आरंभ की जरूरत नहीं है 1और हम दो मानों के बीच टॉगल करने के लिए तार्किक निषेध उपयोग कर सकते हैं।

     The entire program is run in a loop.
     At the beginning of loop iteration i, a(i)-1 will be at the bottom of the
     stack and the first element of the ith run of values will be on top.
     The caveat is that on the first iteration, the stack is empty, but
     popping from an empty stack produces an implicit zero.
=    Duplicate the top of the stack. Since this is defined as "pop x, push
     x, push x" this will result in 2 zeros when the stack is empty.
     After this we've got two copies of the ith run's value on top of the stack.
[    Pull up a(i)-1 from the bottom of the stack.
=)O  Duplicate, increment to a(i) and print it.
?=   If a(i)-1 is 1 (as opposed to 0), make another copy of the top of the
     stack. We've now got a(i)+1 copies, so one more than the run should be 
     long, but that's great because we can use the additional copy to get 
     the start of the next run.
!    Logical negation which swaps 0 and 1.
00.  Jump back to the beginning of the program.

— मार्टिन एंडर
स्रोत

10

ब्रेकीलॉग , 30 26 25 23 17 16 14 बाइट्स

~a₀{1|2}ᵐḅlᵐ?l

पहले n मान को आउटपुट करता है । .इनपुट के लिए "आउटपुट चर" का उपयोग करता है , और "इनपुट चर" के लिए आउटपुट ?। इसे ऑनलाइन आज़माएं!

व्याख्या

मैं इस बात से बहुत खुश हूं कि यह कैसे घोषित हुआ: कार्यक्रम मूल रूप से आउटपुट सूची और इनपुट के संबंध में एक उच्च स्तरीय विवरण है।

~a₀{1|2}ᵐḅlᵐ?l  Input is a number N.
                Output is a term that I'll call T.
~a₀             T is a prefix of a list L.
   {   }ᵐ       Each element of L
    1|2         is either 1 or 2.
         ḅ      If you cut L into blocks of equal elements
          lᵐ    and take the length of each block,
            ?   the result is T.
             l  The length of T is N.

क्योंकि {1|2}ᵐलिक्सोग्राफ़िक क्रम में सूचियों को आज़माता है, आउटपुट 1 से शुरू होगा।

— Zgarb
स्रोत

9

भूसी , 10 बाइट्स

Ṡωo↑⁰`Ṙ¢ḣ2

पहले n मान लौटाता है । इसे ऑनलाइन आज़माएं!

व्याख्या

Ṡωo↑⁰`Ṙ¢ḣ2  Input is an integer N.
        ḣ2  The range [1,2]
       ¢    Cycle: C = [1,2,1,2,1,2...
 ω          Iterate until fixed point is found:
Ṡ    `Ṙ      Replicate the list C element-wise according to the current list,
  o↑⁰        then take first N elements.

इनपुट 20 के लिए, प्रक्रिया इस प्रकार है:

[1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2...
[1,2,2,1,2,2,1,2,2,1,2,2,1,2,2,1,2,2,1,2]
[1,2,2,1,1,2,1,1,2,2,1,2,2,1,1,2,1,1,2,2]
[1,2,2,1,1,2,1,2,2,1,2,1,1,2,2,1,2,2,1,1]
[1,2,2,1,1,2,1,2,2,1,2,2,1,1,2,1,1,2,1,2]
[1,2,2,1,1,2,1,2,2,1,2,2,1,1,2,1,1,2,2,1]
[1,2,2,1,1,2,1,2,2,1,2,2,1,1,2,1,1,2,2,1]

— Zgarb
स्रोत

1

यहाँ एक भिन्नता है जो अनुक्रम को अनिश्चित काल के लिए मुद्रित करती है, वही बाइट काउंट लेकिन शायद आपको कुछ गोल्फ के अवसर दिखाई देंगे जिन्हें मैंने ऑनलाइन

— लियो

9

जावा 10, 155 108 105 100 97 बाइट्स

v->{var s="122";for(int i=1;;s+=(1+i%2)*(s.charAt(i)>49?11:1))System.out.print(s.charAt(++i-2));}

बिना परिसीमा के अनिश्चित काल के लिए प्रिंट।

-3 बाइट @Neil से एक अप्रत्यक्ष टिप के बाद ।
-5 बाइट्स @MartinEnder को धन्यवाद ।
-3 बाइट्स जावा 8 को जावा 10 में परिवर्तित करना।

स्पष्टीकरण:

इसे ऑनलाइन आज़माएं (TIO पर 60 सेकंड के बाद का समय)।

v->{              // Method with empty unused parameter and no return-type
  var s="122";    //  String, starting at "122"
  for(int i=1;;   //  Loop `i` from 1 upwards indefinitely
      s+=         //    After every iteration: Append the String with:
         (1+i%2)  //     1+`i`modulo-2
         *(s.charAt(i)>49?11:1))
                  //     either once or twice depending on the digit at index `i`
    System.out.print(s.charAt(++i-2));}
                  //   Print the character at index `i-2` of the String
                  //   After we've first increased `i` by 1 with `++i`

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

1

मुझे पसंद है कि आपने कैसे इस लुक को इतना सरल बना दिया है।

— एग्री आउटलोफर

@EriktheOutgolfer धन्यवाद! :) जब मैंने चुनौती पढ़ी तो मुझे यकीन नहीं था कि कैसे भी शुरू किया जा सकता है, लेकिन फिर उसने मुझे मारा (प्रारंभिक के साथ एक सूची का उपयोग करके [1,2,2]और वहां से जाना) और मैंने 155 बाइट उत्तर लिखा (जो अब एक स्ट्रिंग का उपयोग करके तैयार किया गया है) सूची के बजाय)।

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

के (3-i)बजाय का उपयोग क्यों नहीं (1+i%2)?

— एर्ग आउटफोलर

1

@EriktheOutgolfer क्योंकि i1 या 2 नहीं है, यह स्ट्रिंग इंडेक्स है।

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

7

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

’ß€+\<¹SḂ‘

एन ^वें कार्यकाल लौटाता है ।

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

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

’ß€+\<¹SḂ‘  Main link. Argument: n (positive integer)

’           Decrement; yield n-1.
 ß€         Recursively map the main link over [1, ..., n-1].
   +\       Take the cumulative sum.
            The k-th sum is the combined length of the first k runs.
     <¹     Compare each sum with n.
       S    Sum the Booleans.
            This counts the number of runs that occur before the n-th term.
            If there's an even number (including 0) of runs, the n-th term is 1.
            If there's an odd number of runs, the n-th term is 2.
        Ḃ   Extract the least significant bit of the count.
         ‘  Increment.

— डेनिस
स्रोत

7

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

r=r%1
~(x:t)%n=n:[n|x>1]++t%(3-n)

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

अर्जन जोहानसन ने उपसर्ग को मजबूर करने के लिए एक अकाट्य पैटर्न का उपयोग करके 7 बाइट्स को बचाया।

— XNOR
स्रोत

5

आप इसे आलसी बनाकर 7 बाइट बचा सकते हैं। इसे ऑनलाइन आज़माएं!

— अर्जन जोहान्सन

@ LrjanJohansen यह अद्भुत और आलसी पैटर्न मेरे लिए जादू है। अपना जवाब पोस्ट करना चाहते हैं?

— xnor

नाह तुम वहाँ सबसे अधिक थे। n:अभिव्यक्ति की शुरुआत में उपयोग करके आपको यह जानने की आवश्यकता नहीं है xकि पहला उत्पादन करने के लिए क्या है n। लेकिन आपको फंक्शन से बचने के लिए पैटर्न को आलसी होने की आवश्यकता होती है n:।

— अर्जन जोहानसन 3

6

गोल> <> , 8 7 बाइट्स

:{:PnKz

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

व्याख्या

यह मेरे Wumpus उत्तर का एक बंदरगाह है । गोल> <> मूल रूप से वह भाषा है जिसमें वम्पस उत्तर (विशेष रूप से, स्टैक के तल पर निहित शून्य, "डुप्लीकेट" लागू किया गया "पॉप, पुश, पुश" और स्टैक रोटेशन कमांड) पोर्ट करने के लिए सभी आवश्यक विशेषताएं हैं, लेकिन :

इसमें एक टॉरॉइडल ग्रिड है, जिसका अर्थ है कि हमें 00.शुरुआत में वापस कूदने के लिए स्पष्ट की आवश्यकता नहीं है ।
इसके पास है K, जो "पॉप एन, फिर अगले तत्व एन बार डुप्लिकेट" है, जो ?=एक और बाइट की बचत कर सकता है ।

तो Wumpus से Gol> <> की मैपिंग हो जाती है:

Wumpus   Gol><>
=        :
[        {
=        :
)        P
O        n
?=       K
!        z
00.

— मार्टिन एंडर
स्रोत

6

शेक्सपियर प्रोग्रामिंग लैंग्वेज , 594 583 572 बाइट्स

-10 बाइट्स के लिए एड व्यान का धन्यवाद!

,.Ford,.Puck,.Act I:.Scene I:.[Enter Ford and Puck]Ford:You cat!Open heart!You big cat!Open heart!Puck:Remember you!Remember me!Scene V:.Ford:You is the sum ofI a cat!Puck:Recall!Open heart!Ford:Remember a pig!Is I nicer a cat?If notyou be the sum ofyou a big pig!Scene X:.Puck:Recall!Ford:Is I nicer zero?If soremember I!If solet usScene X!Puck:Is I nicer zero?You is the sum ofI a big cat!If soyou is I!Remember zero!Remember I!Remember you!You be the difference betweena big cat you!Scene L:.Ford:Recall!Is you worse I?If so,let usScene V!Puck:Remember I!Let usScene L!

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

यह एड वेन के अनगुल्ड सॉल्यूशन का एक गोल्फ संस्करण है , जो 828 बाइट समाधान से शुरू होता है, जो वह टिप्पणियों में जुड़ा हुआ है और वहां से थोड़ा पागल हो रहा है।

स्पष्टीकरण:

,.Ford,.Puck,.Act I:.Scene I:.[Enter Ford and Puck]    Boilerplate, introducing the characters
Ford:You cat!Open heart!You big cat!Open heart!  Print 1,2 as the first two terms of the sequence

Puck:Remember you!Remember me!  Initialise stack as 0, 2
                                Ford's value is currently 0, representing the value to be pushed to the stack

Scene V:.     Start infinite loop
  Ford:You is the sum ofI a cat!         
  Puck:Recall!Open heart!                 Pop the next value in the stack and print it
  Ford:Remember a pig!                    Push -1 as the end of the stack
  Is I nicer a cat?                       If Ford's value is 2
  If notyou be the sum ofyou a big pig! Subtract 2 from Puck's value to represent making 2 only one copy

        #Reverse the stack until it reaches the terminator value 0 or -1
  Scene X:.Puck:Recall!Ford:Is I nicer zero?If soremember I!If solet usScene X!

  Puck:Is I nicer zero?                          Check if the Puck's value is bigger than 0 (only making one copy)
  You is the sum of Ia big cat!                 Set Ford's value to Puck+2 to counter the change
  If soyou is I!                                But undo it if making one copies
  Remember zero!                                 Push 0 as the stack terminator
  Remember I!                                    Push Ford's value, which is 0 or -1 if this is a single copy, or 1 or 2 for a double copy
  Remember you!                                  Push one copy of Puck's value
  You be the difference betweena big cat you!   Map Ford's value from 1,2 to 1,0

  Scene L:.   #Reverse the stack until it reaches the terminator 0 
     Ford:Recall!Is you worse I?If solet us Scene V!
     Puck:Remember I!Let usScene L!

— मजाक कर रहा है
स्रोत

अच्छा! आप जुड़वा बच्चों के बजाय एकल बच्चे को (-1 या 0) बनाकर 7 बाइट्स बचा सकते हैं। इससे आपको सीन एक्स से ठीक पहले 1 बाइट की कीमत मिलती है (जब "अगर ऐसा है तो" अगर "नहीं"), और सीन एक्स लूप के बाद एक और बाइट (जब "आई नेक नीस यू" बन जाता है "इज़ आई नाइसर जीरो")। बचत यह है कि आप "यदि नहीं, तो आपको याद रखें!" बस "मुझे याद रखें!" एक पंक्ति पहले। हम या तो एक दूसरे बच्चे या एक अतिरिक्त टर्मिनेटर सम्मिलित करते हैं। (यही कारण है कि आपको सूक्ष्म रूप से संतुलित "क्या मैं आपको अच्छा मानता हूं" को बदलने की आवश्यकता है - - आप अब सीन == 0 पर सीन एक्स के बाद भरोसा नहीं कर सकते हैं) यहां टीआईओ, 587 बाइट्स है: tinyurl.com/yb9z4gp

— एड व्यान

आप सीन एल में पहले "यदि हां, तो" को हटा सकते हैं और कमांड को सीन वी की शुरुआत में ले जा सकते हैं। यह आपको केवल 1 बाइट बचाता है, क्योंकि आपको एक नया "फोर्ड:" चाहिए। लेकिन आप सीन I में बाइट्स के एक जोड़े को बचाते हैं, इसलिए जब तक आप फोर्ड पर शून्य-प्रारंभिक रूप से भरोसा कर सकते हैं। आपको इस पर भरोसा करने का कोई अधिकार नहीं है, लेकिन यह काम कर सकता है: यहाँ TIO, 584 बाइट्स है: tinyurl.com/y9f6vy7u

— Ed Wynn

5

> <> , 13 12 बाइट्स

0:{:1+n?:0=!

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

मार्टिन एंडर के वम्पस उत्तर का एक बंदरगाह । दुर्भाग्य से, ><>एक वृद्धि या एक औंधा कमान नहीं है और न ही यह स्टैक के तल पर 0s निहित है, इसलिए यह थोड़ा लंबा हो जाता है।

— मजाक कर रहा है
स्रोत

1

हां, यह वही है जो मुझे गोल> <> को याद करने से पहले था। :)

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

5

जावास्क्रिप्ट, 67 66 60 58 52 51 50 बाइट्स

ठीक है, कि यह मेरे दिमाग से अधिक खुजली होना चाहिए था! n0-अनुक्रमित वें शब्द को फिर से रखता है।

s=`122`
x=1
f=n=>s[n]||f(n,s+=s[++x%2]*(s[x]+0-9))

5 + 1 बाइट्स ने मेरे खुजली वाले मस्तिष्क को खरोंचने के लिए धन्यवाद बचाया !

झसे आज़माओ

नीचे दिया गया स्निपेट पहले 50 शब्दों का उत्पादन करेगा।

कोड स्निपेट दिखाएं

s=`122`
x=1
f=n=>s[n]||f(n,s+=s[++x%2]*(s[x]+0-9))
o.innerText=[...Array(50).keys()].map(f).join`, `

<pre id=o></pre>

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

व्याख्या

यह उन दुर्लभ अवसरों में से एक है जब हम अपने कार्यक्षेत्र के दायरे के बाहर कुछ चरों की घोषणा कर सकते हैं, उन्हें फ़ंक्शन के भीतर संशोधित कर सकते हैं और फिर भी फ़ंक्शन के बाद के कॉल पर उन्हें पुन: उपयोग करने में सक्षम हो सकते हैं।

s=`122`       :Initialise variable s as the string "122"
x=1           :Initialise variable x as integer 1
f=n=>         :Named function f taking input as an argument through parameter n
 s[n]         :If s has a character at index n, return it and exit
 ||           :Or
 f(n          :Call f with n again
  ,s+=        :At the same time, append to s
  s[++x%2]    :  Increment x, modulo by 2 and get the character at that index in s
  *           :  Multiplied by (the above gets cast to an integer)
  (s[x]+0-9)  :  Append a 0 to the xth character of s and subtract 9
 )            :  (The above gives "1"+0-9="10"-9=1 or "2"+0-9="20"-9=11)

— झबरा
स्रोत

क्या के बारे मेंn=>(g=s=>s[n]||g(s+(++x%2+1)*(10*s[x]-9)))('122',x=1)

— tsh

Btw, s='122',x=1,g=n=>s[n]||g(n,s+=(++x%2+1)*(10*s[x]-9))एक वैध प्रस्तुत माना जाता है?

— tsh

धन्यवाद, @ सत्। s[n]||पेड़ों के लिए लकड़ी नहीं देखने का एक स्पष्ट मामला था! आपका दूसरा सुझाव मान्य नहीं होगा, हालाँकि, क्योंकि फ़ंक्शन को केवल एक बार बुलाया जा सकता है; sऔर xप्रत्येक कॉल के साथ आरंभ करने की आवश्यकता है।

— झबरा

दूसरा एक पुन: प्रयोज्य हो करता है, जब तक कि sऔर xनहीं हर आह्वान के बीच अन्य कोड (जो डिफ़ॉल्ट रूप से है) से छुआ।

— tsh

1

अच्छा! s[x]+0-9एक बहुत साफ चाल है

— जॉली जोकर

4

पायथन (2 और 3), 65 60 बाइट्स

f=lambda n:sum([f(i)*[i%2+1]for i in range(2,n)],[1,2,2])[n]

एन वें प्रविष्टि लौटाता है , 0-अनुक्रमित।

वैकल्पिक (65 बाइट्स):

f=lambda n:n>1and sum([f(i)*[i%2+1]for i in range(n)],[])[n]or-~n

— ManfP
स्रोत

3

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

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

1

आप (शायद, मैंने हालांकि परीक्षण नहीं किया था) वैकल्पिक संस्करण में 5 बाइट्स को [1,2,2]मूल्य के रूप में उपयोग करके बचा सकते हैंsum

— रॉड

4

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

-1 बाइट थैंक्स टू निम्मी। -2 बाइट्स लिन का धन्यवाद।

c=1:2:c
l=1:2:drop 2(id=<<zipWith replicate l c)

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

हर तत्व को उसकी स्थिति मॉड 2 + 1 बार दोहराएं।

— totallyhuman
स्रोत

आप परिभाषित करके दो और बचा सकते हैंc=1:2:c

— लिन

4

ब्रेनफक , 61 बाइट्स

+.+.[.[>]>+++>+++<<<[->+>->-<<<]<[[->+<]<]>>--[[>]<,<[<]>+]>]

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

प्रिंट संख्या के रूप में संख्या अनिश्चित काल के लिए। स्पष्टता के लिए, यहां एक संस्करण है जो संख्याओं में प्रिंट करता है (पहले दो तत्वों को छोड़कर, जो सत्यापित करने के लिए काफी आसान है)।

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

+.+. Prints the first two elements. These are the self-referential elements
     This also intitialises the tape with the third element, 2
[ Start infinite loop
   . Print current lowest element
   [>]>+++>+++ Move to end of tape and create two 3s
   <<<[->+>->-<<<] Subtract the last element of the tape from these 3s
   <[[->+<]<]>> Move to the beginning of the tape
   --  Subtract two from the first element
       This leaves 2 as 0 and 1 as -1
   [ If the number was 1
     [>]<,  Delete the excess element from the end of the tape
     <[<]>+ Remove the -1
   ]
   > Move to the next element of the list
]

— मजाक कर रहा है
स्रोत

4

05AB1E , 12 9 बाइट्स

3 बाइट्स ग्रिम के लिए धन्यवाद बचा लिया

पहले n आइटम प्रिंट करता है ।

Δ2LÞsÅΓI∍

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

व्याख्या

Δ           # repeat until ToS doesn't change
 2LÞ        # push [1,2,1,2 ...]               
    sÅΓ     # run-length encode with previous value (initially input)
       I∍   # extend/shorten to the length specified by input

— Emigna
स्रोत

रन-लेंथ डिकोडिंग अब एक अंतर्निर्मित है, इसलिए यह बस हो सकता है 2L[2LÞsÅΓ।

— ग्रिमी

या इससे भी बेहतर ∞[2LÞsÅΓ:।

— ग्रम्मी

या Δ2LÞsÅΓI∍एक ऐसे संस्करण के लिए जो इनपुट n दिए गए पहले n आइटम को प्रिंट करता है।

— ग्रम्मी

@ जिमी: धन्यवाद! मुझे पहला एन संस्करण पसंद है क्योंकि यह वास्तव में समाप्त होता है :)

— एमिग्ना

3

05AB1E , 15 बाइट्स

ƵLS[DNÌ©èF®É>¸«

इसे ऑनलाइन आज़माएं! या एक पुनरावृत्ति सीमा के साथ

व्याख्या

ƵLS               # push our initial list [1,2,2]
   [              # for every N in [0 ...
    D             # duplicate current list of numbers
     NÌ©è         # get the N+2'th element from the list
         F        # that many times do
          ®É>     # push ((N+2)%2==1)+1
             ¸«   # append to current list

— Emigna
स्रोत

इसके बजाय ¸«, =उन्हें 2 बाइट्स सहेजे गए के लिए मुद्रित करेगा। ƵLS[NÌ©èF®É>=, अगर आप का उपभोग नहीं कर रहे हैं, तो कोई ज़रूरत नहीं है।

— मैजिक ऑक्टोपस Urn

@MagicOctopusUrn: मैं हालांकि पहले 3 आइटम का उत्पादन नहीं करता, इसलिए दुर्भाग्य से छपाई काम नहीं करती है

— Emigna

3

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

n=h=1;l=[]
while n:print(h);n^=3;h,*l=l+[n]*(l+[2])[0]

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

— OVS
स्रोत

3

जे , 12 बाइट्स

एकल-तर्क फ़ंक्शन n ले रहा है और पहले n शब्द का उत्पादन कर रहा है । इसे ऑनलाइन आज़माएं!

$(1+2|I.)^:]

बस पुराने सवाल का मेरा पुराना जवाब छिड़क रहा हूं ।

I.एक क्रिया है जो संख्याओं की एक सरणी लेता है और सूचकांकों की एक सूची को बाहर निकालता है, ताकि यदि सरणी में k -th आइटम n है , तो सूचकांक k n बार दिखाई देता है। हम इसका उपयोग एक प्रारंभिक बीज से कोलाकोव्स्की अनुक्रम को बूटस्ट्रैप करने के लिए करेंगे। प्रत्येक चरण निम्नानुसार आगे बढ़ेगा:

1 2   2   1 1 2   1 2   2   1   (some prefix)
0 1 1 2 2 3 4 5 5 6 7 7 8 8 9   (use I.)
0 1 1 0 0 1 0 1 1 0 1 1 0 0 1   (mod 2)
1 2 2 1 1 2 1 2 2 1 2 2 1 1 2   (add 1)

यदि हम 1+2|I.10 से शुरू करके इस ऑपरेशन को करते हैं , तो यह कुछ इस तरह दिखता है:

10
1 1 1 1 1 1 1 1 1 1
1 2 1 2 1 2 1 2 1 2
1 2 2 1 2 2 1 2 2 1 2 2 1 2 2
1 2 2 1 1 2 1 1 2 2 1 2 2 1 1 ...
1 2 2 1 1 2 1 2 2 1 2 1 1 2 2 ...
1 2 2 1 1 2 1 2 2 1 2 2 1 1 2 ...

ध्यान दें कि हम हर बार अधिक से अधिक सही शब्द कैसे प्राप्त करते हैं, और थोड़ी देर बाद पहले n शब्द तय किए जाते हैं। बसने के लिए पुनरावृत्तियों की संख्या ठीक-ठीक वर्णन करना कठिन है, लेकिन यह n में मोटे तौर पर लघुगणक प्रतीत होता है , इसलिए यदि हम इसे n बार चलाते हैं (तो ^:]) यह ठीक होना चाहिए। (अधिक जानकारी के लिए इन अन्य OEIS अनुक्रमों की जाँच करें: पीढ़ी की लंबाई , आंशिक रकम ।)

एक बार जब हम ऐसा कर लेते हैं, तो हमें बस इतना करना है कि पहले n शब्दों का उपयोग करना है $। $vकिसी भी क्रिया के लिए निर्माण vएक हुक का एक उदाहरण है, और इसे nतर्क के रूप में देना निष्पादित करेगा n $ (v n)।

यहां पुराना 13-बाइट संस्करण है, जो समय और स्थान की बहुत कम बर्बादी है ($1+2|I.)^:_~:। यह हर कदम पर इनपुट को काट देता है, इसलिए हम रैखिक के बजाय कई बार व्यवस्थित करने के लिए आवश्यक रूप से कई बार चला सकते हैं।

— algorithmshark
स्रोत

ओह यह पूरी तरह से साथ काम करता है I.। मैं हमेशा से कुछ गोल्फ में इसका उपयोग करने की कॉपी सुविधा देखना चाहता था।

— मील

3

फ्यू , 30 बाइट्स

Fueue एक कतार-आधारित एसोलैंग है जिसमें चल रहा प्रोग्राम और उसका डेटा दोनों एक ही कतार में हैं, निष्पादन चक्र में कतार के चारों ओर चला जाता है, और प्रोग्रामिंग को गलत समय पर निष्पादित करने से कुछ भी रखने के लिए बहुत सारे सिंक्रनाइज़ेशन की आवश्यकता होती है।

1)2:[[2:])~)~:~[[1]:~))~:~~]~]

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

उपरोक्त अंक नियंत्रण कोड के रूप में अंकों की एक संयुक्त सूची को मुद्रित करता है। 34 बाइट्स के लिए यह वास्तविक अंकों को प्रिंट कर सकता है:

49)50:[[50:])~)~:~[[49]:~))~:~~]~]

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

बाकी स्पष्टीकरण बाद वाले संस्करण का उपयोग करता है।

फ़्यूए तत्वों का सारांश

फ्यू कतार में निम्नलिखित प्रकार के तत्व हो सकते हैं:

इंजीर्स, जो निष्पादित होने पर अपने यूनिकोड कोडपॉइंट को प्रिंट करते हैं,
स्क्वायर-ब्रैकेट सीमांकित सबप्रोग्राम ब्लॉक, जो दयापूर्वक निष्क्रिय हैं (बस कतार के अंत तक जा रहे हैं) जब तक कि )फ़ंक्शन उन्हें डीबॉक नहीं करता है, और
एकल-वर्ण फ़ंक्शन, जो निष्पादित करते हैं यदि वे सही प्रकार के तर्कों का पालन करते हैं और अन्यथा निष्क्रिय रहते हैं।
- इस कार्यक्रम में उपयोग किए जाने वाले एकमात्र कार्य हैं ~(दो निम्नलिखित तत्वों की अदला-बदली), :(डुप्लिकेट अगला तत्व), और )(ब्लॉक के बाद डीबॉक)।

उच्च स्तरीय अवलोकन

कार्यक्रम के मुख्य लूप के दौरान, कतार में निम्न शामिल हैं:

खंडों की एक श्रृंखला जो अंकों को दर्शाती है;
- एक अंक 1 या 2 क्रमशः ब्लॉक [49]और द्वारा दर्शाया जाता [50:]है।
सेल्फ-रेप्लिकेटिंग मेन लूप सेक्शन जो डिजिट ब्लॉक को ट्रेस करता है और उनके बाद 1s और 2s को ऑप्शनल करता है, फिर उन्हें डीबॉक करता है।
- एक deblocked अंकों ब्लॉक का अपना अंकों प्रिंट घ , और फिर बनाता है घ निम्नलिखित ब्लॉक की प्रतियां, इस प्रकार रन में वर्णन के लिए अंकों का निर्माण।

पहले 10 आदेशों का निम्न स्तर का पता लगाना

Cmds   Explanation              Queue
49     Print '1'.               )50:[[50:])~)~:~[[49]:~))~:~~]~]
)      Inactive, move to end.   50:[[50:])~)~:~[[49]:~))~:~~]~])
50     Print '2'.               :[[50:])~)~:~[[49]:~))~:~~]~])
:[...] Duplicate block.         )[[50:])~)~:~[[49]:~))~:~~]~][[50:])~)~:~[[49]:~))~:~~]~]
)[...] Deblock (rmv. brackets). [[50:])~)~:~[[49]:~))~:~~]~][50:])~)~:~[[49]:~))~:~~]~
[...]  Inactive.                [50:])~)~:~[[49]:~))~:~~]~[[50:])~)~:~[[49]:~))~:~~]~]
[50:]  Inactive.                )~)~:~[[49]:~))~:~~]~[[50:])~)~:~[[49]:~))~:~~]~][50:]
)      Inactive.                ~)~:~[[49]:~))~:~~]~[[50:])~)~:~[[49]:~))~:~~]~][50:])
~)~    Swap ) and ~.            :~[[49]:~))~:~~]~[[50:])~)~:~[[49]:~))~:~~]~][50:])~)
:~     Duplicate ~.             [[49]:~))~:~~]~[[50:])~)~:~[[49]:~))~:~~]~][50:])~)~~

एक पूर्ण मुख्य लूप चलना का पूर्वाभ्यास

वैकल्पिक व्हाट्सएप को अलग-अलग कमांड में डाला गया है।

49 ) 50 :[[50:])~)~:~[[49]:~))~:~~]~]

साइकिल 1: 49प्रिंट 1। )निष्क्रिय है, मुख्य लूप ब्लॉक के साथ एक साथ लाए जाने की प्रतीक्षा कर रहा है। 50प्रिंट करता है 2। :मुख्य लूप ब्लॉक को डुप्लिकेट करता है (जिसे स्व-प्रतिकृति के लिए प्रतिलिपि की आवश्यकता होती है)

) [[50:])~)~:~[[49]:~))~:~~]~] [[50:])~)~:~[[49]:~))~:~~]~]

साइकिल 2: )पहली मुख्य लूप ब्लॉक को डीबॉक करता है, जिससे यह अगले चक्र को निष्पादित करना शुरू कर देता है।

[50:] ) ~)~ :~ [[49]:~))~:~~] ~[[50:])~)~:~[[49]:~))~:~~]~]

साइकिल 3: [50:]श्रृंखला में निर्मित पहले अंक का प्रतिनिधित्व करता है, 2अभी तक डीबॉक नहीं किया गया है। )बाद में मुख्य लूप के बाकी हिस्सों ने इसे ट्रेस कर लिया है, तो निम्नलिखित अंततः ऐसा करेगा। ~)~:~एक गोल्फ (एक स्वैप और एक प्रति का उपयोग करके) एक-चक्र की देरी है ~)~~। [[49]:~))~:~~]निष्क्रिय है। अंक ब्लॉक के ~पिछले मुख्य लूप ब्लॉक को स्वैप करता है [50:]।

) ~)~ ~[[49]:~))~:~~][50:] [[50:])~)~:~[[49]:~))~:~~]~]

साइकिल 4: )अभी भी इंतजार कर रहा है, ~)~का उत्पादन ~), ~स्वैप [[49]:~))~:~~]अतीत [50:]अंकों ब्लॉक।

) ~)[50:] [[49]:~))~:~~] [[50:])~)~:~[[49]:~))~:~~]~]

चक्र 5: अंक ब्लॉक के पिछले ~स्वैप ।)[50:]

)[50:] )[[49]:~))~:~~] [[50:])~)~:~[[49]:~))~:~~]~]

चक्र 6: पहले )अब डिजीटल [50:]ब्लॉक को डीबॉक करता है , अगला )डीबलॉक सबप्रोग्राम बनाता है [[49]:~))~:~~]।

50 :[49] :~ ) ) ~:~ ~[[50:])~)~:~[[49]:~))~:~~]~]

साइकिल 7: 50प्रिंट 2, :सिर्फ उत्पादित [49]डिजिट ब्लॉक को डुप्लिकेट करता है , दो 1एस का एक रन बनाता है । :~))~:~एक-चक्र की देरी है ~~))~:। ~शेष मुख्य लूप ब्लॉक को पहले से स्वैप करता है [49]।

[49] ~~) ) ~:[49] [[50:])~)~:~[[49]:~))~:~~]~]

चक्र 8: ~~))एक-चक्र की देरी है )~)। वर्तमान में ट्रैवर्स किए गए पिछले ~स्वैप ।:[49]

[49] ) ~)[49] :[[50:])~)~:~[[49]:~))~:~~]~]

साइकिल 9: पिछले ~स्वैप । मुख्य लूप ब्लॉक को डुप्लिकेट करता है।)[49]:

[49] )[49] )[[50:])~)~:~[[49]:~))~:~~]~] [[50:])~)~:~[[49]:~))~:~~]~]

चक्र 10: पहला )डीबलॉक [49]अंक ब्लॉक को ट्रेस करता है, दूसरा )अगले लूप को अगले एक को फिर से शुरू करने के लिए पुनरारंभ करता है (ऊपर कतार की शुरुआत में दिखाया गया है।)

— अर्जन जोहान्सन
स्रोत

अच्छा काम! इसका कारण मैंने कुछ फ़्यूए सीखा और एचडब्ल्यू चुनौती का जवाब दिया क्योंकि मैंने वास्तव में इस चुनौती के लिए देखा था, लेकिन कतार-आधारित प्रकृति द्वारा बहुत अधिक डराया जा रहा था। यह Fueue के लिए एक बहुत अच्छा स्कोर है! :)

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

3

x86, 41 37 35 33 28 बाइट्स

मुझे विभिन्न x86 निर्देशों के साथ खिलवाड़ करने में बहुत मज़ा आया, क्योंकि यह मेरा पहला "गैर-तुच्छ" x86 उत्तर है। मैंने वास्तव में पहले x86-64 सीखा, और मैंने अपने कार्यक्रम को 32-बिट में परिवर्तित करके कई बाइट्स बचाए।

यह एल्गोरिथ्म मैं OEIS से उपयोग किया जाता है मानों को एक सरणी में धकेलता है, जो इसे x86 के लिए उत्तरदायी बनाता है और स्टैक पर मान संग्रहीत करता है (नोट MIPS में स्टैक निर्देश नहीं हैं)।

वर्तमान में कार्यक्रम Nइनपुट के रूप में मूल्यों को लेता है ecxऔर ebpक्रम में nth मूल्य का प्रतिनिधित्व करने वाले nth तत्व के साथ एक सरणी में एक पता देता है । मुझे लगता है कि स्टैक पर वापस लौटना और अतिरिक्त मानों की गणना करना वैध है (हम मानते हैं कि किसी भी तरह से कचरा से परे क्या है)।

बदलाव का

-4 बाइट्स हर पुनरावृत्ति के x = 2 - n%2साथ गणना करकेxor
लूप के बजाय करते समय का उपयोग करके -2 बाइट्स।
प्रारंभिक मूल्यों 1, 2, 2 का उपयोग करके -2 बाइट्स eax
-5 बाइट्स nस्पष्ट रूप से भंडारण न करके और लूप Nसमय चलाने के बजाय

.section .text
.globl main
main:
        mov     $10, %ecx           # N = 10 

start:
        mov     %esp, %ebp          # Save sp
        push    $1
        push    $2                  # x = 2
        pop     %eax       
        push    %eax                # push 2
        push    %eax                # push 2
        mov     %esp, %esi          # sn = stack+3 addr

loop:                               
        xor     $3, %al             # flip x between 1 <-> 2 
        push    %eax                # push x      
                                    # maybe use jump by parity?
        cmp     $2, (%esi)          # if *sn == 2 
        jne     loop1
        push    %eax                # push x

loop1: 
        sub     $4, %esi            # sn += 1
        loop    loop                # --N, do while (N)
end:
        mov     %ebp, %esp          # Restore sp
        ret

objdump:

00000005 <start>:
   5:   89 e5                   mov    %esp,%ebp
   7:   6a 01                   push   $0x1
   9:   6a 02                   push   $0x2
   b:   58                      pop    %eax
   c:   50                      push   %eax
   d:   50                      push   %eax
   e:   89 e6                   mov    %esp,%esi

00000010 <loop>:
  10:   34 03                   xor    $0x3,%al
  12:   50                      push   %eax
  13:   83 3e 02                cmpl   $0x2,(%esi)
  16:   75 01                   jne    19 <loop1>
  18:   50                      push   %eax

00000019 <loop1>:
  19:   83 ee 04                sub    $0x4,%esi
  1c:   e2 f2                   loop   10 <loop>

0000001e <end>:
  1e:   89 ec                   mov    %ebp,%esp
  20:   c3                      ret

— qwr
स्रोत

3

C (gcc) , 72 71 65 64 62 बाइट्स

-9 बाइट्स @ceilingcat की बदौलत

x,y;f(z){for(x=y=-1;putchar(49-~x%2);y=-~y|z&x/2)x^=z=y&~-~y;}

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

अनुक्रम के मूल्यों को अनिश्चित काल तक उत्पन्न करता है (चुनौती से विकल्प 3)

— vazt
स्रोत

कृपया स्पष्टीकरण दें! मुझे नहीं पता कि यह कैसे काम करता है। कोई सरणी नहीं है! और बिट्स के रूप में एक को समाहित करने के लिए संख्या बहुत छोटी है।

— अर्जन जोहान्सन

@ MitrjanJohansen मुझे मानना है, मुझे नहीं पता कि यह कैसे काम करता है! :) मैंने OEIS A000002 से अजगर के कार्यान्वयन को लिया , इसे C में पोर्ट किया और इसे गोल्फ दिया :)

— vazt

आह मुझे लगा कि यह वहाँ कुछ हो सकता है, लेकिन पायथन को खोजने के लिए उस पृष्ठ से बहुत नीचे नहीं देखा। स्पष्टीकरण के लिए एक लिंक है , लेकिन यह लिंक अनुभाग में थोड़ा दफन था। यह विधि निश्चित रूप से सी के रूप में अच्छी तरह से फिट बैठता है।

— अर्जन जोहान्सन

1) 56 PHP में बाइट्स for($x=$y=-1;;$y=$y+1|$f&.5*$x^=$f=$y&-$y-2)echo$x&1?:2;:। 2) आपके 50-x%2लिए एक बाइट बचाना चाहिए। 3) मैंने इसे चलाने की कोशिश की x=y=1; लेकिन अभी तक संचालन नहीं मिल सका। क्या आप?

— टाइटस

2

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

अभी भी क्लासिक TPR (0,3) समाधान का एक तुच्छ संशोधन:

से श्रृंखला का उत्पादन 0करता हैn

#!/usr/bin/perl
use 5.10.0;
say$_=($n+=!--$_[$n])%2+1for@_=0..<>

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

— टन हास्पेल
स्रोत

2

जावास्क्रिप्ट ईएस 6 - 71 70 68 बाइट्स

(_="122")=>{for(x=1;;_+=(1+x%2)*(_[x]>1?11:1))console.log(_[++x-2])}

नील की बदौलत 1 बिट बचा

मेरी गलती को सुधारने के लिए झबरा के लिए टैंक , 1 बिट बचाने के लिए भी।

f = (_="122") => {
  for(x=1;x<20;_+=(1+x%2)*(_[x]>1?11:1))
    document.getElementById('content').innerHTML += '   ' + _[++x-2]
}
f()

<div id="content"></div>

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

— लुइस फेलिप डी जीसस मुनोज
स्रोत

यह मेरे जावा 8 उत्तर के पोर्ट की तरह दिखता है (इसके x=0बजाय को छोड़कर x=1), लेकिन @ शैगी वास्तव में सही है: यह अपने वर्तमान रूप में काम नहीं करता है (मैंने ,i=100;i-->0अस्थायी रूप से सिर्फ पहले 100 आइटम देखने के लिए जोड़ा है , बजाय आउटपुट देखने से पहले 60 सेकंड प्रतीक्षा करें)। पता नहीं क्यों यह काम नहीं करता है, हालांकि। जेएस मेरी चीज नहीं है।

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

समस्याएं हैं: 1 के बजाय 0 पर 1.आरंभ xकरना (जैसा कि @ केविनक्रूजसेन ने उल्लेख किया है) और यह 2.जांचना कि क्या xस्ट्रिंग में वें वर्ण, जो केवल 1 या 2 हो सकता है, 49 से अधिक है।

— झबरा

2

यहाँ निश्चित समाधान का एक गोल्फ नीचे (लेकिन पूरी तरह से परीक्षण नहीं किया गया) संस्करण है: tio.run/…

— Shaggy

(_[x]*10-9)से(_[x]>1?11:1)

— l4m2

2

तालियाँ , 89 बाइट्स

(def K(lambda()(concat(q(1 2))(drop 2(flatten(zip-with repeat-val(cycle(q(1 2)))(K)))))))

एक फ़ंक्शन को परिभाषित करता है Kजो कोई तर्क नहीं लेता है और कोलाकोस्की अनुक्रम को एक अनंत सूची के रूप में वापस करता है। इसे ऑनलाइन आज़माएं!

यह दृष्टिकोण पूरी तरह से अमानवीय हास्केल उत्तर से प्रेरित था । मेरा मूल दृष्टिकोण लंबा था और शायद O (2 ^ n) था। : ^ पी

Ungolfed

(def kolakoski
 (lambda ()
  (concat (list 1 2)
   (drop 2
    (flatten
     (zip-with repeat-val
      (cycle (list 1 2))
      (kolakoski)))))))

वापसी की सूची के साथ शुरू होता है (1 2)। उसके बाद, इसे शेष बनाने के लिए (अंदर से बाहर पढ़ने)

(kolakoski)कॉलकोस्कोकी अनुक्रम सूची प्राप्त करने के लिए पुन: कॉल करें (आलसी मूल्यांकन के कारण, यह कोई फर्क नहीं पड़ता कि सूची पूरी तरह से उत्पन्न नहीं हुई है)
(cycle (list 1 2)) एक अनंत सूची बनाता है (1 2 1 2 1 2 ...)
फ़ंक्शन का उपयोग करके एक साथ दो अनंत सूचियों को जिप करें repeat-val। यह दोहराया जाएगा 1या 2से cycleसूची या तो एक या दो बार Kolakoski सूची में जुड़े मूल्य के आधार पर। नतीजा:((1) (2 2) (1 1) ...)
flatten उस सूची में (1 2 2 1 1 ...)
हमें पहले से ही पहले दो शब्द मिल चुके हैं (concat (list 1 2), इसलिए हम dropनकल से बचने के लिए उत्पन्न सूची में से पहले दो हैं।

— DLosc
स्रोत

2

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

╦╥2Bïß▄n»-[╒

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

यह उसी कार्यक्रम का एएससीआई प्रतिनिधित्व है।

G@}2R;D{|;^]*m$

यह अनुक्रम x को विस्तारित करता है जहां x इनपुट है। फिर यह x ^वें तत्व को आउटपुट करता है , 0-अनुक्रमित।

G }             G jumps to trailing } and returns when done
 @              get xth element in array
   2R           [1, 2]
     ;D         repeat the rest x times
       {     m  map array using block
        |;^]    produces [1] and [2] alternately
            *   repeat array specified number of times
              $ flatten array

यहां एक बोनस 12-बाइट समाधान है जो आउटपुट को एक अनंत धारा के रूप में उत्पन्न करता है। प्रेस रन शुरू करने के लिए।

— पुनरावर्ती
स्रोत

2

आर, 63 बाइट्स या 61 बाइट्स

कार्यान्वयन 1: अनुक्रम के n ^वें शब्द को प्रिंट करता है।

x=scan()
a=c(1,2,2)
for(n in 3:x)a=c(a,rep(2-n%%2,a[n]))
a[x]

कार्यान्वयन 2: अनुक्रम के पहले n शब्दों को प्रिंट करता है।

x=scan()
a=c(1,2,2)
for(n in 3:x)a=c(a,rep(2-n%%2,a[n]))
a[1:x]

(अंतर केवल अंतिम पंक्ति में है।)

हाँ, हाँ, आप शिकायत कर सकते हैं कि मेरा समाधान अक्षम है, कि यह वास्तव में आवश्यकता से अधिक शब्दों की गणना करता है, लेकिन फिर भी ...

अपडेट: 9 बाइट्स बंद करने के लिए @Giuseppe का धन्यवाद ।

— आंद्रे कोस्टीर्का
स्रोत

1

कुछ बाइट्स को शेव करने a=c(a,rep(2-n%%2,a[n]))के लिए दूसरे forलूप के बजाय उपयोग करें ।

— Giuseppe

@Giuseppe लागू, धन्यवाद!

— आंद्रे

हम यहाँ गोल्फ समाधान के लिए अक्षम नहीं हैं। वास्तव में एक अधिक अक्षम एल्गोरिथ्म का उपयोग कोड-गोल्फ टैग विकी में युक्तियों में से एक है ।

— अर्जन जोहान्सन

2

शेक्सपियर प्रोग्रामिंग लैंग्वेज, 575 बाइट्स (लेकिन दोषपूर्ण), या 653 या 623 बाइट्स

,.Puck,.Ford,.Act I:.Scene X:.[Enter Puck and Ford]Ford:You big cat!Scene L:.Ford:Is I nicer zero?If so,let us Scene V.Is you nicer a big cat?If so,you is the sum of you a big lie.If so,open heart!Open heart!Scene M:.Puck:Remember you!Is I nicer a cat?You big cat.If so,you cat.Ford:Recall!Is you nicer zero?If not,let us Scene X.Is you nicer a big cat?If not,let us Scene M.You is the sum of you a big lie.Scene V:.Ford:Remember you!Is you worse a big big cat?If not, you big cat.Is you as big as a big cat?If not,you zero.You is the sum of I you.Puck:Recall!Let us Scene L.

हॉट कॉन्टेस्ट एसपीएल श्रेणी में, यह जो किंग की वर्तमान प्रविष्टि (583 बाइट्स) को हरा देगा, सिवाय इसके कि यह दोषपूर्ण है: सबसे पहले, यह टीआईओ संस्करण (एसपीएल वेबसाइट को लागू करने) में नहीं चलता है - लेकिन यह पर्ल में चलता है संस्करण , तो शायद यह एक गंभीर दोष नहीं है। दूसरा, हालांकि, यह पहले दो अंकों को नहीं छापता है। अगर हमने जो राजा के समाधान में उस दोष को अनुमति दी, तो वह दोषपूर्ण समाधान 553 बाइट्स होगा, जो मेरे दोषपूर्ण समाधान को हरा देगा।

मेरा समाधान दो कारणों से टीआईओ पर विफल रहता है: हम खाली स्टैक पर भरोसा करने की कोशिश करते हैं जब पॉपप शून्य होता है; और हमें पहला दृश्य मिला, "[फोर्ड और पक] दर्ज करें", हालांकि किसी ने भी मंच नहीं छोड़ा है। ये केवल पर्ल संस्करण में चेतावनी हैं। यदि मैं इन त्रुटियों को ठीक करता हूं और पहले दो अंकों में डाल देता हूं, तो मैं 653 बाइट तक पहुंचता हूं:

 ,.Puck,.Ford,.Act I:.Scene I:.[Enter Puck and Ford]Ford:You cat!Open heart!You big cat!Open heart!You zero!Scene X:.Ford:Remember you!You big cat!Scene L:.Ford:Is I nicer zero?If so,let us Scene V.Is you nicer a big cat?If so,you is the sum of you a big lie.If so,open heart!Open heart!Scene M:.Puck:Remember you!Is I nicer a cat?You big cat.If so,you cat.Ford:Recall!Is you nicer zero?If not,let us Scene X.Is you nicer a big cat?If not,let us Scene M.You is the sum of you a big lie.Scene V:.Ford:Remember you!Is you worse a big big cat?If not, you big cat.Is you as big as a big cat?If not,you zero.You is the sum of I you.Puck:Recall!Let us Scene L.

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

मैं 623 बाइट्स का उपयोग करके पर्ल कार्यान्वयन में पूर्ण अनुक्रम उत्पन्न कर सकता हूं:

,.Puck,.Ford,.Act I:.Scene I:.[Enter Puck and Ford]Ford:You cat!Open heart!You big cat!Open heart!Scene L:.Ford:Is I nicer zero?If so,let us Scene V.Is you nicer a big cat?If so,you is the sum of you a big lie.If so,open heart!Open heart!Scene M:.Puck:Remember you!Is I nicer a cat?You big cat.If so,you cat.Ford:Recall!Is you worse a cat?If so,you big cat!If so,let us Scene L.Is you nicer a big cat?If not,let us Scene M.You is the sum of you a big lie.Scene V:.Ford:Remember you!Is you worse a big big cat?If not, you big cat.Is you as big as a big cat?If not,you zero.You is the sum of I you.Puck:Recall!Let us Scene L.

हालांकि, मैं यह बताना चाहूंगा कि यह समाधान कई अन्य समाधानों की तुलना में तेज है , और पूरी सूची को संग्रहीत करने के बजाय लॉगरिदमिक मात्रा का उपयोग करता है। (यह vazt के C समाधान के समान है, जिससे यह दूर से संबंधित है।) इससे गोल्फ को कोई फर्क नहीं पड़ता है, लेकिन मैं इससे भी खुश हूं। आप पर्ल में एक मिनट के बारे में एक लाख अंक उत्पन्न कर सकते हैं (उदाहरण के लिए यदि आप सीड और डब्ल्यूसी को एक अंक की गणना के लिए पाइप करते हैं), जहां दूसरा समाधान आपको कुछ हजार अंक दे सकता है।

व्याख्या

हम क्रम में चर का एक क्रम संग्रहीत करते हैं: पक का ढेर (नीचे से ऊपर), पक का मान, फोर्ड का मूल्य, फोर्ड का ढेर (ऊपर से नीचे)। सिरों पर शून्य मान के अलावा (खाली स्टैक को पॉप करने से शायद बाईं ओर शून्य के साथ), प्रत्येक मान उस पीढ़ी के आगे उत्पन्न होने वाला अंक है, 2 के साथ अगर अगली पीढ़ी को उस माता-पिता से एक और बच्चा होने की आवश्यकता होती है। जब हमारे पास अनुक्रम में एन गैर-शून्य मान होते हैं, तो हम सभी बच्चों को एन-वें पीढ़ी तक और एक तरह की गहराई-प्रथम ट्री ट्रैवर्सल में उत्पन्न करते हैं। हम केवल एन-वें पीढ़ी से मान छापते हैं। जब एन-वें पीढ़ी पूरी तरह से उत्पन्न हो गई है, तो संग्रहीत मूल्य वास्तव में 2 से (एन + 1) के लिए शुरुआती मूल्य हैं, इसलिए हम बाईं ओर एक 2 को जोड़ते हैं और फिर से शुरू करते हैं, इस समय उत्पन्न (एन + 1) ) -सां पीढ़ी।

तो, एक रूपरेखा: दृश्य एक्स: जब हम यहां तक पहुंचते हैं, तो यह एक नए ट्रावर्सल की शुरुआत है। पक == 0। हम वैकल्पिक रूप से पक के ढेर पर उस शून्य को धक्का देते हैं, और पक = 2 को सेट करते हैं। दृश्य एल: अगर फोर्ड == 0, हम मुद्रण पीढ़ी तक पहुँच चुके हैं। यदि नहीं, तो गोटो वी। प्रिंटिंग के लिए, यदि पक में मान 2 जोड़ा गया है, तो 2 को हटा दें और दो बार प्रिंट करें; यदि नहीं, तो इसे एक बार प्रिंट करें। दृश्य एम: यह एक लूप है जहां हम बार-बार पक के मूल्य को टॉगल करते हैं और अनुक्रम के माध्यम से वापस जाते हैं। हम तब तक दोहराते हैं जब तक या तो हम अंत तक नहीं पहुँच जाते (Puck == 0), जिस स्थिति में गोटो X होता है, या हम एक ऐसे मूल्य पर पहुँचते हैं, जिसे दूसरे बच्चे (Puck> 2) की आवश्यकता होती है, उस स्थिति में अतिरिक्त 2 को घटाएं और V. दृश्य में आगे की ओर जाएँ। V: यहाँ हम आगे चलते हैं। यदि पक 2 या 4 है, तो अगली पीढ़ी में वर्तमान माता-पिता से दो बच्चे होंगे, इसलिए Ford + = 2। अनुक्रम के माध्यम से आगे की ओर कदम। गोटो एल समाप्ति के लिए जाँच करने के लिए।

— एड व्यान
स्रोत

1

axo , 13 बाइट्स

[:|[1+{#;1;-_

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

व्याख्या

यह मेरे वम्पस उत्तर में एक वैकल्पिक समाधान के बंदरगाह के रूप में शुरू हुआ :

2%)[=]&=[O00.

इसके परिणामस्वरूप 18 बाइट्स हुईं। मैंने इसे 13 बाइट्स के लिए नीचे गोल्फिंग के रूप में समाप्त किया, जिसे आप ऊपर देखते हैं कि इसे एक्सो के काम करने के तरीके से अधिक समायोजित करें। इस 13-बाइट संस्करण के बाद वम्पस में 11 बाइट्स तक सुधार की प्रेरणा मिली, इसलिए अब यह वास्तव में उस संस्करण के करीब है।

के रूप में Wumpus, पुनरावृति i में , स्टैक के नीचे एक (i) -1 होता है और शीर्ष में i th रन का पहला तत्व होता है , लेकिन हम मुद्रण को छोड़कर, 0 और 1 के साथ काम कर रहे हैं ।

[:    Store a copy of the top of the stack in register A.
|     Pull up a(i)-1 from the bottom of the stack.
[1+{  Print a(i).
#;    If a(i)-1 is 1, push the value in register A.
1;-   Push another copy of that value and subtract it from 1 to swap
      0 and 1 for the next run.
_     Jump back to the beginning of the program.

— मार्टिन एंडर
स्रोत

1

रूबी , 45 39 बाइट्स

a=*i=0;loop{a+=[k=1+i%2]*p(a[i+=1]||k)}

अनिश्चित काल के लिए प्रिंट करता है

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

इसे एक अतिभारित प्रिंट फ़ंक्शन के साथ आज़माएं जो आपको एक विभाजक और मुद्रित तत्वों की संख्या चुनने की अनुमति देता है

— आसोन तुहिद
स्रोत

कोलाकोस्की अनुक्रम की गणना करें

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

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

उदाहरण चलाते हैं

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

वम्पस , 13 11 बाइट्स

व्याख्या

ब्रेकीलॉग , 30 26 25 23 17 16 14 बाइट्स

व्याख्या

भूसी , 10 बाइट्स

व्याख्या

जावा 10, 155 108 105 100 97 बाइट्स

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

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

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

गोल> <> , 8 7 बाइट्स

व्याख्या

शेक्सपियर प्रोग्रामिंग लैंग्वेज , 594 583 572 बाइट्स

स्पष्टीकरण:

> <> , 13 12 बाइट्स

जावास्क्रिप्ट, 67 66 60 58 52 51 50 बाइट्स

झसे आज़माओ

व्याख्या

पायथन (2 और 3), 65 60 बाइट्स

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

ब्रेनफक , 61 बाइट्स

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

05AB1E , 12 9 बाइट्स

05AB1E , 15 बाइट्स

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

जे , 12 बाइट्स

फ्यू , 30 बाइट्स

फ़्यूए तत्वों का सारांश

उच्च स्तरीय अवलोकन

पहले 10 आदेशों का निम्न स्तर का पता लगाना

एक पूर्ण मुख्य लूप चलना का पूर्वाभ्यास

x86, 41 37 35 33 28 बाइट्स

C (gcc) , 72 71 65 64 62 बाइट्स

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

जावास्क्रिप्ट ईएस 6 - 71 70 68 बाइट्स

तालियाँ , 89 बाइट्स

Ungolfed

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

आर, 63 बाइट्स या 61 बाइट्स

शेक्सपियर प्रोग्रामिंग लैंग्वेज, 575 बाइट्स (लेकिन दोषपूर्ण), या 653 या 623 बाइट्स

व्याख्या

axo , 13 बाइट्स

व्याख्या

रूबी , 45 39 बाइट्स