Beachten Sie, wenn ich "negieren" sage, meine ich, alle Einsen durch Nullen zu ersetzen (dh eine bitweise Negation)

Die Thue-Morse-Sequenz lautet 01101001

Die Art und Weise, wie Sie es generieren, ist:

Beginnen Sie mit 0. Negieren Sie, was noch übrig ist, und hängen Sie es an das Ende an.

Also, nimm 0. Negiere es und füge das zum Ende hinzu -01

Dann nimm das und negiere es und füge es am Ende hinzu - 0110

Und so weiter.

Eine weitere interessante Eigenschaft ist, dass der Abstand zwischen Nullen eine "irrationale" und sich nicht wiederholende Zeichenfolge erzeugt.

Damit:

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

Können Sie ein Programm schreiben, das bei Eingabe von n die ersten n Ziffern der zu druckenden Zeichenfolge ausgibt?

Dies ist Code Golf, also gewinnt die kürzeste Anzahl von Bytes!

Gelee, 9 Bytes

;¬$‘¡TI’ḣ

Probieren Sie es online aus!

Wie es funktioniert

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

Dies ist eine ziemlich rudimentäre Lösung, die darauf basiert, eine ternäre Thue-Morse-Sequenz von Grund auf neu zu erstellen. Diese Sequenz ist identisch mit der angefragten, obwohl jemand anderes eine gründlichere Erklärung schreiben muss, warum das so ist. In jedem Fall ist diese Sequenz nur eine triviale Modifikation dieser Sequenz, A036580 .

Bearbeiten: Die for-Schleife wurde in ein Listenverständnis geändert, von einer Funktion in ein Programm geändert und das Ganze in Python 2 geändert. Vielen Dank an Dennis für die Hilfe beim Golfen.

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 Bytes

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

Dies ist eine anonyme Funktion, die eine Ganzzahl akzeptiert und ein Ganzzahlarray zurückgibt. Um es aufzurufen, weisen Sie es einer Variablen zu.

Wir erzeugen die bitgetauschte Thue-Morse-Sequenz, indem m = 1wir mit einer ganzen Zahl beginnen , und hängen 1-msie dann mals Array- n+1Zeiten an, wobei ndie Eingabe ist. Dies erzeugt mehr Begriffe als wir brauchen. Wir lokalisieren dann diejenigen mit find(m), ermitteln die Differenz zwischen aufeinanderfolgenden Werten mit diffund subtrahieren 1 elementweise. Wenn wir die ersten nTerme des resultierenden Arrays nehmen, erhalten wir, was wir wollen.

6 Bytes gespeichert und ein Problem dank Dennis behoben!

PowerShell, 102 Byte

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

Ein bisschen anders rechnen. PowerShell hat keine einfache Möglichkeit, "alle Indizes in diesem Array abzurufen, bei denen der Wert an diesem Index gleich so und so ist ", daher müssen wir etwas kreativ werden.

Hier verwenden wir A001969 , die "Zahlen mit einer geraden Anzahl von Einsen in ihrer binären Erweiterung", die völlig zufällig die Indizes der Nullen in der Thue-Morse-Sequenz angibt. ;-);

Der filterberechnet diese Zahl. Zum Beispiel x 4würde geben 9. Wir schleifen dann einfach von 0zu unserer Eingabe $args[0]und subtrahieren, 1weil wir nullindiziert sind, und jede Iteration der Schleife druckt die Differenz zwischen der nächsten und der aktuellen Zahl aus. Die Ausgabe wird der Pipeline hinzugefügt und implizit mit Zeilenumbrüchen ausgegeben.

Beispiel

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

Haskell, 42 Bytes

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

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

Es ist eine Implementierung a036585_listvon A036585 nach unten verschoben zu 0, 1und 2. Golfen: concat (map f l)ist f =<< lund f 0=[0,1,2]; f 1=[0,2]; f 2=[1]ist ([[0..2],[0,2],[1]]!!).

Hinweis: list die unendliche Folge. Die Implementierung der Take-First- nElements-Funktion dauert 10 Byte oder etwa 25% .

Mathematica, 79 68 70 Bytes

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

MATL , 14 11 Bytes

Q:qB!Xs2\dQ

Probieren Sie es online aus!

Wie @TimmyD in seiner Antwort hervorhob , ist die gewünschte Reihenfolge durch die aufeinanderfolgenden Unterschiede von A001969 gegeben . Letzteres kann wiederum als Thue-Morse-Sequenz plus 2 * n erhalten werden . Daher ist die gewünschte Sequenz gegeben durch (aufeinanderfolgende Unterschiede der Thue-Morse-Sequenz) plus eins .

Auf der anderen Seite ist die Morsefolge erhalten werden , wenn die Anzahl der Einsen in der binären Darstellung von n , ausgehend von n = 0 ist .

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 Bytes

Code:

ÎFDSÈJJ}¥1+¹£

Erläuterung:

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

Probieren Sie es online aus!

Python, 69 Bytes

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

Der idritte Term dieser Sequenz lautet 1+t(i+1)-t(i): Wo tist die Thue-Morse-Funktion? Der Code implementiert es rekursiv, was kürzer als ist

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

Mathematica, 65 Bytes

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

Schlägt meine andere Antwort, schlägt aber nicht die extra scharfe Golfversion. Normalerweise stecke ich meinen Code in Anführungszeichen und ziehe ihn dann heraus, weil Mathematica es liebt, Ihrem Code Leerzeichen hinzuzufügen (die nichts bewirken), aber es wird nie mit Zeichenfolgen durcheinander gebracht, aber das funktioniert nicht für Code, der selbst Anführungszeichen enthält ...

Wie auch immer, ich benutze nur die Magie, die dafür eingebaut ist. Die Ausgabe ist eine Zeichenfolge.

Mathematica, 58 Bytes

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

Perl, 45 + 2 = 47 Bytes

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

Benötigt das -pund -aFlag:

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

Port von @ Sherlock9 Antwort

9 Bytes dank Ton gespart

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 @ Sherlock9s Antwort.

Bearbeiten: 6 Bytes dank @WashingtonGuedes gespeichert.

CJam (19 Bytes)

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

Online-Demo

Dies verwendet den Ansatz, die aufeinanderfolgenden Unterschiede zwischen Elementen der Thue-Morse-Sequenz zu erhöhen.

Mein kürzester Ansatz mit Umschreibregeln ist 21 Byte:

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

(Warnung: langsam). Dies codiert die Umschreibregeln

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

wie

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

Ruby, 57 Bytes

Eine Portierung von xnors Python-Antwort. Die Veränderungen liegen vor allem in der ternären Aussage in tanstelle des andwegen 0sind truthy in Ruby und die Verwendung (1..n).mapund 1+t[i]-t[i-1]Bytes vs. speichern direkt auf die Liste Verständnis importieren.

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

Mathematica ( fast nonverbal), 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)[[;;#]]&

Die Sequenz wird durch wiederholtes Anwenden einer Ersetzungsregel generiert. Eine andere Regel wandelt es in die gewünschte Ausgabe um. Wenn genügend Leute interessiert sind, werde ich im Detail erklären.

nicht alphanumerische Version

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

wie von CatsAreFluffy vorgeschlagen.