Not, "olumsuzlama" dediğimde, hepsini sıfırlarla değiştirmek (yani bitsel bir olumsuzlama)

Thue-Morse dizisi 01101001 gibi gider

Oluşturma şekliniz:

0 alarak başlayın. Kalan şeyi düzenleyin ve sonuna ekleyin.

Yani, al 0. Sıkıştırın ve sonuna ekleyin -01

Sonra bunu al ve reddet ve sonuna ekle - 0110

Ve bunun gibi.

Bunun bir başka ilginç özelliği de sıfırlar arasındaki mesafenin "mantıksız" ve tekrar etmeyen bir dize yaratmasıdır.

Yani:

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

N girişi olduğunda, yazdırılacak dizenin ilk n basamağını çıkaracak bir program yazabilir misiniz?

Bu kod golf, çok az sayıda bayt kazanır!

Jöle, 9 bayt

;¬$‘¡TI’ḣ

Çevrimiçi deneyin!

Nasıl çalışır

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

Bu, sıfırdan üçlü Thue-Morse dizisi oluşturmaya dayanan oldukça temel bir çözümdür. Bu sekans, sorulanla aynıdır, ancak bir başkası bunun nedeninin daha ayrıntılı bir açıklamasını yazmak zorunda kalacaktır. Her halükarda, bu dizi bunun sadece A036580'in önemsiz bir modifikasyonudur .

Düzenleme: for döngüsü bir liste kavrama olarak değiştirildi, bir fonksiyondan bir programa değişti ve her şeyi Python 2 olarak değiştirdi . Golf yardımı için Dennis'e teşekkürler .

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 bayt

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

Bu, bir tamsayıyı kabul eden ve bir tamsayı dizisi döndüren anonim bir işlevdir. Bunu çağırmak için bir değişkene atayın.

Biz bir tamsayı başlayarak bit takas Thue-Morse dizisi üretmek m = 1, o zaman ekleme 1-miçin mbir dizi olarak n+1kez, ngirişidir. Bu ihtiyacımız olandan daha fazla terim üretir. Daha sonra kullanarak olanları buluruz, find(m)kullanarak ardışık değerler arasındaki farkı diffalırız ve 1 öğesini çıkartırız. nOrtaya çıkan dizinin ilk terimlerini almak bize istediğimizi verir.

6 bayt kaydedildi ve Dennis sayesinde bir sorun düzeltildi!

PowerShell, 102 bayt

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

Biraz farklı bir hesaplama yöntemi. PowerShell'in "bu dizindeki değerin böyle ve benzeri olduğu tüm dizileri alması" için kolay bir yolu yoktur , bu yüzden biraz yaratıcı olmamız gerekir.

Burada , Thue-Morse dizisindeki 0'ların indekslerini tamamen tesadüfen veren "ikili genişlemelerinde çift sayıda 1" olan sayılar "olan A001969'u kullanıyoruz . ;-)

Bu filtersayıyı hesaplar. Örneğin, x 4verecekti 9. Daha sonra basitçe gelen döngü 0bizim girişine $args[0], çıkarılarak 1biz sıfır endeksli çünkü ve arasındaki fark üzerinden döngü baskısı her yineleme sonraki numara ve mevcut sayı. Çıktı boru hattına eklenir ve dolaylı olarak yeni satırlarla çıkar.

Misal

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

Haskell, 42 bayt

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

Kullanım örneği: (`take`l) 7-> [2,1,0,2,0,1,2].

Bu bir uygulamasıdır var a036585_listdan A036585 aşağı kaymıştır 0, 1ve 2. Golf: concat (map f l)olduğunu f =<< lve f 0=[0,1,2]; f 1=[0,2]; f 2=[1]öyle ([[0..2],[0,2],[1]]!!).

Not: lsonsuz dizidir. İlk ntercihleri ​​alma özelliğini uygulamak 10 bayt veya yaklaşık% 25 sürer .

Mathematica, 79 68 70 bayt

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

MATL , 14 11 bayt

Q:qB!Xs2\dQ

Çevrimiçi deneyin!

İçinde @TimmyD işaret ettiği gibi onun cevabını , istenen dizi ardışık farklılıkların verilir A001969 . Sonuncusu sırayla Thue-Morse dizisi artı 2 * n olarak elde edilebilir . Bu nedenle istenen sekans (Thue-Morse sekansının ardışık farklılıkları) artı bir tarafından verilir .

Öte yandan, Thue-Morse dizisi , n = 0'dan başlayarak n'nin ikili gösteriminde yer alanların sayısı olarak elde edilebilir .

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 bayt

Kod:

ÎFDSÈJJ}¥1+¹£

Açıklama:

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

Çevrimiçi deneyin!

Python, 69 bayt

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

iBu dizinin inci terimdir 1+t(i+1)-t(i)burada, tThue-Morse fonksiyonudur. Kod, yinelemeli olarak uygular, bu da

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

Mathematica, 65 bayt

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

Diğer cevabımı atıyor ama ekstra baharatlı golf versiyonunu geçmiyor. Şimdi normalde kodumu tırnak içinde yapıştırıyorum, sonra Mathematica kodunuza boşluk eklemeyi çok seviyor çünkü (hiçbir şey yapmıyor) ama asla dizelerle uğraşmıyor, ama bu tırnak işaretleri olan kod için çalışmıyor ...

Her neyse, sadece bunun için sihirli yapıyı kullanıyorum. Çıktı bir dizedir.

Mathematica, 58 bayt

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

Perl, 45 + 2 = 47 bayt

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

-pVe -aişaretini gerektirir :

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

@ Sherlock9 bağlantı noktası

Ton sayesinde 9 bayt kaydedildi

JavaScript (ES6), 73 67 bayt

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

Bağlantı noktası @ Sherlock9'un cevabı.

edit: @WashingtonGuedes sayesinde 6 bayt kaydedildi.

CJam (19 bayt)

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

Çevrimiçi demo

Bu, Thue-Morse dizisinin elemanları arasındaki ardışık farkları artırma yaklaşımını kullanır.

Yeniden yazma kurallarını kullanarak en kısa yaklaşımım 21 bayt:

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

(Uyarı: yavaş). Bu, yeniden yazma kurallarını kodlar

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

gibi

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

Ruby, 57 bayt

Xnor'ın Python cevabının bir limanı. Değişiklikler çoğunlukla içinde üçlü açıklamada yalan tyerine andnedeniyle 0Ruby truthy olma ve kullanma (1..n).mapve 1+t[i]-t[i-1]doğrudan liste anlama ithal bayt vs kaydedin.

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

Mathematica ( hemen hemen sözel), 107 110 bayt

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

Sekans, tekrarlayan bir değiştirme kuralı uygulanarak oluşturulur. Başka bir kural onu istenen çıktıya dönüştürür. Yeterli insan ilgiliyse, ayrıntılı olarak açıklayacağım.

alfasayısal olmayan sürüm

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

CatsAreFluffy tarafından önerildiği gibi.