"네거티브"라고 말하면 모든 것을 0으로 바꿉니다 (즉, 비트 부정).

Thu-Morse 시퀀스는 01101001과 같습니다.

생성하는 방법은 다음과 같습니다.

남은 것을 무효화하고 끝에 추가하십시오.

따라서 0. 그것을 부정하고 끝에 추가하십시오-01

그런 다음 그것을 가지고 부정하고 그것을 끝에 추가하십시오- 0110

등등.

이것의 또 다른 흥미로운 속성은 0 사이의 거리가 "비이성적"이고 반복되지 않는 문자열을 생성한다는 것입니다.

그래서:

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 바이트

이것은 처음부터 3 차 Thue-Morse 시퀀스를 작성하는 것을 기반으로하는 매우 기초적인 솔루션입니다. 이 순서는 요청 된 것과 동일하지만 다른 사람은 왜 그런지에 대한 더 자세한 설명을 작성해야합니다. 여하튼,이 순서는 A036580 의 사소한 수정일뿐입니다 .

편집 : for 루프를 목록 이해로 변경하고 함수에서 프로그램으로 변경했으며 모든 것을 Python 2로 변경했습니다 . 골프 도움말 을 위해 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)

이것은 정수를 받아들이고 정수 배열을 반환하는 익명 함수입니다. 호출하려면 변수에 지정하십시오.

우리는 정수로 시작하여, 비트 교환 Thue-모스 시퀀스를 생성 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은 "해당 인덱스의 값이 이와 같은 위치에있는이 인덱스의 모든 인덱스를 얻을 수있는"쉬운 방법이 없기 때문에 약간의 창의성을 가져야합니다.

여기서 우리는 "이진 확장에서 짝수의 1을 갖는 숫자"인 A001969를 사용하고 있는데 , 이는 Thue-Morse 시퀀스에서 0의 인덱스 를 완전히 우연히 제공합니다. ;-)

는 filter그 수를 계산합니다. 예를 들어, x 4을 줄 것 9입니다. 우리는 단순히 0에서 인덱스되기 때문에 뺄셈에서 0입력으로 반복하고 루프의 각 반복은 다음 숫자와 현재 숫자 의 차이를 인쇄합니다 . 출력이 파이프 라인에 추가되고 개행으로 암시 적으로 출력됩니다.$args[0]1

예

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

하스켈, 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-first-- nelements 기능 을 구현하는 데 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을 더한 값으로 주어집니다 .

한편, 모스 Thue - 시퀀스 를 얻을 수 의 이진 표현에서 사람의 수가 N 부터 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 바이트

암호:

Î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

온라인으로 사용해보십시오!

파이썬, 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이 순서 의 세 번째 항은입니다 1+t(i+1)-t(i). 여기서 tThu-Morse 함수입니다. 코드는 재귀 적으로 구현하는데,

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

Mathematica, 65 바이트

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

내 다른 대답은 이기지 만 매운 골프 버전을 이기는 것은 아닙니다 . 이제 일반적으로 코드를 따옴표로 묶은 다음 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 바이트 절약

자바 스크립트 (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

루비, 57 바이트

xnor의 Python 답변 포트. 변화는 대부분의 삼항 성명에서 거짓말 t의 장소 and로 인해 0루비 truthy되고, 그리고 사용 (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]}}

티카 ( 거의 비언어적) 107 110 바이트

({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가 제안한대로.