这个站点上有很多挑战，要求您打印一个序列，这也不例外。

（此挑战序列的以下说明假定序列中的符号为0和1。）

Thue-Morse序列的递归定义是

T_0 = 0
T_2n = T_n
T_2n+1 = 1 - T_n

一个更直接的定义是，从0到2**m-1和的序列2**m to 2**(m+1)-1是二进制补码。因此0，其后是1，之后是，01之后是10，0110然后是1001和，向前跳了一点，0110100110010110之后是1001011001101001。

面临的挑战是编写一个程序或函数来打印出第一个元素的Thue-Morse序列n，其中n任何非负整数都是。输出可以使用任何两个符号，如下例所示。

例子

>>> tm_01(20)
01101001100101101001
>>> tm_ab(42)
abbabaabbaababbabaababbaabbabaabbaababbaab
>>> tm_paren(37)
())()(())(()())()(()())(())()(())(()(
>>> tm_space_star(12)
 ** *  **  *
>>> tm_01(0)
                # to show that this is a valid input

规则

• 输入将是任何非负整数。您可以假设所有输入均有效。

• 输出必须是nThue-Morse序列的第一个元素，使用任何方便的符号。如果愿意，还可以添加分隔符。在我的示例中，我没有。 注意：此规则允许使用列表（如Python的列表），这,是有效的分隔符，我不介意输出中的[和开头或结尾的字符]。

• 这是代码高尔夫，因此最少的字节数获胜。

与往常一样，如果问题仍然不清楚，请告诉我。祝你好运，打高尔夫球！

目录

var QUESTION_ID=65549;var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe";var COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk";var OVERRIDE_USER=47581;var answers=[],answers_hash,answer_ids,answer_page=1,more_answers=true,comment_page;function answersUrl(index){return"http://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+index+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(index,answers){return"http://api.stackexchange.com/2.2/answers/"+answers.join(';')+"/comments?page="+index+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:true,success:function(data){answers.push.apply(answers,data.items);answers_hash=[];answer_ids=[];data.items.forEach(function(a){a.comments=[];var id=+a.share_link.match(/\d+/);answer_ids.push(id);answers_hash[id]=a});if(!data.has_more)more_answers=false;comment_page=1;getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:true,success:function(data){data.items.forEach(function(c){if(c.owner.user_id===OVERRIDE_USER)answers_hash[c.post_id].comments.push(c)});if(data.has_more)getComments();else if(more_answers)getAnswers();else process()}})}getAnswers();var SCORE_REG=/<h\d>\s*([^\n,<]*(?:<(?:[^\n>]*>[^\n<]*<\/[^\n>]*>)[^\n,<]*)*),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/;var OVERRIDE_REG=/^Override\s*header:\s*/i;function getAuthorName(a){return a.owner.display_name}function process(){var valid=[];answers.forEach(function(a){var body=a.body;a.comments.forEach(function(c){if(OVERRIDE_REG.test(c.body))body='<h1>'+c.body.replace(OVERRIDE_REG,'')+'</h1>'});var match=body.match(SCORE_REG);if(match)valid.push({user:getAuthorName(a),size:+match[2],language:match[1],link:a.share_link,});else console.log(body)});valid.sort(function(a,b){var aB=a.size,bB=b.size;return aB-bB});var languages={};var place=1;var lastSize=null;var lastPlace=1;valid.forEach(function(a){if(a.size!=lastSize)lastPlace=place;lastSize=a.size;++place;var answer=jQuery("#answer-template").html();answer=answer.replace("{{PLACE}}",lastPlace+".").replace("{{NAME}}",a.user).replace("{{LANGUAGE}}",a.language).replace("{{SIZE}}",a.size).replace("{{LINK}}",a.link);answer=jQuery(answer);jQuery("#answers").append(answer);var lang=a.language;lang=jQuery('<a>'+lang+'</a>').text();languages[lang]=languages[lang]||{lang:a.language,lang_raw:lang.toLowerCase(),user:a.user,size:a.size,link:a.link}});var langs=[];for(var lang in languages)if(languages.hasOwnProperty(lang))langs.push(languages[lang]);langs.sort(function(a,b){if(a.lang_raw>b.lang_raw)return 1;if(a.lang_raw<b.lang_raw)return-1;return 0});for(var i=0;i<langs.length;++i){var language=jQuery("#language-template").html();var lang=langs[i];language=language.replace("{{LANGUAGE}}",lang.lang).replace("{{NAME}}",lang.user).replace("{{SIZE}}",lang.size).replace("{{LINK}}",lang.link);language=jQuery(language);jQuery("#languages").append(language)}}

body{text-align:left!important}#answer-list{padding:10px;width:290px;float:left}#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"> <div id="language-list"> <h2>Shortest Solution by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr> </thead> <tbody id="languages"> </tbody> </table> </div> <div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr> </thead> <tbody id="answers"> </tbody> </table> </div> <table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr> </tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr> </tbody> </table>

Pyth，6个字节

xMjR2Q

在线尝试：演示

基于@ThomasKwa的解决方案和@FryAmTheEggman的变体。

它使用以下公式： i Thue-Morse序列中 -th数字是：xor(digits of i in base 2)。

说明：

xMjR2Q   implicit: Q = input number
  jR2Q   convert each number in [0, 1, ..., Q-1] to its binary digits
xM       xor each binary list

CJam，17个 9字节

ri{2b:^}/

要么

ri,2fb::^

在这里测试。

说明

它使用Wikipedia上的替代定义，该定义基于1的二进制表示形式中s 数的奇偶性n。

ri   e# Read input and convert to integer n.
{    e# For each i from 0 to n-1...
  2b e#   Convert i to base 2.
  :^ e#   Fold XOR over the bits to compute the parity of the number of 1s.
}/

替代解决方案用于在使用中缀运算符来计算二进制表示形式和XOR之前，无需使用块,就n显式地将其转换为范围[0 ... n-1]。

奖励解决方案

这是基于其他定义的一些解决方案。如果有两个方案，一个短会炸毁内存非常快（因为预计算产生2^n截断为前位n）。

作为带有0 --> 01和的L系统1 --> 10：

ri_2mL2,\{2,aA+f=s:~}*<
ri_2,\{2,aA+f=s:~}*<

通过否定并追加上一部分：

ri_2mL2,\{_:!+}*<
ri_2,\{_:!+}*<

使用质询中给出的递归关系，使用divmod和XOR来区分两个递归定义：

ri{Ta{2md\j^}j}/

（当然，这种递归关系只是将Thue-Morse序列表示为的二进制表示形式的1位奇偶校验的另一种方式n。）

Dyalog APL，8个 7字节

≠⌿⍴∘2⊤⍳

这是单轨火车，它的索引原点为0（⎕IO←0）。等效的非训练函数为{≠⌿(⍵⍴2)⊤⍳⍵}。

说明：

      ⍳      List of numbers from 0 to (input-1)
  ⍴∘2        (input) copies of 2
     ⊤       Convert all the elements in ⍳ to base 2 to (input) digits
≠⌿           Reduce over the first axis by not-equal

输出是一个空格分隔的列表0和1。在这里尝试。

Mathematica，35个 21字节

Mathematica具有Thue-Morse序列的内置函数！

Array[ThueMorse,#,0]&

原始答案：

#&@@@DigitCount[Range@#-1,2]~Mod~2&

LabVIEW，15个LabVIEW原语

现在作为带有探针的超级精美gif

J，12 11字节

@MartinBüttner保存了一个字节。

~:/@#:"0@i.

这是一元函数（表示一元函数），用法如下：

   f =: ~:/@#:"0@i.
   f 10
0 1 1 0 1 0 0 1 1 0

说明

我正在使用另一种定义，即T _n是_n的二进制表示形式中1位数目的奇偶校验。

~:/@#:"0@i.  Input is n.
~:/          Output is XOR folded over
   @#:       the binary representations of
      "0     each element of
        @i.  integers from 0 to n-1.

Pyth，11个10字节

m%ssM.Bd2Q

输出为Python样式列表。

Japt，29 11 字节

Uo ®¤¬r@X^Y

在线尝试！

直接输出为数组，节省大约4个字节。

脱节和解释

Uo ®   ¤  ¬ r@  X^Y
Uo mZ{Zs2 q rXY{X^Y}}
        // Implicit: U = input number
Uo      // Create an array of integers in the range `[0, U)`. 
mZ{Zs2  // Map each item Z in this range to Z.toString(2),
q rXY{  //  split into chars, and reduced by
X^Y}}   //   XORing.
        //  This returns (number of 1s in the binary string) % 2.
        // Implicit: output last expression

编辑：您现在可以使用以下8字节代码（无效；此挑战后发布的功能）：

Uo ®¤¬r^

Haskell，39 36 35字节

take<*>(iterate([id,(1-)]<*>)[0]!!)

在线尝试！

工作原理：从开始[0]并应用x ++ invert x-function n时间。n从结果列表中获取第一个元素。由于Haskell的惰性n，实际上只计算了第一个元素。注意：第一个<*>在函数上下文中，第二个在列表上下文中。

使用GHC v8.4（在挑战时尚不可用）有一个34字节的解决方案：

take<*>(iterate(id<>map(1-))[0]!!)

编辑：-3分别。-4个字节感谢@Laikoni。-1个字节感谢@ØrjanJohansen。

Haskell，54个字节

不如nimi的解决方案紧凑，但我不想否认您对功能代码的这种混淆。适用于任何一对物体；例如，你可以替换(f 0.f 1)的(f 'A'.f 'B')。

根据定义，前2 ^个n位数字后跟相同的数字序列。我们要做的是并排建立两个列表。一个用于序列，一个用于逆。不断地，我们将一个列表中越来越长的部分添加到另一个列表中。

该实现包含三个定义：

t=(f 0.f 1)t
f c=flip take.(c:).g 1
g n l=l n++g(n+n)l

函数t接受任何数字并返回该长度的Thue-Morse序列。其他两个功能是助手。

• 函数f代表任一列表；f 0用于序列，f 1用于逆。
• 函数g负责将一个列表的越来越长的重复追加到另一个列表。

小提琴：http：//goo.gl/wjk9S0

Pari / GP，33字节

n->[sumdigits(x,2)%2|x<-[0..n-1]]

在线尝试！

滑稽，21字节

{0}{J)n!_+}400E!jri.+

例子：

blsq ) "20"{0}{J)n!_+}400E!jri.+
{0 1 1 0 1 0 0 1 1 0 0 1 0 1 1 0 1 0 0 1}
blsq ) "42"{0}{J)n!_+}400E!jri.+
{0 1 1 0 1 0 0 1 1 0 0 1 0 1 1 0 1 0 0 1 0 1 1 0 0 1 1 0 1 0 0 1 1 0 0 1 0 1 1 0 0 1}

说明：

{0}      -- setup
{J)n!_+} -- duplicate, map invert, concatenate
400E!    -- do 400 times (this will eventually run
            out of memory).
jri.+    -- take n elements

没有这个jri.+部分，您将耗尽内存（因为它将计算出莫尔斯序列的长度令人难以置信的巨大数字）。但是由于Burlesque很懒，所以无论如何都要求第一个n元素有效。

K5，27 13个字节

{x#((log x)%log 2){x,~x}/0}

计算序列非常容易，问题在于避免计算过多。我们可以认识到，序列的容易扩展使我们得到了一个字符串序列，该字符串是长度为2的连续幂。取输入的对数为2并四舍五入将使我们有足够的工作量，然后可以将其缩减为适当的大小：

  {x#((log x)%log 2){x,~x}/0}'(20 42 37 12 0)
(0 1 1 0 1 0 0 1 1 0 0 1 0 1 1 0 1 0 0 1
 0 1 1 0 1 0 0 1 1 0 0 1 0 1 1 0 1 0 0 1 0 1 1 0 0 1 1 0 1 0 0 1 1 0 0 1 0 1 1 0 0 1
 0 1 1 0 1 0 0 1 1 0 0 1 0 1 1 0 1 0 0 1 0 1 1 0 0 1 1 0 1 0 0 1 1 0 0 1 0
 0 1 1 0 1 0 0 1 1 0 0 1
 ())

编辑：

基于奇偶校验的解决方案：

~=/'(64#2)\'!

实际上：

  ~=/'(64#2)\'!20
0 1 1 0 1 0 0 1 1 0 0 1 0 1 1 0 1 0 0 1

请注意，由于K5没有任意的转换成二进制原语，因此我必须指定例如64位解码。K5不使用任意精度数学，因此在任何情况下我们都可以处理的输入大小受到限制。

八度，33 31字节

感谢Thomas Kwa，节省了2个字节。

@(n)mod(sum(dec2bin(0:n-1)'),2)

Perl 5，62 49字节

是的，这不是最好的语言，但是我仍然喜欢它的出现方式。要求5.14+的/r和say。

sub{$_=0;$_.=y/01/10/r while$_[0]>length;say substr$_,0,$_[0]}

使用奇偶校验定义，需要5.12+ say：

sub{say map{sprintf("%b",$_)=~y/1//%2}0..$_[0]-1}

Prolog（SWI），115字节

码：

N*X:-N>1,R is N//2,R*Y,X is(N mod 2)xor Y;X=N.
p(N):-M is N-1,findall(E,between(0,M,E),L),maplist(*,L,K),write(K).

解释：

N*X:-                                 % Calculate Thue-Morse number at index N
     N>1,                             % Input is bigger than 1
     R is N//2,R*Y,X is(N mod 2)xor Y % Thue-Morse digit at index N is binary digits of N xor'ed
     ;X=N.                            % OR set X to N (end of recursion)
p(N):-
      M is N-1,                       % Get index of Nth number
      findall(E,between(0,M,E),L),    % Make a list of number 0->N-1
      maplist(*,L,K),                 % Map * on list L producing K
      write(K).                       % Print K

例：

p(20).
[0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 0, 1]

在这里在线尝试

视网膜， 70 69字节

将定义用作带有初始词0，产生式0 --> 01和的L系统1 --> 10。

^
0;
(T`d`ab`^(.)+;(?!(?<-1>.)+$)
a
01
)`b
10
!`^(?=.*;(.)+)(?<-1>.)+

输入已取 一元形式。

您可以从带有-s标志的单个文件中运行代码。要不就在线尝试。

说明

^
0;

预先考虑0;到输入端，其中，0是初始字和;仅仅是一个隔板。

(T`d`ab`^(.)+;(?!(?<-1>.)+$)

的(指示，这是一个循环（其反复进行，直到循环停止改变字符串）的开头。此阶段本身变成0并分别1变成a和b（因为d扩展为0-9）。只要当前单词（用来测量其长度(.)+比输入短）（即只要我们无法通过匹配1单词中的s 来读取字符串的末尾），它就会执行此操作。

a
01

更换 a（替代0）01。

)`b
10

用代替b（替代1）10。这也是循环的结束。一旦音译阶段的条件失败，循环就会终止，因为所有0s和1s都将保持不变，而其他两个阶段将找不到任何匹配项。

!`^(?=.*;(.)+)(?<-1>.)+

最后一步是将单词截断为输入的长度。这次，我们(.)+以超前方式测量输入的长度。然后我们从字符串的开头匹配那么多字符。

红宝石，33岁

->n{n.times{|i|p ("%b"%i).sum%2}}

像这样打电话：

f=->n{n.times{|i|p ("%b"%i).sum%2}}
f[16]

使用二进制数的奇偶校验形成周-莫尔斯序列的事实。

分隔符为换行符。转换数字i为二进制字符串，然后计算所有ASCII码的模数之和2。

如果换行符不是可接受的分隔符，则以下没有附加的2个字节的分隔符：

->n{n.times{|i|$><<("%b"%i).sum%2}}

MATL，9个字节

该语言是在挑战之后设计的。

方法1：13个字节

这通过级联递增大小的块的否定副本来构建序列。

itBFw"t~h]w:)

例

>> matl itBFw"t~h]w:)
> 20
0 1 1 0 1 0 0 1 1 0 0 1 0 1 1 0 1 0 0 1

说明

i           % input number, say "N"
tB          % duplicate and convert to binary. Produces a vector
F           % initialize sequence to "false"
w           % swap to bring vector to top
"           % for loop. There will be at least log2(N) iterations
  t~h       % duplicate, negate, concatenate
]           % end for
w           % swap
:)          % index with vector 1, 2, ..., N

方法2：9个字节

这使用与Alephalpha的答案相同的方法。

i:1-B!s2\

例

>> matl i:1-B!s2\
> 20
0 1 1 0 1 0 0 1 1 0 0 1 0 1 1 0 1 0 0 1

说明

i           % input "N" 
:1-         % create vector 0, 1, ..., N-1
B           % convert to binary
!           % tranpose
s           % sum
2\          % modulo 2

C，88 83字节

计算每个单独位置的奇偶校验。

i,j;main(int c,char**a){for(;i<atoi(a[1]);putchar(c))for(c=48,j=i++;j;j&=j-1)c^=1;}

小提琴：http：//goo.gl/znxmOk

果冻，4字节

ḶB§Ḃ

请注意，这个挑战比果冻要古老。

在线尝试！

怎么运行的

ḶB§Ḃ  Main link. Argument: n (integer)

Ḷ     Unlength; yield [0, ..., n-1].
 B    Compute the binary representation of each integer in the range.
  §   Take the sum of each binary representation.
   Ḃ  Take the LSB of each sum.

Matlab，42岁

我使用的事实是，它与开始相同0，然后重复添加当前系列的补码的步骤n。

t=0;for k=1:input('');t=[t;~t];end;disp(t)

𝔼𝕊𝕄𝕚𝕟，11个字符/ 23个字节（非竞争性）

Ⓐïⓜ_ⓑⓢĊ⇀$^_

Try it here (Firefox only).

这个圈子很强大。

重击 71 66字节

根据定义，前2 ^个n位数字后跟相同的数字序列。

x=0;y=1;while((${#x}<$1));do z=$x;x=$x$y;y=$y$z;done;echo ${x::$1}

$1 作为参数是所需的位数。

小提琴：http：//goo.gl/RkDZIC

批处理，115 + 2 = 117字节

基于Bash的答案。

@echo off
set x=0
set y=1
set z=0
:a
set x=!x!!y!
set y=!y!!z!
set z=!x:~0,%1!
if !z!==!x! goto a
echo !z!

需要额外/V的调用以允许使用!s。

ES6，53个字节

f=(i,x="0",y=1)=>x.length<i?f(i,x+y,y+x):x.slice(0,i)

递归似乎比循环更简单。

Par，8字节

✶u[Σ_✶¨^

说明：

✶          parse implicit input number
 u         range [0..n-1]
  [        map:
   Σ           convert to binary
    _✶         get digit list
      ¨^       fold with xor

输出类似：

(0 1 1 0 1 0 0 1)

数学++，86字节

用途0.0\n为0和1.0\n1

?>n
3*!!(n-m)>$
m>a
0>k
6+6*!a>$
9-2*!(a%2)>$
a/2>a
5>$
(a-1)/2>a
!k>k
5>$
k
m+1>m
2>$

Arcyóu，50 55字节

我必须添加5个字节才能使其正常工作:(

(f i(_(#(l)))(r b^(@(> i 0)(pg 0(% i 2)(: i(#/ i 2))))0

说明（侧面带有Pythonesque伪代码：

(f i (_ (# (l)))       ; For i in range(int(input())):
  (r b^                ; Reduce with binary xor
    (@ (> i 0)         ; While i > 0:
      (pg 0            ; Return first of its arguments
        (% i 2)        ; i mod 2
        (: i (#/ i 2)) ; i //= 2
      )
    )
    0                  ; Default reduce argument of 0 for the first bit in the sequence

普通Lisp，50字节

(lambda(n)(dotimes(i n)(princ(mod(logcount i)2))))

在线尝试！