अनुक्रम में प्रपत्र की बाइनरी संख्याओं का दशमलव प्रतिनिधित्व होता है: 10101...जहां n-th शब्द में n बिट्स हैं।

अनुक्रम शायद बाइनरी और दशमलव संख्याओं के बीच संबंधों को दिखाते हुए व्याख्या करना सबसे आसान है:

0       ->  0
1       ->  1
10      ->  2
101     ->  5
1010    ->  10
10101   ->  21
101010  ->  42

चुनौती:

एक इनपुट पूर्णांक लें n, और अनुक्रम में पहले n संख्याओं को वापस करें। आप अनुक्रम 0-अनुक्रमित या 1-अनुक्रमित करना चुन सकते हैं।

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

n = 1   <- 1-indexed
0

n = 18
0, 1, 2, 5, 10, 21, 42, 85, 170, 341, 682, 1365, 2730, 5461, 10922, 21845, 43690, 87381

स्पष्टीकरण को प्रोत्साहित किया जाता है, हमेशा की तरह।

यह OEIS A000975 है ।

— स्टीवी ग्रिफिन
स्रोत

अपने खुद के MATL समाधान को देखते हुए, क्या परिणाम को रिवर्स ऑर्डर में आउटपुट करना स्वीकार्य है?

— झबरा

हाँ, जब तक यह हल है। @ शैगी

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

मेरी किस्मत को यहां धक्का देना, लेकिन क्या यह आउटपुट फॉर्मेट स्वीकार्य होगा [85,[42,[21,[10,[5,[2,[1,0]]]]]]]?

— झबरा

66

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

lambda n:[2**i*2/3for i in range(n)]

इसे ऑनलाइन आज़माएं! स्पष्टीकरण: का द्विआधारी प्रतिनिधित्व हैतो यह केवल 2 का एक उपयुक्त शक्ति से गुणा करें और पूर्णांक भाग लेने के लिए बनी हुई है। $\frac{2}3$ 0.101010101...

— नील
स्रोत

1

बहुत बुरा यह जनवरी 2018 है, अन्यथा मैंने इसे सर्वश्रेष्ठ पीपीसीजी 2017 के लिए सर्वश्रेष्ठ गणितीय अंतर्दृष्टि के लिए नामित किया होता । उम्मीद है कि मुझे अभी भी 2019 की शुरुआत में याद होगा; पी

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

@ केविनक्रूजसेन यह सबसे अच्छा है जिसे मैंने सभी कोडगॉल्फ

— a/

3

@ केविनक्रूजसेन मत भूलना!

— बैसड्रॉप कंबरवुबवबूब

2

@BassdropCumberwubwubwub अनुस्मारक के लिए धन्यवाद, क्योंकि मैं वास्तव में इसके बारे में पूरी तरह से भूल गया था! इसे नामांकन में जोड़ा गया था।

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

11

05AB1E , 4 बाइट्स

नील की 2/3 चाल का उपयोग करके 2 बाइट बचाई गईं

Lo3÷

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

व्याख्या

L      # push range [1 ... input]
 o     # raise 2 to the power of each
  3÷   # integer division of each by 3

05AB1E , 6 बाइट्स

TRI∍ηC

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

व्याख्या

T        # push 10
 R       # reverse it
  I∍     # extend to the lenght of the input
    η    # compute prefixes
     C   # convert each from base-2 to base-10

— Emigna
स्रोत

9

जेली , ... 4 बाइट्स

-1 बाइट के लिए धन्यवाद मील !

ḶḂḄƤ

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

स्पष्टीकरण:

Ḷ     Ḷowered range, or UnḶength. Get [0, 1, 2, 3, ..., n-1]
 Ḃ    Ḃit. Get the last bit of each number. [0, 1, 0, 1, ...]
   Ƥ  for each Ƥrefixes [0], [0, 1], [0, 1, 0], [0, 1, 0, 1], ...
  Ḅ   convert it from Ḅinary to integer.

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

जोनाथन एलन का संस्करण।

Ḷ€ḂḄ

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

Ḷ     Ḷowered range, or UnḶength.
 €    Apply for €each. Automatically convert the number n
      to the range [1,2,..,n]. Get [[0],[0,1],[0,1,2],..].
  Ḃ   Ḃit. Get the last bit from each number.
      Current value: [[0],[0,1],[0,1,0],..]
   Ḅ  Convert each list from Ḅinary to integer.

नील के 2/3 चाल पर आधारित एक संस्करण 5 बाइट्स देता है, संशोधन इतिहास देखें।

— user202729
स्रोत

ḶḂḄƤइसके लिए उपसर्ग त्वरित बनाया गया था

— मील

त्वरित उपसर्ग के लिए भी कोई ज़रूरत नहीं है - Ḷ€ḂḄयह भी काम करेगा।

— जोनाथन एलन

5

MATL , 5 बाइट्स

:WI/k

नील के जवाब के आधार पर ।

व्याख्या

:       % Implicit input, n. Push range [1 2 ... n]
W       % 2 raised to that, element-wise. Gives [2 4 ...2^n] 
I       % Push 3
/       % Divide, element-wise
k       % Round down, element-wise. Implicit display

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

MATL , 9 बाइट्स

:q"@:oXBs

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

व्याख्या

:       % Implicit input n. Range [1 2 ... n]
q       % Subtract 1, element-wise: gives [0 1 ... n-1]
"       % For each k in [0 1 ... n-1]
  @     %   Push k
  :     %   Range [1 2 ... k]
  o     %   Modulo 2, element-wise: gives [1 0 1 ...]
  XB    %   Convert from binary to decimal
  s     %   Sum. This is needed for k=0, to transform the empty array into 0
        % Implicit end. Implicit display

— लुइस मेंडो
स्रोत

5

पायथन 2 , 45 37 36 बाइट्स

^{-3 बाइट्स धन्यवाद user202729}
^{-1 बाइट थैंक्स टू मैथमंडन}

s=0
exec"print s;s+=s+~s%2;"*input()

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

— छड़ी
स्रोत

दोहरीकरण खुद sको जोड़ने के समान sहै, इसलिए मेरा मानना है कि आप s+=s+~s%2एक बाइट को बचाने के लिए कर सकते हैं ।

— मैथमैडैन

5

पायथन 3, 68 61 54 48 43 बाइट्स

c=lambda x,r=0:x and[r]+c(x-1,2*r+~r%2)or[]

6 बाइट बचाने में मदद करने के लिए 19 बाइट्स और ओवर्स बचाने में मदद करने के लिए user202729 का धन्यवाद ।

यह ऑनलाइन की कोशिश करो

— मनीष कुंडू
स्रोत

इसके लिए धन्यवाद -1 बाइट। और मुझे लगता है कि मैं जगह नहीं ले सकता अगर और साथ या?

— मनीष कुंडू

ठीक है कि पहले से ही किया है।

— मनीष कुंडू

2

क्योंकि एक पूर्णांक के x == 0बराबर है, not xतो xऑपरेंड स्वैप करें (जैसे, x if c else y= y if not c else x) कुछ और बाइट्स को बचाएगा।

— user202729

आप इसके बजाय ड्रॉप i%2और उपयोग कर सकते हैं1-r%2

— रॉड

1

फिर आपको नज़र रखने की ज़रूरत नहीं है i।

— user202729

4

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

mḋḣ↑Θİ¬

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

1-आधारित, इसलिए इनपुट n पहले n परिणाम देता है ।

व्याख्या

     İ¬   The infinite list [1, 0, 1, 0, 1, ...]
    Θ     Prepend a zero.
   ↑      Take the first n elements.
  ḣ       Get the prefixes of that list.
mḋ        Interpret each prefix as base 2.

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

4

एपीएल (Dyalog यूनिकोड) , 11 बाइट्स ^SBCS

मान लिया गया है ⎕IO( मैं ndex हे rigin) होने के लिए 0है, जो कई सिस्टम पर डिफ़ॉल्ट है। बेनामी tacit उपसर्ग समारोह। 1 अनुक्रमित।

(2⊥⍴∘1 0)¨⍳

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

⍳ ɩ ndices 0… n। 1

(… )¨ प्रत्येक के लिए निम्नलिखित tacit फ़ंक्शन लागू करें

⍴∘1 0 चक्रीय रूप [1,0]से उस लंबाई में सूची को फिर से खोलना

2⊥ बेस -2 (बाइनरी) से सामान्य संख्या में परिवर्तित करें

— एडम
स्रोत

4

पर्ल`v5.10` `-n` , 24 + 1 बाइट्स

-3 बाइट्स नाहुएल फोइउलुल को धन्यवाद !

say$v=$v*2|$|--while$_--

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

मेरे रूबी संस्करण के रूप में एक ही तर्क, लेकिन कम क्योंकि पर्ल अधिक संक्षिप्त है। कुछ अजीब कारण के लिए, printतो मैं का इस्तेमाल किया था एक विभाजक (dammit!) ऐसा नहीं होता है, sayसे v5.10;, मुझे यकीन है कि यह कैसे स्कोर करने के लिए नहीं कर रहा हूँ, इसलिए मैं यह अब के लिए बाहर जा रहा हूँ रन करने के लिए इस क्रम में ?. ..

व्याख्या

say    # Like shouting, but milder.
  $v = $v*2 | $|-- # Next element is this element times 2 bitwise-OR
                   # with alternating 0 1 0 1..., so 0b0, 0b1, 0b10, 0b101...
                   # $. is OUTPUT_AUTOFLUSH, which is initially 0 and
                   #   setting all non-zero values seem to be treated as 1
  while $_-- # do for [input] times

— Unihedron
स्रोत

स्कोरिंग के लिए मैं कहूंगा: 27 + 1 ( -n) = 28 बाइट्स, क्योंकि एक पर्ल वन-लाइनर को चलाने के लिए, एक का उपयोग करना चाहिए -eऔर 5.10 का उपयोग करने के लिए आपको बस उपयोग करने की आवश्यकता होती है -E, जो कि एक ही लंबाई है

— नहुएल फोइलेर

के $|--बजाय 3 बाइट्स बचा सकते हैं($.^=1)

— नाहुएल फौइउल

4

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

l=1:0:l
($scanl((+).(2*))0l).take

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

— क्रिस्टियन लुपस्कू
स्रोत

4

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

⌊3÷⍨2*⍳

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

APL (Dyalog) , 11 बाइट्स

(2⊥2|⍳)¨1+⍳

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

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

— Uriel
स्रोत

एक-कई शर्तें लौटाता है। के तहत चलाएँ ⎕IO←0(लेकिन दावा करें कि यह 1-अनुक्रमित है!) और इसमें परिवर्तन 0,करें 1+:(2⊥2|⍳)¨1+⍳

— Adám

4

सी , 81 55 59 बाइट्स

1 अनुक्रमित।

i,j;f(c){for(i=j=0;i<c;)printf("%d ",i++&1?j+=j+1:(j+=j));}

पूर्ण कार्यक्रम, कम गोल्फ:

i;j;main(c,v)char**v;{c=atoi(*++v);for(;i<c;i++)printf("%d ",i&1?j+=j+1:(j+=j));}

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

EDIT 2: मैं इस धारणा के तहत था कि कार्यों को अब पुन: प्रयोज्य होने की आवश्यकता नहीं है कि मुझे लगता है कि यह सही अर्थ है कि उन्हें पुन: प्रयोज्य होना होगा: पी

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

मुझे पूरा यकीन है कि मैं यहाँ और वहाँ कुछ बाइट्स को शेव कर सकता हूँ। मैंने पहले ही कुछ तरकीबें लगा ली हैं। कार्यक्रम का एक बड़ा हिस्सा तर्क प्राप्त करने और इसे एक इंट में बदलने के लिए समर्पित है। यह मेरा पहला कोड गोल्फ है। अगर मैं कुछ गलत कर रहा हूं तो मुझे बताओ: पी

— Minerscale
स्रोत

2

PPCG में आपका स्वागत है! :) मैं एक C लड़का नहीं हूँ लेकिन आप Steadybox के समाधान से कुछ संकेत चमक सकते हैं ।

— झबरा

ठीक है कि अब अधिक समझ में आता है, मैंने पूरे कार्यक्रम को शामिल किया है जब मुझे ज़रूरत है एक फ़ंक्शन और बाकी एक पाद में किया जा सकता है। मुझे लगता है कि यह तब काफी सुधार किया जा सकता है।

— माइनरसेले

PPCG में आपका स्वागत है! आप को हटाकर एक बाइट को बचा सकता है i++और बदल रहा है i&1करने के लिए i++&1। इसके अलावा, हालांकि वैश्विक चर के रूप में iऔर jशुरू में शून्य करने के लिए प्रारंभ में, उन्हें फ़ंक्शन के अंदर प्रारंभ करने की आवश्यकता होती है, क्योंकि फ़ंक्शन सबमिशन को पुन: प्रयोज्य करना पड़ता है ।

— 12 फरवरी को

1

इससे भी बेहतर, यह 2 और बाइट्स को बचाने के लिए संभव है, टर्नरी को पूरी तरह से समाप्त करना।

— user202729

2

50 बाइट्स: i,j;f(c){for(i=j=0;i<c;)printf("%d ",j+=j+i++%2);} इसे ऑनलाइन आज़माएं!

— 14

4

हास्केल , 47 40 53 49 44 40 34 बाइट्स

-4 बाइट्स धन्यवाद उपयोगकर्ता 20202929
-6 बाइट्स लाइकोनी के लिए धन्यवाद

(`take`l)
l=0:[2*a+1-a`mod`2|a<-l]

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

— oktupol
स्रोत

आप otherwiseउदाहरण के साथ बदल सकते हैं 1>0( otherwise == True)

— त्रुटिपूर्ण

इसे और भी अधिक निखारने के लिए, आप किसी चीज़ को असाइन करने के लिए गार्ड का उपयोग कर सकते हैं, जैसे कि: इसे ऑनलाइन आज़माएँ!

— दोष

1

पुनश्च: इसके अलावा हैस्केल में गोल्फिंग के लिए युक्तियों और पुरुषों और पुरुषों के हमारे हैसेल-चैटरूम की भी जाँच करें ।

— flawr

1

आपको एक फ़ंक्शन बनाने की ज़रूरत है जो सूची के पहले n तत्वों को लौटाता है जहां n तर्क है।

— पूरी तरह से

1

हाँ बिल्कुल। मैं हास्केल में हमारे गाइड टू गोल्फिंग रूल्स पर एक नज़र डालने की सिफारिश कर सकता हूं , जो अनुमति दी गई और जो नहीं है, उस पर वर्तमान सहमति को पकड़ने की कोशिश करता है।

— लकोनी

4

रूबी , 26 बाइट्स

->n{(1..n).map{|i|2**i/3}}

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

सभी पुराने रूबी जवाब धड़कता है।

व्याख्या

1/3बाइनरी में ऐसा दिखता है 0.01010101..., इसलिए यदि आप इसे दो की शक्तियों से गुणा करते हैं , तो आपको यह मिलता है:

n| 2^n/3
-+---------
1|0.1010101...
2|01.010101...
3|010.10101...
4|0101.0101...
5|01010.101...
6|010101.01...

लेकिन रूबी इंट डिवीजन पर संख्याओं को फर्श करती है, मुझे वह अनुक्रम देती है जिसकी मुझे ज़रूरत है।

— MegaTom
स्रोत

4

जे , 9 बाइट्स

[:#.\2|i.

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

i. - सूची 0..n-1

2| - सूची आइटम मॉड 2

\ - सभी उपसर्ग

#. - दशमलव के लिए

[: - कांटा को कैप करें (जैसा कि मेरे पास क्रियाओं की संख्या (4) है)

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

— गैलेन इवानोव
स्रोत

3

रेटिना , 28 बाइट्स

)K`0
"$+"+¶<`.+
$.(*__2*$-1*

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

0-आधारित, इसलिए इनपुट n पहले n + 1 परिणाम देता है।

व्याख्या

OEIS से पुनरावृत्ति का उपयोग करता है:

a(n) = a(n-1) + 2*a(n-2) + 1

कार्यक्रम के माध्यम से चलते हैं:

)K`0

यह एक स्थिर चरण है: यह इनपुट को डिस्कनेक्ट करता है और कार्य स्ट्रिंग को 0अनुक्रम के प्रारंभिक मूल्य पर सेट करता है। )एक समूह में इस स्तर गिर्द घूमती है। वह समूह स्वयं कुछ नहीं करता है, लेकिन लगभग हर चरण (समूह चरणों सहित) एक लॉग में अपना परिणाम रिकॉर्ड करता है, और हमें 0उस लॉग ऑन पर काम करने के लिए प्रोग्राम की दो प्रतियों की आवश्यकता होगी ।

"$+"+¶<`.+
$.(*__2*$-1*

यहां कॉन्फ़िगरेशन का एक गुच्छा है: "$+"+मंच को लूप में लपेटता है। "$+"एक प्रतिस्थापन के रूप में इलाज, और है $+कार्यक्रम के इनपुट, यानी को संदर्भित करता है n । इसका मतलब है कि लूप को एन बार चलाया जाता है ।

फिर ¶<एक आउटपुट चरण में प्रत्येक पुनरावृत्ति को लपेटता है, जो कि चरण के इनपुट को एक अनुगामी लाइनफीड के साथ प्रिंट करता है (इसलिए पहला पुनरावृत्ति शून्य को प्रिंट करता है, दूसरा पुनरावृत्ति पहले पुनरावृत्ति के परिणाम को प्रिंट करता है और इसी तरह)।

मंच ही अंतिम पंक्ति पर प्रतिस्थापन के साथ पूरे कामकाजी स्ट्रिंग को बदल देता है। यह पुनरावृत्ति ऑपरेटर के लिए एक अंतर्निहित समापन कोष्ठक और अंतर्निहित तर्क का उपयोग करता है *, इसलिए यह वास्तव में इसके लिए छोटा है:

$.($&*__2*$-1*_)

कोष्ठक के अंदर के सामान को तीन भागों में विभाजित किया जा सकता है:

$&*_: (n-1) _ s की एक स्ट्रिंग देता है ।
_: एक देता है _।
2*$-1*_: 2 * a (n-1) की एक स्ट्रिंग देता है _। $-1यानी पिछले से पहले पाश यात्रा, परिणाम लॉग में अंत से पहले परिणाम को दर्शाता है। इसलिए हमें शुरू करने के लिए लॉग पर शून्य की प्रतियों की आवश्यकता थी, अन्यथा यह पहले पुनरावृत्ति पर कार्यक्रम के इनपुट को संदर्भित करेगा।

फिर $.(…)परिणामस्वरूप स्ट्रिंग की लंबाई को मापता है। दूसरे शब्दों में, हमने a(n) = a(n-1) + 1 + 2*a(n-2)यूरीरी के माध्यम से गणना की है (वास्तव में हालांकि: $.(…)आलसी नहीं है और वास्तव में इसकी सामग्री का मूल्यांकन नहीं करता है यदि यह परिणामी लंबाई को सीधे अंकगणित के माध्यम से निर्धारित कर सकता है, तो यह काफी कुशल है)।

कार्यक्रम के अंत में रेटिना के अंतर्निहित आउटपुट के कारण अंतिम लूप पुनरावृत्ति ( अनुक्रम का n + 1 तत्व) मुद्रित होता है।

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

3

ब्रेन-फ्लैक , 36 बाइट्स

{([()]{}<((({}<>)<>){}([{}]()))>)}<>

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

स्पष्टीकरण:

अनुक्रम में अगला नंबर n*2+1या इसके द्वारा प्राप्त किया जाता है n*2+0।

{([()]{}< Loop input times
  (
   (({}<>)<>){} Copy n to other stack; n*2
   ([{}]())  i = 1-i
  ) push n*2 + i
>)} End loop
<> Output other stack

— MegaTom
स्रोत

3

रूबी 42 41 43 41 37 35 31 31 30 बाइट्स

यूनीहेड्रॉन के लिए -2 बाइट्स धन्यवाद

-3 बाइट्स जीबी के लिए धन्यवाद

->x{a=0;x.times{a-=~a+p(a)%2}}

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

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

अच्छा कार्य! मुझे आपका सूत्र पसंद है ^^

— Unihedron

1

3 बाइट्स बचाएं:->x{a=0;x.times{a-=~a+p(a)%2}}

— जीबी

2

> <> , 22 + 3 (-v ध्वज) बाइट्स

0:nao::1+2%++$1-:?!;$!

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

व्याख्या

स्टैक लूप काउंटर के साथ आरंभीकृत हो जाता है।

0:nao                  : Push 0 to the stack, duplicate and print with a new line.
                         [7] -> [7, 0]
     ::1+              : Duplicate the stack top twice more then add 1 to it.
                         [7, 0] -> [7, 0, 0, 1]
         2%++          : Mod the stack top by 2 then add all values on the stack bar the loop counter.
                         [7, 0, 0, 1] -> [7, 1]
             $1-:?!;$! : Swap the loop counter to the top, minus 1 from it and check if zero, if zero stop the program else continue.

— पेल पेलिकन
स्रोत

2

जावा 8, 115 81 80 52 बाइट्स

n->{for(int i=2;n-->0;i*=2)System.out.println(i/3);}

पोर्ट ऑफ @ नील का पायथन 2 उत्तर ।
1-अनुक्रमित और सीधे आउटपुट, एक अलग लाइन पर प्रत्येक मूल्य।

स्पष्टीकरण:

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

n->{                           // Method with integer parameter and no return-type
  for(int i=2;                 //  Start integer `i` at 2
      n-->0;                   //  Loop `n` times:
      i*=2)                    //    Multiply `i` by 2 after every iteration
    System.out.println(i/3);}  //   Print `i` integer-divided by 3 and a new-line

पुराने 80 बाइट्स उत्तर:

n->{String t="",r=t;for(Long i=0L;i<n;)r+=i.parseLong(t+=i++%2,2)+" ";return r;}

1-अनुक्रमित इनपुट और अंतरिक्ष-सीमांकित Stringआउटपुट

स्पष्टीकरण:

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

n->{                             // Method with integer parameter and String return-type
  String t="",r=t;               //  Temp and result-Strings, both starting empty
  for(Long i=0L;i<n;)            //  Loop from 0 to `n` (exclusive)
    r+=                          //   Append the result-String with:
       i.parseLong(        ,2);  //    Binary to integer conversion
                   t+=           //     append the temp-String with:
                      i  %2      //      current index `i` modulo-2
                       ++        //      and increase `i` by one afterwards
       +" ";                     //    + a space
  return r;}                     //  Return the result-String

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

2

पर्ल 6 , 35 30 27 25 20 बाइट्स

{[\~](0,+!*...*)[^$_]».&{:2(~$_)}}

यह कोशिश करो (35)

{(0,{$_*2+|($+^=1)}…*)[^$_]}

यह कोशिश करो (30)

{(⅓X*(2,4,8…2**$_))».Int}

यह कोशिश करो (30)

{(⅔,* *2…*)[^$_]».Int}

यह कोशिश करो (27)

{((2 X**1..$_)X/3)».Int}

कोशिश करो (25)

{(2 X**1..$_)Xdiv 3}

यह कोशिश करो (20)

विस्तारित:

{
 (
  2                  # 2
    X**              # cross to the power of
       1..$_         # Range from 1 to the input (inclusive)
            )

             Xdiv    # cross using integer divide
                  3  # by 3
}

— ब्रैड गिल्बर्ट b2gills
स्रोत

2

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

s=2
exec"print s/3;s*=2;"*input()

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

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

f=lambda n:n*[f]and[2**n/3]+f(n-1)

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

उल्टे क्रम में लौटता है।

— XNOR
स्रोत

2

सी, 47 46 बाइट्स

a;f(n){for(a=0;n--;a+=a-~a%2)printf("%d ",a);}

संचायक aशून्य से शुरू होता है। प्रत्येक चरण में, हम इसे दोगुना करते हैं ( a+=a) और एक जोड़ते हैं यदि पिछले कम से कम महत्वपूर्ण बिट शून्य था ( !(a%2)या समकक्ष, -(~a)%2)।

परीक्षण कार्यक्रम

#include <stdlib.h>
#include <stdio.h>

int main(int argc, char **argv)
{
    while (*++argv) {
        f(atoi(*argv));
        puts("");
    }
}

परिणाम

$ ./153783 1 2 3 4 5 6
0 
0 1 
0 1 2 
0 1 2 5 
0 1 2 5 10 
0 1 2 5 10 21

— टोबी स्पाईट
स्रोत

2

जाप , 10 9 7 6 बाइट्स

सभी अन्य समाधानों से स्वतंत्र रूप से प्राप्त हुए।

1 अनुक्रमित।

õ!²mz3

कोशिश करो

व्याख्या

õ        :[1,input]
 !²      :Raise 2 to the power of each
   m     :Map
    z3   :Floor divide by 3

कोशिश करो

7 बाइट संस्करण

õ_ou ì2

कोशिश करो

õ            :[1,input]
 _           :Pass each through a function
   o         :[0,current element)
    u        :Modulo 2 on above
      ì2     :Convert above from base-2 array to base-10

9 बाइट संस्करण

õ_îA¤w)n2

कोशिश करो

õ            :[1,input]
 _           :Pass each through a function
   A         :10
    ¤        :Convert to binary
     w       :Reverse
  î          :Repeat the above until it's length equals the current element
      )      :Close nested methods
       n2    :Convert from binary to base-10

— झबरा
स्रोत

1

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

(`take`map a[0..])
a 0=0
a 1=1
a n=a(n-1)+2*a(n-2)+1

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

— totallyhuman
स्रोत

1

MATL , 7 बाइट्स

:&+oRXB

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

स्पष्टीकरण:

         % Implicitly grab input, n
:        % Range: 1 2 ... n

 &+      % Add the range to itself, transposed
         % 2 3 4 5 ...
         % 3 4 5 6 ...
         % 4 5 6 7 ...
         % 5 6 7 8 ...

   o     % Parity (or modulus 2)
         % 0 1 0 1 ...
         % 1 0 1 0 ...
         % 0 1 0 1 ...
         % 1 0 1 0 ...

    R    % Upper triangular matrix:
         % 0 1 0 1
         % 0 0 1 0
         % 0 0 0 1
         % 0 0 0 0

    XB   % Convert rows to decimal:
         % [5, 2, 1, 0]
         % Implicitly output

आउटपुट होगा 0, 1, 2, 5 ...अगर Pअंत में जोड़ा गया ( flip), इसे 8 बाइट्स बना रहा है।

— स्टीवी ग्रिफिन
स्रोत

1

अच्छा विचार,&+

— लुइस मेंडो

1

रूबी `-n` ,32 30 + 1 बाइट्स

चूँकि हमारे पास इनपुट की ठीक 1 पंक्ति है, $.ईश्वरीय सुविधाजनक है!

संपादित करें: मुझे आश्चर्य है कि मैं अपने आप को आउटगोल्फ करने में कामयाब रहा, लेकिन ऐसा लगता है कि -nजो 1 के रूप में गिना जाता है (नियम 2 डिफ़ॉल्ट विशेष परिस्थितियों में , क्योंकि रूबी के साथ चलाया जा सकता है ruby -e 'full program'(इस प्रकार -n1) सभी उदाहरणों में getsसे केवल एक बार उपयोग किया जा सकता है इस तरह से 1 चार्ट नीचे गिराओ; मेरा मानना है कि यह माणिक के लिए एक मील का पत्थर है, कृपया बोलें कि क्या आप इस ट्रेन के बारे में असहमत हैं इससे पहले कि मैं बार-बार भविष्य में इसका पुन: उपयोग करूं)

v=0
?1.upto($_){p v=v*2|$.^=1}

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

व्याख्या

# while gets(); -- assumed by -n
v=0            # First element of the sequence
?1.upto($_){   # Do from "1" to "$LAST_READ_LINE" aka: Repeat [input] times
  p            # print expression
  v=v*2|$.^=1  # Next element is current element times two
               # bitwise-or 0 or 1 alternating
               # $. = lines of input read so far = 1 (initially)
}
# end           -- assumed by -n

— Unihedron
स्रोत

दिलचस्प। यह 27 बाइट्स में संभव है , हालांकि।

— एरिक डुमिनील

1

अच्छा! लगता है कि हम सब 26b से बढ़ गए थे, हालांकि।

— यूनीहेड्रोन

1

AWK `a=0` , 31 बाइट्स

{for(;$1--;a=a*2+1-a%2)print a}

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

इस अन्य रूबी जवाब से बेशर्मी से चुराए गए सूत्र का उपयोग करता है ।

a=0काम नहीं करते समय (awk "0 के रूप में खाली" व्यवहार करता है), 0 का पहला तत्व मुद्रित नहीं होगा और इसके बजाय एक emptyपंक्ति होगी, जबकि मैं तर्क देता हूं कि एक वैध आउटपुट शायद पास नहीं होगा, इसलिए वहां a=0जो हो सकता है कमांड लाइन तर्क के रूप में डाला जा सकता है।

— Unihedron
स्रोत

मुझे आपका सूत्र पसंद है ^ ^

— असोन तुहिद

1

सी, 52 बाइट्स

i,k;f(n){for(i=k=0;i<n;k=++i%2+2*k)printf("%d ",k);}

1 अनुक्रमित

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

— Steadybox
स्रोत

1

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

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

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

0 अनुक्रमित। चार कोड के रूप में इनपुट, चार कोड की श्रृंखला को अलग करने वाली नल बाइट्स के साथ एकरी के रूप में आउटपुट। जब तक आप 255 से अधिक इनपुट नहीं करना चाहते तब तक 8-बिट कोशिकाओं को ग्रहण करता है। नकारात्मक कोशिकाओं को मानता है, हालांकि यह कई बाइट्स की कीमत पर तय किया जा सकता है।

इससे पहले, 50 बाइट्स

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

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

चार कोड के रूप में इनपुट, चार कोड के रूप में आउटपुट। 1 अनुक्रमित। शायद थोड़ा गोल्फ हो सकता है।

@ यूनीहेड्रॉन बताते हैं कि मैं यह निर्दिष्ट करना भूल गया कि इसके लिए अनंत आकार की कोशिकाओं की जरूरत है, अन्यथा यह 8 वें नंबर पर सबसे ऊपर है।

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

जब मैं इसे टेस्ट केस के रूप में `` (0d018) के साथ चलाता हूं, तो आपका कोड `* UªUªUªUªUªUªUª` (0x01 02 05 0a 15 2a 55 एए 55 एए 55 एए) 55 ए 55 # 55 एए; ए डी डी 00 00 00 0 0 0 0 0 0 0 0 0 0 0 0 0 0; 170 085 170 085 170 085 170 085 170 085 170) :( tio.run/##SypKzMxLK03O/…

— Unihedron

ठीक है, लगता है यह एक सेल आकार की समस्या है। मुझे लगता है कि या तो आपके कोड को बड़े पूर्णांक के अनुकूल होना चाहिए या आपको कार्यान्वयन को निर्दिष्ट करने की आवश्यकता है जो आपके कोड को ठीक से चलाएगा, लेकिन 8-बिट कोशिकाओं का डिफ़ॉल्ट पर्याप्त नहीं है

— Unihedron

इसके बारे में भूल गए, धन्यवाद @Unihedron! मेरे पास 8-बिट संस्करण के बारे में एक विचार होगा, शायद एकात्मक में आउटपुट।

— जो राजा

32-बिट कोशिकाओं के साथ एक दुभाषिया का उपयोग करना, यह काम करता है। हालांकि मुझे लगता है कि अगर आपके पास सप्ताहांत तक नहीं है तो मैं एक बिटिन्टेगर (8 बिट) संस्करण में एक कोशिश कर सकता हूं: डी

— अनहाइड्रॉन

लगातार बराबर बाइनरी अंकों के बिना पहली एन संख्या

चुनौती:

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

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

05AB1E , 4 बाइट्स

05AB1E , 6 बाइट्स

जेली , ... 4 बाइट्स

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

MATL , 5 बाइट्स

व्याख्या

MATL , 9 बाइट्स

व्याख्या

पायथन 2 , 45 37 36 बाइट्स

पायथन 3, 68 61 54 48 43 बाइट्स

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

व्याख्या

एपीएल (Dyalog यूनिकोड) , 11 बाइट्स SBCS

पर्लv5.10 -n , 24 + 1 बाइट्स

व्याख्या

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

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

APL (Dyalog) , 11 बाइट्स

सी , 81 55 59 बाइट्स

हास्केल , 47 40 53 49 44 40 34 बाइट्स

रूबी , 26 बाइट्स

व्याख्या

जे , 9 बाइट्स

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

रेटिना , 28 बाइट्स

व्याख्या

ब्रेन-फ्लैक , 36 बाइट्स

स्पष्टीकरण:

रूबी 42 41 43 41 37 35 31 31 30 बाइट्स

> <> , 22 + 3 (-v ध्वज) बाइट्स

व्याख्या

जावा 8, 115 81 80 52 बाइट्स

पर्ल 6 , 35 30 27 25 20 बाइट्स

विस्तारित:

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

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

सी, 47 46 बाइट्स

परीक्षण कार्यक्रम

परिणाम

जाप , 10 9 7 6 बाइट्स

व्याख्या

7 बाइट संस्करण

9 बाइट संस्करण

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

MATL , 7 बाइट्स

रूबी -n ,32 30 + 1 बाइट्स

व्याख्या

AWK a=0 , 31 बाइट्स

सी, 52 बाइट्स

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

इससे पहले, 50 बाइट्स

एपीएल (Dyalog यूनिकोड) , 11 बाइट्स ^SBCS

पर्ल`v5.10` `-n` , 24 + 1 बाइट्स

रूबी `-n` ,32 30 + 1 बाइट्स

AWK `a=0` , 31 बाइट्स