请注意，当我说“求反”时，我的意思是将所有的都替换为零（即按位求反）

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.

蟒3 2，104个 92 88 84字节

这是一个非常基本的解决方案，基于从头开始构建三元Thue-Morse序列。这个顺序与被询问的顺序是相同的，尽管其他人将不得不写一个更彻底的解释。无论如何，该序列只是对该序列A036580的简单修改。

编辑：将for循环更改为列表理解，从函数更改为程序，并将整个内容更改为Python2。感谢Dennis提供的高尔夫帮助。

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

朱莉娅，56 50字节

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

这是一个接受整数并返回整数数组的匿名函数。要调用它，请将其分配给变量。

我们通过用整数开始产生位交换图厄莫尔斯序列m = 1，那么我们追加1-m到m作为数组n+1次，其中n是输入。这产生了比我们需要更多的术语。然后find(m)，我们使用来定位，使用来获取连续值之间的差diff，然后逐个减去1。取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，即“二进制扩展中偶数为1的数字”，它完全重合地给出了Thue-Morse序列中0的索引。;-)

在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是无限序列。实施Take- nfirst - elements功能需要10个字节或大约25％。

Mathematica，79 68 70字节

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

MATL，14 11字节

Q:qB!Xs2\dQ

在线尝试！

正如@TimmyD在其答案中指出的那样，所需的序列由A001969的连续差给出。后者又可以作为Thue-Morse序列加2 * n获得。因此，所需的序列由（Thue-Morse序列的连续差）加1给出。

另一方面，从n = 0 开始，Thue-Morse序列可以作为n的二进制表示形式中的1的数目获得。

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-Morse函数。该代码以递归方式实现，比

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

Mathematica，65个字节

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

击败我的其他答案，但不打预算外辣 golfed版本。现在通常我将我的代码放在引号中，然后将其拔出，因为Mathematica喜欢在代码中添加空格（不执行任何操作），但它永远不会与字符串混淆，但这不适用于本身带有引号的代码...

不管怎样，我只是在使用内置的魔术。输出是一个字符串。

Mathematica，58个字节

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

Perl，45 + 2 = 47字节

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

需要-pand -a标志：

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

@ Sherlock9的端口答案

Ton节省了9个字节

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的答案的端口。

编辑：由于@WashingtonGuedes，节省了6个字节。

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个字节

xnor的Python答案端口。更改主要在于三元语句，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（几乎非语言），107110字节

({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所建议。