थ्यू-मोर्स अनुक्रम में अंतर प्रिंट करें

Question

ध्यान दें, जब मैं "नेगेट" कहता हूं, तो मेरा मतलब है कि सभी को शून्य (यानी थोड़ा सा नकारात्मक) से बदल दें

थु-मोर्स अनुक्रम 01101001 की तरह होता है

जिस तरह से आप इसे उत्पन्न करते हैं वह है:

0. नेगेट क्या बचा है इसे लेकर शुरू करें और इसे अंत तक जोड़ें।

तो, ले लो 0। इसे हटा दें और इसे अंत तक जोड़ें -01

फिर इसे लें और इसे नकार दें और इसे अंत तक जोड़ दें - 0110

और इसी तरह।

इसकी एक और दिलचस्प संपत्ति यह है कि शून्य के बीच की दूरी एक "तर्कहीन" और गैर-दोहराए जाने वाले स्ट्रिंग बनाती है।

इसलिए:

0110100110010110
|__|_||__||_|__|
 2  1 0 2 01 2          <------------Print this!

क्या आप एक प्रोग्राम लिख सकते हैं, जब इनपुट n, स्ट्रिंग के पहले n अंक को प्रिंट करेगा?

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

Comments

आउटपुट के लिए एक विशिष्ट आधार की आवश्यकता नहीं है। थ्यू-मोर्स अनुक्रम स्वयं वांछित आउटपुट है, एकात्मक में और 0 विभाजक के रूप में।

— डेनिस

oeis.org/A036577

— xnor

Answer 1

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

;¬$‘¡TI’ḣ

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

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

;¬$‘¡TI’ḣ  Main link. Argument: n

  $        Create a monadic chain that does the following to argument A (list).
 ¬         Negate all items of A.
;          Concatenate A with the result.
   ‘¡      Execute that chain n + 1 times, with initial argument n.
     T     Get all indices of truthy elements (n or 1).
      I    Compute the differences of successive, truthy indices.
       ’   Subtract 1 from each difference.
        ḣ  Keep the first n results.

Answer 2

पायथन 3 2, 104 92 88 84 बाइट्स

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

संपादित करें: लूप के लिए एक सूची समझ में बदल गया, एक फ़ंक्शन से एक प्रोग्राम में बदल गया, और पूरी चीज़ को पायथन में बदल दिया । गोल्फ की मदद के लिए डेनिस को धन्यवाद ।

n=input()
s="2"
while len(s)<n:s="".join(`[1,20,210][int(i)]`for i in s)
print s[:n]

Answer 3

जूलिया, 56 50 बाइट्स

n->(m=1;[m=[m;1-m]for _=0:n];diff(find(m))[1:n]-1)

यह एक अनाम फ़ंक्शन है जो पूर्णांक को स्वीकार करता है और पूर्णांक सरणी देता है। इसे कॉल करने के लिए, इसे किसी वैरिएबल पर असाइन करें।

हम एक पूर्णांक के साथ शुरू से थोड़ा-बदली Thue-मोर्स अनुक्रम उत्पन्न m = 1है, तो हम संलग्न 1-mकरने के लिए mएक सरणी के रूप में n+1कई बार, जहां nइनपुट है। यह हमारी आवश्यकता से अधिक शब्द उत्पन्न करता है। हम तब उपयोग करने वाले का पता लगाते हैं find(m), लगातार उपयोग करने वाले मूल्यों के बीच अंतर प्राप्त करते हैं diff, और 1 तत्व को घटाते हैं। nपरिणामी सरणी के पहले शब्दों को लेने से हमें वही मिलता है जो हम चाहते हैं।

6 बाइट्स बचाए और डेनिस की बदौलत एक मुद्दा तय किया!

Answer 4

पॉवरशेल, 102 बाइट्स

filter x($a){2*$a+([convert]::toString($a,2)-replace0).Length%2}
0..($args[0]-1)|%{(x($_+1))-(x $_)-1}

कंप्यूटिंग के एक अलग तरीके का एक छोटा सा। PowerShell के पास इस सरणी में "सभी सूचकांकों को प्राप्त करने का एक आसान तरीका नहीं है जहां उस सूचकांक का मूल्य इस तरह के और इस तरह के बराबर होता है ", इसलिए हमें थोड़ा रचनात्मक होने की आवश्यकता है।

यहां हम A001969 का उपयोग कर रहे हैं , "उनके द्विआधारी विस्तार में 1s की संख्या के साथ संख्या", जो पूरी तरह से संयोग से थ्यू-मोर्स अनुक्रम में 0s के सूचकांकों को देता है। ;-)

filterउस संख्या की गणना करता है। उदाहरण के लिए, x 4दे देंगे 9। हम तब 0अपने इनपुट से लूप करते हैं $args[0], घटाना 1क्योंकि हम शून्य-अनुक्रमित हैं, और लूप के प्रत्येक पुनरावृत्ति अगले नंबर और वर्तमान संख्या के बीच के अंतर को प्रिंट करते हैं । आउटपुट को पाइप लाइन पर जोड़ा जाता है और नए सिरे से आउटपुट का अनुमान लगाया जाता है।

उदाहरण

PS C:\Tools\Scripts\golfing> .\print-the-difference-in-the-thue-morse.ps1 6
2
1
0
2
0
1

Comments

A001969 के साथ संबंध एक महान खोज है!

— लुइस मेन्डो

Answer 5

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

l=2:(([[0..2],[0,2],[1]]!!)=<<l)
(`take`l)

प्रयोग उदाहरण: (`take`l) 7-> [2,1,0,2,0,1,2]।

यह A036585a036585_list से लागू किया गया है , और नीचे स्थानांतरित कर दिया गया है । गोल्फ: है और है । 012concat (map f l)f =<< lf 0=[0,1,2]; f 1=[0,2]; f 2=[1]([[0..2],[0,2],[1]]!!)

नोट: lअनंत क्रम है। टेक- nफर्स्ट- -मेंट्स फीचर को लागू करने के लिए 10 बाइट्स या लगभग 25% लगते हैं।

Answer 6

मैथेमेटिका, 79 68 70 बाइट्स

(Differences[Join@@Position[Nest[#~Join~(1-#)&,{0},#+2],0]]-1)[[;;#]]&

Comments

के लिए विफल है n<3।

— मर्फी

Answer 7

MATL , 14 11 बाइट्स

Q:qB!Xs2\dQ

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

जैसा कि @TimmyD ने अपने उत्तर में बताया है , वांछित क्रम A001969 के निरंतर अंतरों द्वारा दिया गया है । बाद में थ्यू-मोर्स अनुक्रम प्लस 2 * एन के रूप में प्राप्त किया जा सकता है । इसलिए वांछित अनुक्रम (थ्यू-मोर्स अनुक्रम के लगातार अंतर) प्लस एक द्वारा दिया जाता है ।

दूसरी ओर, Thue-मोर्स अनुक्रम प्राप्त किया जा सकता की बाइनरी प्रतिनिधित्व में लोगों की संख्या के रूप में एन , से शुरू n = 0।

Q:q    % take input n implicitly and generate row vector [0,1,...,n]
B!     % 2D array where columns are the binary representations of those numbers
Xs     % sum of each column. Gives a row vector of n+1 elements
2\     % parity of each sum
d      % consecutive differences. Gives a row vector of n elements
Q      % increase by 1. Display implicitly

Comments

क्या मैं (थ्यू-मोर्स अनुक्रम के लगातार अंतर) प्लस 1 में कोष्ठकीकरण का अनुरोध कर सकता हूं ?

— कैलकुलेटरफ्लीन

@CatsAreFluffy आप पूरी तरह से सही हैं। हो गया

— लुइस मेंडो

Answer 8

05AB1E , 14 13 बाइट्स

कोड:

ÎFDSÈJJ}¥1+¹£

स्पष्टीकरण:

Î              # Push 0 and input
 F     }       # Do the following n times
  DS           # Duplicate and split
    È          # Check if even
     JJ        # Join the list then join the stack
        ¥1+    # Compute the differences and add 1
           ¹£  # Return the [0:input] element

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

Answer 9

पायथन, 69 बाइट्स

t=lambda n:n and n%2^t(n/2)
lambda n:[1+t(i+1)-t(i)for i in range(n)]

iइस क्रम की वें शब्द है 1+t(i+1)-t(i)जहां, tThue-मोर्स कार्य है। कोड इसे पुनरावर्ती रूप से लागू करता है, जो इससे छोटा है

t=lambda n:bin(n).count('1')%2

Answer 10

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

SubstitutionSystem[{"0"->"012","1"->"02","2"->"1"},"0",#][[;;#]]&

मेरे दूसरे जवाब को धड़कता है, लेकिन अतिरिक्त मसालेदार को हरा नहीं करता है गोल्फ संस्करण । अब आम तौर पर मैं अपना कोड उद्धरण चिह्नों में बांधता हूं, फिर इसे बाहर निकालता हूं क्योंकि Mathematica को आपके कोड में रिक्त स्थान जोड़ना पसंद है (जो कुछ भी नहीं करते हैं) लेकिन यह तार के साथ कभी भी गड़बड़ नहीं करता है, लेकिन यह उस कोड के लिए काम नहीं करता है जो स्वयं उद्धरण है ...

जो भी हो, मैं इसके लिए सिर्फ मैजिक बिलिन का उपयोग कर रहा हूं। आउटपुट एक स्ट्रिंग है।

Comments

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

— कैलक्यूलेटरफिलीन

Answer 11

मैथेमेटिका, 58 बाइट्स

Differences[Nest[Join[#,1-#]&,{0},#]~Position~0][[;;#]]-1&

Comments

मुझे कैसे पता चलेगा कि आपने मेरा समाधान नहीं निकाला है और इसे गोल्फ में डाला है?

— कैलकुलेटरफ्लीन

@catsarefluffy मैंने अनुक्रम को उत्पन्न करने के लिए आपके विचार को अनुकूलित किया (infix ऑपरेटर को काटकर गोल्फिंग), लेकिन यह महसूस किया कि यहाँ जिस विधि का उपयोग किया गया था, उसे परिवर्तित करना बहुत ही अलग और एक सुझाए गए संपादन की तुलना में नए उत्तर के लिए अधिक अनुकूल था।

— एक सीमन्स

@catsarefluffy मैंने अभी-अभी आपका संपादन देखा है। जब मैंने ऐसा किया था, तो मैंने इसे अपने मूल रूप में देखा था। मैं इस उत्तर को निकाल दूंगा, लेकिन आपको बस मुझ पर भरोसा करना होगा कि यह स्वतंत्र था :)

— ए सिमंस

1;;#बस के साथ बदला जा सकता है ;;#।

— लीजियनममाल 978

वास्तव में मुझे टिम्मीड के जवाब से आउटपुट ट्रांसफ़ॉर्म मिला। (विशेष रूप से, पहले पैराग्राफ ने मुझे इसके बारे में याद Position

— कैलकुलेटरफ्लीन

Answer 12

पर्ल, 45 + 2 = 47 बाइट्स

$_=2;s/./(1,20,210)[$&]/ge until/.{@F}/;say$&

आवश्यक है -pऔर -aझंडा:

$ perl -pa morse-seq.pl <<< 22                                                                            
2102012101202102012021

पोर्ट ऑफ @ शरलॉक 9 जवाब

सहेजे गए 9 बाइट्स टू टन के लिए धन्यवाद

Comments

-aविकल्प आपको इनपुट के एक मुक्त प्रतिलिपि, देता है तो$_=2;s/./(1,20,210)[$&]/ge until/.{@F}/;$_=$&

— टन Hospel

@ सही, यह विश्वास नहीं कर सकता कि मैं उस के बारे में नहीं सोचा था :-) और मैं के -pसाथ बचा सकता है -E: say$&अंत में अगर हम मानते हैं कि पर्ल> v5.18

— andlrc

Answer 13

जावास्क्रिप्ट (ईएस 6), 73 67 बाइट्स

f=(n,s="2")=>s[n]?s.slice(0,n):f(n,s.replace(/./g,c=>[1,20,210][c]))

पोर्ट ऑफ @ शर्लक 9 का जवाब।

संपादित करें: सहेजे गए 6 बाइट्स के लिए @WashingtonGuedes धन्यवाद।

Comments

के !s[n]स्थान पर काम करेगा s.length<n? या हो सकता है बस उल्टे के s[n]साथ ?:?

— हटा दिया

Answer 14

CJam (19 बाइट्स)

1ri){2b:^}%2ew::-f-

ऑनलाइन डेमो

यह थ्यू-मोर्स अनुक्रम के तत्वों के बीच क्रमिक अंतर को बढ़ाने के दृष्टिकोण का उपयोग करता है।

---

पुनर्लेखन नियमों का उपयोग करने वाला मेरा सबसे छोटा तरीका 21 बाइट्स है:

ri_2a{{_*5*)3b~}%}@*<

(चेतावनी: धीमा)। यह पुनर्लेखन नियमों को कूटबद्ध करता है

0  ->  1
1  ->  20
2  ->  210

जैसा

x -> (5*x*x + 1) in base 3

Answer 15

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

Xnor के पायथन जवाब का एक बंदरगाह। परिवर्तन ज्यादातर में त्रिगुट बयान में झूठ tके स्थान पर andकी वजह से 0रूबी में truthy जा रहा है, और का उपयोग कर (1..n).mapऔर 1+t[i]-t[i-1]बाइट्स बनाम को बचाने के लिए सीधे सूची समझ का आयात।

t=->n{n<1?n:n%2^t[n/2]}
->n{(1..n).map{|i|1+t[i]-t[i-1]}}

Comments

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

— कैलक्यूलेटरफिलीन

@CatsAreFluffy मेरे अनुभव में, खराब

— शर्लक

Answer 16

गणितज्ञ ( लगभग अशाब्दिक), १०atic ११० बाइट्स

({0}//.{n__/;+n<2#}:>{n,{n}/.x_:>(1-x)/._[x__]:>x}//.{a___,0,s:1...,0,b___}:>{a,+s/.(0->o),0,b}/.o->0)[[;;#]]&

प्रतिस्थापन नियम को बार-बार लागू करने से अनुक्रम उत्पन्न होता है। एक और नियम इसे वांछित आउटपुट में बदल देता है। यदि पर्याप्त लोग रुचि रखते हैं, तो मैं विस्तार से बताऊंगा।

गैर-अल्फ़ान्यूमेरिक संस्करण

({$'-$'}//.{$__/;+$/#
<($'-$')!+($'-$')!}:>
{$,{$}/.$$_:>(($'-$')
!-$$)/.{$$__}:>$$}//.
{$___,$'-$',$$:($'-$'
)!...,$'-$',$$$___}:>
{$,+$$/.($'-$'->$$$$)
,$'-$',$$$}/.$$$$->$'
-$')[[;;#]]

CatsAreFluffy द्वारा सुझाए गए अनुसार।

Comments

मुझे लगता है कि यह मान लेना सुरक्षित है कि लोग किसी भी उत्तर के बारे में स्पष्टीकरण के लिए पर्याप्त रुचि रखते हैं। केवल अपने लिए बोलते हुए, मैं स्पष्टीकरण के बिना प्रस्तुतियाँ नहीं बढ़ाता (जब तक कि दृष्टिकोण स्पष्ट नहीं है)।

— एलेक्स ए।

और यदि आप सभी अक्षरों को अनुक्रम में $बदल देते हैं 0और x-x(जहाँ x का अप्रयुक्त अनुक्रम है $) से बदल देते हैं (और (x-x)!1 (ditto) के लिए उपयोग करते हैं), तो हम अल्फ़ान्यूमेरिक-मुक्त हो जाते हैं।

— कैलक्यूलेटरफलिन

बाइटसेव: {x__}इसके बजाय का उपयोग करें_[x__]

— कैलक्यूलेटरफैनलाइन

मुझे वास्तव में पूरा यकीन है कि मैथेमेटिका केवल प्रतीकों पर ट्यूरिंग-पूर्ण है या $[_]:=-/;(काउंटर मशीन एमुलेशन द्वारा)

— कैलकुलेटरफनलीन