Catatan, ketika saya mengatakan "negate", maksud saya ganti semua yang dengan nol (yaitu negasi bitwise)

Urutan Thue-Morse berjalan seperti 01101001

Cara Anda menghasilkannya adalah:

Mulailah dengan mengambil 0. Meniadakan apa yang tersisa dan menambahkannya sampai akhir.

Jadi, ambil 0. Negasikan dan tambahkan itu sampai akhir -01

Kemudian ambil itu dan negasikan dan tambahkan itu sampai akhir - 0110

Dan seterusnya.

Properti lain yang menarik dari ini adalah bahwa jarak antara nol menciptakan string "irasional" dan tidak berulang.

Begitu:

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

Bisakah Anda menulis sebuah program yang, ketika menginput n, akan menampilkan n digit pertama dari string yang akan dicetak?

Ini adalah kode golf, sehingga jumlah byte terpendek menang!

Jelly, 9 byte

;¬$‘¡TI’ḣ

Cobalah online!

Bagaimana itu bekerja

;¬$‘¡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 byte

Ini adalah solusi yang sangat sederhana berdasarkan pada membangun urutan Thue-Morse ternary dari awal. Urutan ini identik dengan yang diminta, meskipun orang lain harus menulis penjelasan yang lebih menyeluruh tentang mengapa itu. Bagaimanapun, urutan ini hanya modifikasi sepele dari yang ini, A036580 .

Sunting: Mengubah loop for menjadi daftar pemahaman, berubah dari fungsi ke program, dan mengubah semuanya menjadi Python 2. Terima kasih kepada Dennis untuk bantuan golf.

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 byte

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

Ini adalah fungsi anonim yang menerima integer dan mengembalikan array integer. Untuk menyebutnya, tetapkan ke variabel.

Kami menghasilkan bit-bertukar Thue-Morse urutan dengan memulai dengan integer m = 1, maka kita tambahkan 1-mke msebagai array n+1kali, di mana nadalah input. Ini menghasilkan lebih banyak istilah daripada yang kita butuhkan. Kami kemudian menemukan yang menggunakan find(m), mendapatkan perbedaan antara menggunakan nilai berturut-turut diff, dan mengurangi 1 elemen. Mengambil nsyarat pertama dari array yang dihasilkan memberi kita apa yang kita inginkan.

Disimpan 6 byte dan memperbaiki masalah berkat Dennis!

PowerShell, 102 byte

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

Sedikit cara komputasi yang berbeda. PowerShell tidak memiliki cara mudah untuk "mendapatkan semua indeks dalam array ini di mana nilai pada indeks itu sama dengan ini -dan-itu ", jadi kita perlu sedikit kreatif.

Di sini kita menggunakan A001969 , "angka dengan angka genap 1s dalam ekspansi biner mereka", yang sepenuhnya secara kebetulan memberikan indeks 0s dalam urutan Thue-Morse. ;-)

The filtermenghitung jumlah itu. Misalnya x 4mau memberi 9. Kami kemudian hanya loop dari 0ke input kami $args[0], mengurangi 1karena kami diindeks nol, dan setiap iterasi dari loop mencetak perbedaan antara angka berikutnya dan nomor saat ini. Output ditambahkan ke pipeline dan secara implisit output dengan baris baru.

Contoh

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

Haskell, 42 byte

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

Contoh penggunaan: (`take`l) 7-> [2,1,0,2,0,1,2].

Ini merupakan implementasi a036585_listdari A036585 bergeser ke 0, 1dan 2. Golf: concat (map f l)ada f =<< ldan f 0=[0,1,2]; f 1=[0,2]; f 2=[1]sedang ([[0..2],[0,2],[1]]!!).

Catatan: ladalah urutan yang tak terbatas. Dibutuhkan 10 byte atau sekitar 25% untuk mengimplementasikan fitur take- nfirst - elemen.

Mathematica, 79 68 70 byte

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

MATL , 14 11 byte

Q:qB!Xs2\dQ

Cobalah online!

Seperti yang ditunjukkan oleh @TimmyD dalam jawabannya , urutan yang diinginkan diberikan oleh perbedaan berturut-turut A001969 . Yang terakhir pada gilirannya dapat diperoleh sebagai urutan Thue-Morse ditambah 2 * n . Oleh karena itu urutan yang diinginkan diberikan oleh (perbedaan berurutan dari urutan Thue-Morse) ditambah satu .

Di sisi lain, urutan Thue-Morse dapat diperoleh sebagai jumlah yang dalam representasi biner dari n , mulai dari 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 byte

Kode:

ÎFDSÈJJ}¥1+¹£

Penjelasan:

Î              # 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

Cobalah online!

Python, 69 byte

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

The ijangka th urutan ini 1+t(i+1)-t(i), di mana tadalah fungsi Thue-Morse. Kode mengimplementasikannya secara rekursif, yang lebih pendek dari

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

Mathematica, 65 byte

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

Mengalahkan jawaban saya yang lain, tetapi tidak mengalahkan versi golf ekstra pedas . Sekarang biasanya saya menempelkan kode saya pada tanda kutip, kemudian menariknya keluar karena Mathematica suka menambahkan spasi pada kode Anda (yang tidak melakukan apa-apa) tetapi tidak pernah mengacaukan string, tetapi itu tidak berfungsi untuk kode yang memiliki tanda kutip ...

Apa pun, aku hanya menggunakan sihir bawaan untuk ini. Output adalah string.

Mathematica, 58 byte

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

Perl, 45 + 2 = 47 byte

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

Membutuhkan -pdan -amenandai:

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

Port of @ Sherlock9 menjawab

Disimpan 9 byte berkat Ton

JavaScript (ES6), 73 67 byte

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

Port of @ Sherlock9 menjawab.

sunting: Disimpan 6 byte berkat @WashingtonGuedes.

CJam (19 byte)

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

Demo online

Ini menggunakan pendekatan incrementing perbedaan berturut-turut antara elemen dari urutan Thue-Morse.

Pendekatan terpendek saya menggunakan aturan penulisan ulang adalah 21 byte:

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

(Peringatan: lambat). Ini mengkodekan aturan penulisan ulang

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

sebagai

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

Ruby, 57 byte

Port jawaban Python xnor. Perubahan sebagian besar terletak pada pernyataan ternary tdi tempat andkarena 0menjadi benar di Ruby, dan menggunakan (1..n).mapdan 1+t[i]-t[i-1]menyimpan byte vs mengimpor daftar pemahaman secara langsung.

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

Mathematica ( hampir nonverbal), 107 110 byte

({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)[[;;#]]&

Urutan dihasilkan dengan berulang kali menerapkan aturan penggantian. Aturan lain mengubahnya menjadi output yang diinginkan. Jika cukup banyak orang yang tertarik, saya akan jelaskan secara terperinci.

versi non-alfanumerik

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

seperti yang disarankan oleh CatsAreFluffy.