หมายเหตุเมื่อฉันพูดว่า "ลบล้าง" ฉันหมายถึงแทนที่ค่าทั้งหมดด้วยศูนย์ (เช่นการลบล้างแบบ bitwise)

ลำดับ Thue-Morse เป็นเช่น 01101001

วิธีที่คุณสร้างมันคือ:

เริ่มต้นด้วยการ 0 ปฏิเสธสิ่งที่เหลืออยู่และผนวกเข้ากับท้าย

เอา0ล่ะ ลบมันและเพิ่มไปยังจุดสิ้นสุด -01

จากนั้นนำสิ่งนั้นมาและลบล้างมันและบวกมันไปยังจุดสิ้นสุด - 0110

และอื่น ๆ

คุณสมบัติที่น่าสนใจอีกอย่างของที่นี่คือระยะห่างระหว่างศูนย์สร้างสตริง "ไม่มีเหตุผล" และสตริงที่ไม่ซ้ำกัน

ดังนั้น:

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

คุณสามารถเขียนโปรแกรมที่เมื่อป้อน n จะส่งออกตัวเลข n ตัวแรกของสตริงที่จะพิมพ์หรือไม่?

นี่คือรหัสกอล์ฟจำนวนไบต์ที่สั้นที่สุดจึงจะชนะ!

เยลลี่ขนาด 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.

Python 3 2, 104 92 88 84 ไบต์

นี่เป็นวิธีการแก้ปัญหาพื้นฐานที่สวยงามตามการสร้างลำดับที่สามของ Thue-Morse ตั้งแต่เริ่มต้น ลำดับนี้เหมือนกับสิ่งที่ถูกถามถึงแม้ว่าบางคนจะต้องเขียนคำอธิบายอย่างละเอียดมากขึ้นว่าทำไมถึงเป็นเช่นนั้น ลำดับนี้เป็นเพียงการปรับเปลี่ยนเล็กน้อยของA036580นี้

แก้ไข:เปลี่ยนการวนรอบสำหรับเป็นความเข้าใจในรายการเปลี่ยนจากฟังก์ชั่นเป็นโปรแกรมและเปลี่ยนทุกสิ่งเป็น Python 2 ขอบคุณDennisสำหรับการเล่นกอล์ฟ

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

Julia, 56 50 ไบต์

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

นี่คือฟังก์ชั่นที่ไม่ระบุชื่อที่ยอมรับจำนวนเต็มและส่งกลับอาร์เรย์จำนวนเต็ม หากต้องการเรียกใช้กำหนดค่าให้กับตัวแปร

เราสร้างลำดับ Thue-Morse ที่สลับบิตโดยเริ่มต้นด้วยจำนวนเต็มm = 1จากนั้นเราจะผนวก1-mเข้าmกับn+1เวลาอาร์เรย์ซึ่งnเป็นอินพุต สิ่งนี้สร้างคำศัพท์มากกว่าที่เราต้องการ จากนั้นเราจะค้นหาสิ่งที่ใช้find(m)รับความแตกต่างระหว่างค่าที่ใช้ติดต่อกันdiffและลบ 1 elementwise การรับnเงื่อนไขแรกของอาร์เรย์ผลลัพธ์จะให้สิ่งที่เราต้องการ

บันทึก 6 ไบต์และแก้ไขปัญหาด้วย Dennis!

PowerShell, 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 ในลำดับ Thue-Morse โดยบังเอิญ ;-)

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

Haskell, 42 ไบต์

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

ตัวอย่างการใช้งาน: ->(`take`l) 7[2,1,0,2,0,1,2]

มันเป็นเรื่องการดำเนินการa036585_listจากA036585ขยับลงไป0, และ1 2กอล์ฟ: concat (map f l)เป็นf =<< lและเป็น f 0=[0,1,2]; f 1=[0,2]; f 2=[1]([[0..2],[0,2],[1]]!!)

หมายเหตุ: lเป็นลำดับที่ไม่มีที่สิ้นสุด ใช้เวลา 10 ไบต์หรือประมาณ 25% ในการใช้คุณสมบัตินำnองค์ประกอบแรก

Mathematica, 79 68 70 ไบต์

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

MATL , 14 11 ไบต์

Q:qB!Xs2\dQ

ลองออนไลน์!

ในฐานะที่เป็นแหลมออกโดย @TimmyD ในคำตอบของเขาลำดับที่ต้องการจะได้รับจากความแตกต่างของการติดต่อกันA001969 หลังสามารถในการเปิดรับได้เป็นลำดับ Thue-มอร์บวก 2 * n ดังนั้นลำดับที่ต้องการจะได้รับจาก(ความแตกต่างติดต่อกันของลำดับ Thue-มอร์ส) บวกหนึ่ง

ในทางตรงกันข้ามลำดับ Thue-Morse สามารถรับได้เป็นจำนวนของการแทนเลขฐานสองของnเริ่มต้นจาก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

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

ลองออนไลน์!

Python ขนาด 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ระยะ TH ของลำดับนี้เป็น1+t(i+1)-t(i)ที่tเป็นฟังก์ชั่น Thue-มอร์ส รหัสดำเนินการซ้ำซึ่งสั้นกว่า

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

Mathematica, 65 ไบต์

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

Beats คำตอบอื่น ๆ ของฉัน แต่ไม่ชนะ extra- เผ็ดแข็งแรงเล่นกอล์ฟรุ่น ปกติตอนนี้ฉันติดโค้ดของฉันในเครื่องหมายคำพูดแล้วดึงออกเพราะ Mathematica ชอบเพิ่มช่องว่างให้กับโค้ดของคุณ (ซึ่งไม่ทำอะไรเลย) แต่มันไม่เคยยุ่งกับสตริง แต่มันไม่ทำงานกับโค้ดที่มีเครื่องหมายคำพูด ...

อะไรก็ตามฉันแค่ใช้เวทย์มนตร์ในตัว เอาต์พุตเป็นสตริง

Mathematica, 58 ไบต์

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

Perl, 45 + 2 = 47 ไบต์

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

ต้องการ-pและ-aธง:

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

พอร์ตของ @ Sherlock9 คำตอบ

บันทึกแล้ว 9 ไบต์ขอบคุณ Ton

JavaScript (ES6), 73 67 ไบต์

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

คำตอบของพอร์ตของ @ Sherlock9

แก้ไข: บันทึกแล้ว 6 ไบต์ขอบคุณ @WashingtonGuedes

CJam (19 ไบต์)

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

การสาธิตออนไลน์

วิธีนี้ใช้วิธีการเพิ่มความแตกต่างอย่างต่อเนื่องระหว่างองค์ประกอบของลำดับ Thue-Morse

แนวทางที่สั้นที่สุดของฉันที่ใช้กฎการเขียนใหม่คือ 21 ไบต์:

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

(คำเตือน: ช้า) สิ่งนี้เข้ารหัสกฎการเขียนซ้ำ

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

เช่น

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

Ruby, 57 ไบต์

พอร์ตของคำตอบ Python ของ xnor การเปลี่ยนแปลงส่วนใหญ่อยู่ในคำสั่งที่สามtแทนandเนื่องจาก0ความจริงใน Ruby และการใช้(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]}}

Mathematica ( เกือบไม่มีอวัจนภาษา), 107 110 bytes

({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 แนะนำ