이 사이트에는 시퀀스를 인쇄하도록 요청하는 몇 가지 과제가 있지만 예외는 아닙니다.

(이 도전에 대한 순서에 대한 다음 설명은 순서의 기호가 0및 이라고 가정합니다 1.)

의 재귀 정의 Thue-모스 시퀀스 이다

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 시퀀스 를 인쇄하는 프로그램이나 함수를 작성하는 것 입니다. 아래 예제와 같이 출력에는 두 개의 기호가 사용될 수 있습니다.nn

예

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

규칙

• 입력은 음이 아닌 정수입니다. 모든 입력이 유효하다고 가정 할 수 있습니다.

• 출력 n은 편리한 기호를 사용하여 Thu-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의 변형을 기반으로합니다.

iThue-Morse 시퀀스의-번째 자릿수 는 다음 공식을 사용합니다 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::^

여기에서 테스트하십시오.

설명

이것은 1의 이진 표현에서의 수의 패리티를 기반으로 Wikipedia에 제공된 대체 정의를 사용 합니다 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).

와 L-시스템으로 0 --> 01하고 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의 비트 표현으로 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

파이썬 스타일 목록으로 출력합니다.

apt , 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^

하스켈, 39 36 35 바이트

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

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

작동 방식 : -function으로 시작하여 [0]적용x ++ invert xn 시간으로 . n결과 목록에서 첫 번째 요소를 가져옵니다 . Haskell의 게으름 덕분에 첫 번째 n요소 만 실제로 계산됩니다. 참고 : 첫 번째 <*>는 함수 컨텍스트에 있고 두 번째는 목록 컨텍스트에 있습니다.

GHC v8.4 (챌린지 당시에는 사용할 수 없었 음)에는 34 바이트 솔루션이 있습니다.

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

편집 : -3 resp. @Laikoni 덕분에 -4 바이트. @ Ørjan Johansen 덕분에 -1 바이트.

하스켈, 54 바이트

nimi의 솔루션보다 컴팩트하지는 않지만이 기능 코드 난독 화를 거부하고 싶지는 않습니다. 모든 객체 쌍에 적용됩니다. 예를 들어, 당신이 바꿀 수 있습니다 (f 0.f 1)에 의해(f 'A'.f 'B') .

처음 ²ⁿ 이라는 정의에 따라 자리 뒤에 동일한 숫자의 자리가 뒤집힌다 . 우리가하는 일은 두 개의리스트를 나란히 구축하는 것입니다. 하나는 순서에, 하나는 역에 대한 것입니다. 지속적으로 한 목록의 긴 부분을 다른 목록에 추가합니다.

구현은 세 가지 정의로 구성됩니다.

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)

펄 5, 62 49 바이트

예,이 언어에 가장 적합한 언어는 아니지만 여전히 나오는 방식이 마음에 듭니다. /r및에 5.14+가 필요합니다 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}

프롤로그 (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와 제작 을 통해 L 시스템으로 정의 사용 0 --> 01및 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>.)+

마지막 단계는 단어를 입력 길이로 자르는 것입니다. 이번에 (.)+는 lookahead에서 입력 길이를 측정합니다 . 그런 다음 문자열의 시작 부분부터 많은 문자를 찾습니다.

루비, 33

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

이런 식으로 전화하십시오 :

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

이진 숫자의 패리티가 thue-morse 시퀀스를 형성한다는 사실을 사용합니다.

구분 문자는 줄 바꿈입니다. 숫자 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!

s를 /V사용 하려면 추가 호출이 필요합니다 !.

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\n0과 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

공통 리스프 , 50 바이트

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

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