थ्यू-मोर्स अनुक्रम लिखें


22

इस साइट पर काफी चुनौतियां हैं जो आपको एक अनुक्रम का प्रिंट आउट करने के लिए कहते हैं, और यह कोई अपवाद नहीं है।

(इस चुनौती के लिए अनुक्रम का निम्नलिखित विवरण मानता है कि अनुक्रम में प्रतीक हैं 0और 1)

थ्यू-मोर्स अनुक्रम की पुनरावर्ती परिभाषा वह है

T_0 = 0
T_2n = T_n
T_2n+1 = 1 - T_n

एक और अधिक प्रत्यक्ष परिभाषा है कि से अनुक्रम 0करने के लिए 2**m-1और 2**m to 2**(m+1)-1बाइनरी पूरक हैं। तो 0द्वारा पीछा किया जाता 1, 01द्वारा पीछा किया जाता 10, 0110द्वारा पीछा किया जाता 1001है, और, आगे थोड़ा लंघन, 0110100110010110द्वारा पीछा किया जाता 1001011001101001

चुनौती एक प्रोग्राम या एक फ़ंक्शन लिखना है जो थ्यू-मोर्स अनुक्रम को पहले nतत्वों के लिए प्रिंट करता है, जहां nकोई भी गैर-नकारात्मक पूर्णांक है। आउटपुट किसी भी दो प्रतीकों का उपयोग कर सकता है, जैसा कि नीचे दिए गए उदाहरणों में दिखाया गया है।

उदाहरण

>>> tm_01(20)
01101001100101101001
>>> tm_ab(42)
abbabaabbaababbabaababbaabbabaabbaababbaab
>>> tm_paren(37)
())()(())(()())()(()())(())()(())(()(
>>> tm_space_star(12)
 ** *  **  *
>>> tm_01(0)
                # to show that this is a valid input

नियम

  • इनपुट कोई भी गैर-नकारात्मक पूर्णांक होगा। आप मान सकते हैं कि सभी इनपुट मान्य हैं।

  • आउटपुट nथ्यू-मोर्स अनुक्रम का पहला तत्व होना चाहिए , जो किसी भी प्रतीकों का उपयोग करके सुविधाजनक हो। यदि आप चाहें, तो आप एक विभाजक भी जोड़ सकते हैं। मेरे उदाहरण में, मैंने नहीं किया है। नोट: यह नियम सूचियों (जैसे कि पायथन) की अनुमति देता है, जैसा ,कि एक वैध विभाजक है और मुझे इस तरह के [और ]आउटपुट में अग्रणी या अनुगामी पात्रों से कोई ऐतराज नहीं है ।

  • यह कोड गोल्फ है, इसलिए सबसे छोटी संख्या बाइट्स जीतती है।

हमेशा की तरह, अगर समस्या स्पष्ट नहीं है, तो कृपया मुझे बताएं। गुड लक और गुड गोल्फिंग!

सूची

var QUESTION_ID=65549;var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe";var COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk";var OVERRIDE_USER=47581;var answers=[],answers_hash,answer_ids,answer_page=1,more_answers=true,comment_page;function answersUrl(index){return"http://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+index+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(index,answers){return"http://api.stackexchange.com/2.2/answers/"+answers.join(';')+"/comments?page="+index+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:true,success:function(data){answers.push.apply(answers,data.items);answers_hash=[];answer_ids=[];data.items.forEach(function(a){a.comments=[];var id=+a.share_link.match(/\d+/);answer_ids.push(id);answers_hash[id]=a});if(!data.has_more)more_answers=false;comment_page=1;getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:true,success:function(data){data.items.forEach(function(c){if(c.owner.user_id===OVERRIDE_USER)answers_hash[c.post_id].comments.push(c)});if(data.has_more)getComments();else if(more_answers)getAnswers();else process()}})}getAnswers();var SCORE_REG=/<h\d>\s*([^\n,<]*(?:<(?:[^\n>]*>[^\n<]*<\/[^\n>]*>)[^\n,<]*)*),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/;var OVERRIDE_REG=/^Override\s*header:\s*/i;function getAuthorName(a){return a.owner.display_name}function process(){var valid=[];answers.forEach(function(a){var body=a.body;a.comments.forEach(function(c){if(OVERRIDE_REG.test(c.body))body='<h1>'+c.body.replace(OVERRIDE_REG,'')+'</h1>'});var match=body.match(SCORE_REG);if(match)valid.push({user:getAuthorName(a),size:+match[2],language:match[1],link:a.share_link,});else console.log(body)});valid.sort(function(a,b){var aB=a.size,bB=b.size;return aB-bB});var languages={};var place=1;var lastSize=null;var lastPlace=1;valid.forEach(function(a){if(a.size!=lastSize)lastPlace=place;lastSize=a.size;++place;var answer=jQuery("#answer-template").html();answer=answer.replace("{{PLACE}}",lastPlace+".").replace("{{NAME}}",a.user).replace("{{LANGUAGE}}",a.language).replace("{{SIZE}}",a.size).replace("{{LINK}}",a.link);answer=jQuery(answer);jQuery("#answers").append(answer);var lang=a.language;lang=jQuery('<a>'+lang+'</a>').text();languages[lang]=languages[lang]||{lang:a.language,lang_raw:lang.toLowerCase(),user:a.user,size:a.size,link:a.link}});var langs=[];for(var lang in languages)if(languages.hasOwnProperty(lang))langs.push(languages[lang]);langs.sort(function(a,b){if(a.lang_raw>b.lang_raw)return 1;if(a.lang_raw<b.lang_raw)return-1;return 0});for(var i=0;i<langs.length;++i){var language=jQuery("#language-template").html();var lang=langs[i];language=language.replace("{{LANGUAGE}}",lang.lang).replace("{{NAME}}",lang.user).replace("{{SIZE}}",lang.size).replace("{{LINK}}",lang.link);language=jQuery(language);jQuery("#languages").append(language)}}
body{text-align:left!important}#answer-list{padding:10px;width:290px;float:left}#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}
<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"> <div id="language-list"> <h2>Shortest Solution by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr> </thead> <tbody id="languages"> </tbody> </table> </div> <div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr> </thead> <tbody id="answers"> </tbody> </table> </div> <table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr> </tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr> </tbody> </table>



1
सरल शब्दों में आप कह सकते हैं: फ़ंक्शन पुनरावर्ती है, इनपुट को नकारात्मक करें और इसे संलग्न करें।
यूमेल


2
@PeterTaylor किस तरह से? जुड़े हुए प्रश्न का एक संभावित उत्तर थ्यू-मोर्स अनुक्रम है, लेकिन यह प्रश्न थ्यू-मोर्स उत्पन्न करने के लिए है और कुछ नहीं।
शरलॉक

1
क्योंकि पिछले प्रश्न के उत्तर में से कुछ का उपयोग इस प्रश्न को तुच्छ परिवर्तनों के साथ किया जा सकता है, और इस प्रश्न के सभी उत्तरों का उपयोग पिछले प्रश्न का तुच्छ परिवर्तनों के साथ किया जा सकता है।
पीटर टेलर

जवाबों:


14

अजगर, 6 बाइट्स

xMjR2Q

इसे ऑनलाइन आज़माएँ: प्रदर्शन

@ThomasKwa के समाधान और @FryAmTheEggman की भिन्नता के आधार पर।

यह निम्नलिखित सूत्र का उपयोग करता है: iथ्यू-मोर्स अनुक्रम में -th अंक है xor(digits of i in base 2):।

स्पष्टीकरण:

xMjR2Q   implicit: Q = input number
  jR2Q   convert each number in [0, 1, ..., Q-1] to its binary digits
xM       xor each binary list

9

CJam, 17 9 बाइट्स

ri{2b:^}/

या

ri,2fb::^

इसका परीक्षण यहां करें।

व्याख्या

यह विकिपीडिया पर दी गई वैकल्पिक परिभाषा का उपयोग करता है, 1जो कि द्विआधारी प्रतिनिधित्व में s की संख्या की समता पर आधारित है n

ri   e# Read input and convert to integer n.
{    e# For each i from 0 to n-1...
  2b e#   Convert i to base 2.
  :^ e#   Fold XOR over the bits to compute the parity of the number of 1s.
}/

वैकल्पिक समाधान बाइनरी अभ्यावेदन और XOR को ब्लॉक किए बिना गणना करने के लिए infix ऑपरेटरों का उपयोग करने से पहले स्पष्ट रूप से एक सीमा में ,बदलने के लिए उपयोग करता है ।n[0 ... n-1]

बोनस समाधान

यहाँ अन्य परिभाषाओं के आधार पर कुछ समाधान दिए गए हैं। यदि दो समाधान हैं, तो छोटी एक बहुत जल्दी स्मृति को उड़ा देगी (क्योंकि पूर्वसंचालन 2^nबिट्स को छोटा करने से पहले उत्पन्न करता है n)।

एक एल-सिस्टम के साथ 0 --> 01और 1 --> 10:

ri_2mL2,\{2,aA+f=s:~}*<
ri_2,\{2,aA+f=s:~}*<

पिछले भाग को नकार कर और जोड़कर:

ri_2mL2,\{_:!+}*<
ri_2,\{_:!+}*<

चुनौती में दिए गए पुनरावृत्ति संबंध का उपयोग करते हुए, divmodदो पुनरावर्ती परिभाषाओं के बीच अंतर करने के लिए XOR का उपयोग करना:

ri{Ta{2md\j^}j}/

(हालांकि, निश्चित रूप से, यह पुनरावृत्ति संबंध थ्यू-मोर्स अनुक्रम को बाइनरी प्रतिनिधित्व में 1-बिट्स की समता के रूप में व्यक्त करने का एक अलग तरीका है n।)


स्मृति-व्यर्थ समाधान मेरा पहला विचार था, लेकिन मुझे लगा कि मेमोरी के आधे से अधिक टेराबाइट का उपयोग करके आउटपुट की गणना करना 42एक बिटसेट के लिए बहुत अनुचित होगा।
जॉनी

@ जॉन समस्या हल। ;)
मार्टिन एंडर

:^मुझे खुश कर देता है। एक और नोट पर, पवित्र बकवास, यह एक शांत एल्गोरिथ्म है।
निधि मोनिका का मुकदमा

@QPaysTaxes नहीं :^}?
TheLethalCoder

1
@ TheLethalCoder जो मुझे बहुत खुश करता है
निधि मोनिका का मुकदमा

8

Dyalog एपीएल, 8 7 बाइट्स

≠⌿⍴∘2⊤⍳

यह एक मोनैडिक ट्रेन है जो 0 की इंडेक्स उत्पत्ति की उम्मीद करती है ( ⎕IO←0)। बराबर गैर-ट्रेन फ़ंक्शन है {≠⌿(⍵⍴2)⊤⍳⍵}

स्पष्टीकरण:

      ⍳      List of numbers from 0 to (input-1)
  ⍴∘2        (input) copies of 2
     ⊤       Convert all the elements in ⍳ to base 2 to (input) digits
≠⌿           Reduce over the first axis by not-equal

आउटपुट के एक अंतरिक्ष अलग की गई सूची है 0और 1। इसे यहाँ आज़माएँ ।


8

गणितज्ञ, 35 21 बाइट्स

Mathematica में थ्यू-मोर्स अनुक्रम के लिए एक अंतर्निहित है!

Array[ThueMorse,#,0]&

मूल उत्तर:

#&@@@DigitCount[Range@#-1,2]~Mod~2&

7

लैबव्यू, 15 लैब व्यू आदिम

अब एक जांच के साथ सुपर फैंसी gif के रूप में

यहां छवि विवरण दर्ज करें


3
क्या आप बता सकते हैं कि इसका परीक्षण कैसे किया जाएगा?
जॉन डे

विकल्प 1: लैबव्यू टेस्ट संस्करण प्राप्त करें और इसे फिर से बनाएं, विकल्प: एक तरीका सुझाएं कि मैं इसे आपके लिए। exe या .vi के रूप में कैसे भेज सकता हूं। (बाद के लिए आपको लैबव्यू भी प्राप्त करना होगा)
Eumel

1
वास्तव में मैं यह देखना चाहूंगा कि जब यह चलता है तो यह कैसा व्यवहार करता है। क्या GIF रिकॉर्ड करना निराशाजनक होगा?
जॉनी

यह एक महान विचार है जो मैंने अभी-अभी किया है और इसे एक सेकंड में पूरा करूंगा
Eumel

6

जे, 12 11 बाइट्स

@ मार्टिनबटनर ने एक बाइट को बचाया।

~:/@#:"0@i.

यह एक मोनैडिक (अर्थ एकात्मक) कार्य है, जिसका उपयोग निम्न प्रकार से किया जाता है:

   f =: ~:/@#:"0@i.
   f 10
0 1 1 0 1 0 0 1 1 0

व्याख्या

मैं वैकल्पिक परिभाषा का उपयोग कर रहा हूं कि टी n , n के बाइनरी प्रतिनिधित्व में 1-बिट की संख्या की समता है।

~:/@#:"0@i.  Input is n.
~:/          Output is XOR folded over
   @#:       the binary representations of
      "0     each element of
        @i.  integers from 0 to n-1.

{.(,-)^:]कुछ नियमों के साथ 9 बाइट्स के लिए काम करता है ( जिसकी अनुमति दी गई है )। जैसे कि 5इसके लिए आउटपुट 5 _5 _5 5 _5। (नियम के कारण केवल एक टिप्पणी के रूप में जोड़ा गया।)
यादृच्छिक संख्या

4

अजगर, 11 10 बाइट्स

m%ssM.Bd2Q

पायथन शैली की सूची के रूप में आउटपुट।


मैंने बाइनरी स्ट्रिंग पर XOR का उपयोग करने की कोशिश की, लेकिन मुझे ऐसा करने के लिए पायथ के बारे में पर्याप्त नहीं पता है। यह वैसे भी बहुत कम है। +1
ETHproductions

@FryAmTheEggman आह, मुझे नहीं पता था Fक्योंकि मैंने 'कम' के लिए खोज की थी। आप CW के रूप में पोस्ट कर सकते हैं ...
lirtosiast

4

जाप , 29 11 बाइट्स

Uo ®¤¬r@X^Y

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

एक सरणी के रूप में सीधे आउटपुट, जो लगभग 4 बाइट्स बचाता है।

अपुष्ट और व्याख्या

Uo ®   ¤  ¬ r@  X^Y
Uo mZ{Zs2 q rXY{X^Y}}
        // Implicit: U = input number
Uo      // Create an array of integers in the range `[0, U)`. 
mZ{Zs2  // Map each item Z in this range to Z.toString(2),
q rXY{  //  split into chars, and reduced by
X^Y}}   //   XORing.
        //  This returns (number of 1s in the binary string) % 2.
        // Implicit: output last expression

संपादित करें: अब आप निम्नलिखित 8-बाइट कोड का उपयोग कर सकते हैं (मान्य नहीं; इस चुनौती के बाद प्रकाशित फीचर):

Uo ®¤¬r^

आप अपनी व्याख्या अपडेट करना चाहते हैं
Eumel

@Eumel मैंने पहले ही किया था ...?
ETHproductions

आपके द्वारा समझा गया कोड और ऊपर दिया गया कोड अलग
Eumel

@Eumel वहाँ, यह बेहतर है?
ईसीएचप्रोडक्शन

बिल्कुल सही :)
यूमेल

4

हास्केल, 39 36 35 बाइट्स

take<*>(iterate([id,(1-)]<*>)[0]!!)

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

यह कैसे काम करता है: -function समय के साथ शुरू [0]और लागू करें । परिणामी सूची से पहले तत्वों को लें । हास्केल के आलस्य के लिए धन्यवाद केवल पहले तत्वों की वास्तव में गणना की जाती है। नोट: पहलाx ++ invert xnnn<*> फ़ंक्शन संदर्भ में है, दूसरा सूची संदर्भ में।

GHC v8.4 के साथ (जो चुनौती के समय उपलब्ध नहीं था) एक 34 बाइट समाधान है:

take<*>(iterate(id<>map(1-))[0]!!)

संपादित करें: -3 सम्मान -4 बाइट्स @ लिकोनी को धन्यवाद। -1 बाइट @ अर्जन जोहान्सन को धन्यवाद।


(\x->x++map(1-)x)([id,(1-)]<*>)या (id<>map(1-))जीएचसी 8.4 के साथ छोटा किया जा सकता है ।
लकोनी

take<*>(iterate([id,(1-)]<*>)[0]!!)
अर्जन जोहान्सन

3

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

निम्मी के समाधान की तुलना में कम कॉम्पैक्ट है, लेकिन मैं आपको कार्यात्मक कोड के इस टुकड़े से इनकार नहीं करना चाहता था। वस्तुओं की किसी भी जोड़ी के लिए काम करता है; जैसे आप (f 0.f 1)द्वारा प्रतिस्थापित कर सकते हैं (f 'A'.f 'B')

परिभाषा के आधार पर कि पहले 2 एन अंकों को बाद में अंकों के एक ही अनुक्रम द्वारा उलटा किया जाता है। हम जो करते हैं वह दो सूचियों का निर्माण साथ-साथ होता है; अनुक्रम के लिए एक, विलोम के लिए एक। लगातार हम एक सूची से दूसरे तक तेजी से लंबे भागों को जोड़ते हैं।

कार्यान्वयन में तीन परिभाषाएँ शामिल हैं:

t=(f 0.f 1)t
f c=flip take.(c:).g 1
g n l=l n++g(n+n)l

फ़ंक्शन tकिसी भी संख्या को स्वीकार करता है और उस लंबाई के थ्यू-मोर्स अनुक्रम को लौटाता है। अन्य दो कार्य सहायक हैं।

  • फ़ंक्शन fया तो सूची का प्रतिनिधित्व करता है; f 0अनुक्रम के f 1लिए है, व्युत्क्रम के लिए।
  • gएक सूची से दूसरी सूची में तेजी से लंबे दोहराव को लागू करने के लिए कार्य का ख्याल रखा जाता है।

फिडल: http://goo.gl/wjk9S0



2

बर्लेस्क, 21 बाइट्स

{0}{J)n!_+}400E!jri.+

उदाहरण:

blsq ) "20"{0}{J)n!_+}400E!jri.+
{0 1 1 0 1 0 0 1 1 0 0 1 0 1 1 0 1 0 0 1}
blsq ) "42"{0}{J)n!_+}400E!jri.+
{0 1 1 0 1 0 0 1 1 0 0 1 0 1 1 0 1 0 0 1 0 1 1 0 0 1 1 0 1 0 0 1 1 0 0 1 0 1 1 0 0 1}

स्पष्टीकरण:

{0}      -- setup
{J)n!_+} -- duplicate, map invert, concatenate
400E!    -- do 400 times (this will eventually run
            out of memory).
jri.+    -- take n elements

jri.+भाग के बिना आप मेमोरी से बाहर निकल जाएंगे (क्योंकि यह लंबाई के मोर्स अनुक्रम को अविश्वसनीय रूप से विशाल संख्या की गणना करेगा )। लेकिन चूंकि बर्लेस्क आलसी है, इसलिए पहले एन-एलिमेंट की मांग करना वैसे भी काम करेगा।


अच्छा लगा। मेरे हास्केल समाधान के समान। हालांकि, मैं एक बाइट को बचाने के लिए केवल 99 बार दोहराता हूं।
नीमी

2

K5, 27 13 बाइट्स

{x#((log x)%log 2){x,~x}/0}

अनुक्रम की गणना करना बहुत आसान है, समस्या बहुत अधिक कंप्यूटिंग से बच रही है। हम यह पहचान सकते हैं कि अनुक्रम का आसान विस्तार हमें उन तारों का अनुक्रम देता है जो लंबाई में दो की क्रमिक शक्तियां हैं। इनपुट का लॉग बेस 2 लेना और राउंड अप करना हमें काम करने के लिए पर्याप्त देगा और फिर हम इसे उपयुक्त आकार में कटौती कर सकते हैं:

  {x#((log x)%log 2){x,~x}/0}'(20 42 37 12 0)
(0 1 1 0 1 0 0 1 1 0 0 1 0 1 1 0 1 0 0 1
 0 1 1 0 1 0 0 1 1 0 0 1 0 1 1 0 1 0 0 1 0 1 1 0 0 1 1 0 1 0 0 1 1 0 0 1 0 1 1 0 0 1
 0 1 1 0 1 0 0 1 1 0 0 1 0 1 1 0 1 0 0 1 0 1 1 0 0 1 1 0 1 0 0 1 1 0 0 1 0
 0 1 1 0 1 0 0 1 1 0 0 1
 ())

संपादित करें:

समता आधारित समाधान:

~=/'(64#2)\'!

कार्रवाई में:

  ~=/'(64#2)\'!20
0 1 1 0 1 0 0 1 1 0 0 1 0 1 1 0 1 0 0 1

ध्यान दें कि चूंकि K5 में एक मनमाना रूप से परिवर्तित-बाइनरी आदिम नहीं है जो मुझे निर्दिष्ट करना होगा, उदाहरण के लिए, 64-बिट डिकोडिंग। K5 मनमाने ढंग से सटीक गणित का उपयोग नहीं करता है, इसलिए इनपुट के आकार की एक सीमा होगी जिसे हम किसी भी मामले में निपट सकते हैं।


2

अष्टक, ३३ 31 बाइट्स

थॉमस केवा के लिए धन्यवाद 2 बाइट्स बचाए।

@(n)mod(sum(dec2bin(0:n-1)'),2)

2

पर्ल 5, 62 49 बाइट्स

हाँ, इस एक के लिए सबसे अच्छी भाषा नहीं है, लेकिन मुझे अभी भी यह पसंद आया है। के लिए /rऔर 5.14+ की आवश्यकता है say

sub{$_=0;$_.=y/01/10/r while$_[0]>length;say substr$_,0,$_[0]}

समता की परिभाषा का उपयोग करते हुए, इसके लिए 5.12+ की आवश्यकता होती है say:

sub{say map{sprintf("%b",$_)=~y/1//%2}0..$_[0]-1}

2

प्रोलोग (एसडब्ल्यूआई), 115 बाइट्स

कोड:

N*X:-N>1,R is N//2,R*Y,X is(N mod 2)xor Y;X=N.
p(N):-M is N-1,findall(E,between(0,M,E),L),maplist(*,L,K),write(K).

व्याख्या की:

N*X:-                                 % Calculate Thue-Morse number at index N
     N>1,                             % Input is bigger than 1
     R is N//2,R*Y,X is(N mod 2)xor Y % Thue-Morse digit at index N is binary digits of N xor'ed
     ;X=N.                            % OR set X to N (end of recursion)
p(N):-
      M is N-1,                       % Get index of Nth number
      findall(E,between(0,M,E),L),    % Make a list of number 0->N-1
      maplist(*,L,K),                 % Map * on list L producing K
      write(K).                       % Print K

उदाहरण:

p(20).
[0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 0, 1]

इसे यहाँ ऑनलाइन आज़माएँ


2

रेटिना , 70 69 बाइट्स

प्रारंभिक शब्द 0और प्रस्तुतियों के साथ एल-सिस्टम के रूप में परिभाषा का उपयोग करना 0 --> 01और 1 --> 10

^
0;
(T`d`ab`^(.)+;(?!(?<-1>.)+$)
a
01
)`b
10
!`^(?=.*;(.)+)(?<-1>.)+

इनपुट यूनीरी में लिया गया है

आप -sध्वज के साथ एक फ़ाइल से कोड चला सकते हैं । या सिर्फ इसे ऑनलाइन आज़माएं।

व्याख्या

^
0;

पहले जोड़ता है 0;इनपुट, जहां के लिए 0प्रारंभिक शब्द है और ;सिर्फ एक विभाजक है।

(T`d`ab`^(.)+;(?!(?<-1>.)+$)

(बताता है कि यह एक पाश (जो जब तक पाश स्ट्रिंग को बदलने बंद हो जाता है दोहराता है) की शुरुआत है। इस चरण में ही बदल जाता है 0और 1में aऔर bक्रमशः (क्योंकि dफैलता करने के लिए 0-9)। यह तब तक करता है जब तक कि वर्तमान शब्द (जिसकी लंबाई को मापा जाता (.)+है इनपुट से कम है (जब तक हम स्ट्रिंग के अंत को पढ़ नहीं सकते हैं जब तक 1कि हम शब्द में हैं)।

a
01

के साथ बदलें a(स्टैंड-इन के लिए 0) 01

)`b
10

के साथ बदलें b(स्टैंड-इन के लिए 1) 10। यह भी लूप का अंत है। एक बार जब लिप्यंतरण चरण में स्थिति विफल हो जाती है, तो लूप समाप्त हो जाता है, क्योंकि तब सभी 0s और 1s अपरिवर्तित रहेंगे और अन्य दो चरणों का मिलान करने के लिए कुछ भी नहीं मिलेगा।

!`^(?=.*;(.)+)(?<-1>.)+

अंतिम चरण इनपुट की लंबाई के लिए शब्द को छोटा करना है। इस बार हम (.)+लुकहेड में इनपुट की लंबाई को मापते हैं । फिर हम स्ट्रिंग की शुरुआत से कई पात्रों का मिलान करते हैं।


2

रूबी, ३३

->n{n.times{|i|p ("%b"%i).sum%2}}

इस तरह कॉल करें:

f=->n{n.times{|i|p ("%b"%i).sum%2}}
f[16]

इस तथ्य का उपयोग करता है कि द्विआधारी संख्याओं की समानता थ्यू-मोर्स अनुक्रम बनाती है।

सेपरेटर कैरेक्टर न्यूलाइन है। धर्मान्तरित संख्याi को एक बाइनरी स्ट्रिंग में करता है, फिर सभी ASCII कोडों के योग की गणना करता है, modulo 2।

यदि नईलाइन स्वीकार्य विभाजक नहीं है, तो अतिरिक्त 2 बाइट्स के लिए निम्नलिखित में कोई विभाजक नहीं है:

->n{n.times{|i|$><<("%b"%i).sum%2}}

2

MATL , 9 बाइट्स

इस भाषा को चुनौती के बाद डिजाइन किया गया था

दृष्टिकोण 1: 13 बाइट्स

यह बढ़ते-आकार के ब्लॉकों की नकारात्मक प्रतियों को संक्षिप्त करके अनुक्रम बनाता है।

itBFw"t~h]w:)

उदाहरण

>> matl itBFw"t~h]w:)
> 20
0 1 1 0 1 0 0 1 1 0 0 1 0 1 1 0 1 0 0 1

व्याख्या

i           % input number, say "N"
tB          % duplicate and convert to binary. Produces a vector
F           % initialize sequence to "false"
w           % swap to bring vector to top
"           % for loop. There will be at least log2(N) iterations
  t~h       % duplicate, negate, concatenate
]           % end for
w           % swap
:)          % index with vector 1, 2, ..., N

दृष्टिकोण 2: 9 बाइट्स

यह अलेफल्फा के उत्तर के समान दृष्टिकोण का उपयोग करता है ।

i:1-B!s2\

उदाहरण

>> matl i:1-B!s2\
> 20
0 1 1 0 1 0 0 1 1 0 0 1 0 1 1 0 1 0 0 1

व्याख्या

i           % input "N" 
:1-         % create vector 0, 1, ..., N-1
B           % convert to binary
!           % tranpose
s           % sum
2\          % modulo 2

2

सी, 88 83 बाइट्स

प्रत्येक व्यक्तिगत स्थिति के लिए समता की गणना करता है।

i,j;main(int c,char**a){for(;i<atoi(a[1]);putchar(c))for(c=48,j=i++;j;j&=j-1)c^=1;}

फिडल: http://goo.gl/znxmOk


2

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

ḶB§Ḃ

ध्यान दें कि यह चुनौती जेली से पुरानी है।

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

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

ḶB§Ḃ  Main link. Argument: n (integer)

Ḷ     Unlength; yield [0, ..., n-1].
 B    Compute the binary representation of each integer in the range.
  §   Take the sum of each binary representation.
   Ḃ  Take the LSB of each sum.

1

मतलब, ४२

मैं इस तथ्य का उपयोग कर रहा हूं कि यह शुरुआत के साथ ही है 0और फिर वर्तमान श्रृंखला के पूरक को जोड़ने के चरण को दोहराते हुए, nबार।

t=0;for k=1:input('');t=[t;~t];end;disp(t)

आप मेरे विचार से
डिस्क्रिप्शन


1

बैश, 71 66 बाइट्स

इस परिभाषा के आधार पर कि पहले 2 n अंकों को बाद में अंकों के एक ही अनुक्रम द्वारा उलटा किया जाता है।

x=0;y=1;while((${#x}<$1));do z=$x;x=$x$y;y=$y$z;done;echo ${x::$1}

$1 एक पैरामीटर के रूप में अंकों की वांछित संख्या है।

फिडल: http://goo.gl/RkDZIC


1

बैच, 115 + 2 = 117 बाइट्स

बैश जवाब के आधार पर।

@echo off
set x=0
set y=1
set z=0
:a
set x=!x!!y!
set y=!y!!z!
set z=!x:~0,%1!
if !z!==!x! goto a
echo !z!

एस /Vके उपयोग की अनुमति देने के लिए आह्वान में एक अतिरिक्त की आवश्यकता है !


1

ईएस 6, 53 बाइट्स

f=(i,x="0",y=1)=>x.length<i?f(i,x+y,y+x):x.slice(0,i)

पुनरावृत्ति एक पाश की तुलना में सरल लग रहा था।


1

बराबर , 8 बाइट्स

✶u[Σ_✶¨^

स्पष्टीकरण:

✶          parse implicit input number
 u         range [0..n-1]
  [        map:
   Σ           convert to binary
    _✶         get digit list
      ¨^       fold with xor

आउटपुट कुछ इस तरह है:

(0 1 1 0 1 0 0 1)

1

मठ ++ , 86 बाइट्स

0.0\n0 और 1.0\n1 के लिए उपयोग करता है

?>n
3*!!(n-m)>$
m>a
0>k
6+6*!a>$
9-2*!(a%2)>$
a/2>a
5>$
(a-1)/2>a
!k>k
5>$
k
m+1>m
2>$

1

अरसीओयू , 50 55 बाइट्स

मुझे इसे सही ढंग से काम करने के लिए 5 बाइट्स जोड़ना पड़ा :(

(f i(_(#(l)))(r b^(@(> i 0)(pg 0(% i 2)(: i(#/ i 2))))0

स्पष्टीकरण (पाइथोस्केस स्यूडोकोड के साथ पक्ष:

(f i (_ (# (l)))       ; For i in range(int(input())):
  (r b^                ; Reduce with binary xor
    (@ (> i 0)         ; While i > 0:
      (pg 0            ; Return first of its arguments
        (% i 2)        ; i mod 2
        (: i (#/ i 2)) ; i //= 2
      )
    )
    0                  ; Default reduce argument of 0 for the first bit in the sequence

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.