이것은 I / O 요구 사항을 최근 표준에 맞게 조정하기 위해 오래된 도전 에 대한 내용입니다. 이는 더 많은 언어가이 인기있는 시퀀스에 대한 도전에 참여할 수 있도록하기위한 것입니다. 재 게시 에 대한 토론은 이 메타 게시물 을 참조하십시오 .

Kolakoski 시퀀스는 재미있는 자체 참조 시퀀스로 OEIS 시퀀스 A000002 (A000001보다 이해하고 구현하기가 훨씬 쉽습니다)를 기립니다. 시퀀스가 시작 1 단 구성 1 S 및 2 개 (S) 및 시퀀스 소자 A (N) 의 길이를 설명 N 의 런 제 1 S 또는 2 개 순서들. 이것은 시퀀스를 고유하게 정의합니다 (아래에 런을 시각화하여).

1,2,2,1,1,2,1,2,2,1,2,2,1,1,2,1,1,2,2,1,2,1,1,2,1,2,2,1,1,2,1,1,2,...
= === === = = === = === === = === === = = === = = === === = === =
1, 2,  2, 1,1, 2, 1, 2,  2, 1, 2,  2, 1,1, 2, 1,1, 2,  2, 1, 2, 1,...

물론 당신의 임무는이 순서를 구현하는 것입니다. 세 가지 형식 중 하나를 선택할 수 있습니다.

1. 입력 n을 취하여 시퀀스 의 n 번째 항을 출력합니다 . 여기서 n 은 0 또는 1 에서 시작합니다 .
2. 입력 n을 취하여 시퀀스 의 n 번째 항 까지 포함 하여 항 을 출력합니다 . 여기서 n 은 0 또는 1 에서 시작합니다 (즉, 첫 번째 n 또는 첫 번째 n + 1 항을 인쇄합니다 ).
3. 시퀀스의 값을 무기한으로 출력합니다.

두 번째 및 세 번째 경우에는 합리적이고 명확한 목록 형식을 선택할 수 있습니다. 요소 사이에 구분 기호가 없으면 정의에 따라 항상 한 자리 수이므로 괜찮습니다.

세 번째 경우 제출이 함수 인 경우 무한 목록 또는 생성기를 지원하는 언어로 생성자를 반환 할 수도 있습니다.

당신은 쓸 수 있습니다 프로그램이나 기능을 우리의 사용 표준 방법 입력을 수신하고 출력을 제공합니다. 참고 이러한 허점은 기본적으로 금지되어 있습니다.

이것은 code-golf 이므로 바이트 단위로 측정 된 가장 짧은 유효한 답변이 이깁니다.

젤리 , 7 바이트

2Rṁxṁµ¡

이것은 첫 번째 n 용어 를 인쇄하는 전체 프로그램입니다 .

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

작동 원리

2Rṁxṁµ¡  Main link. Argument: n (integer)

     µ   Combine the preceding links into a monadic chain.
      ¡  Set t = n.  Call the chain n times, updating t with the return value after
         each call. Yield the last value of t.
2R           Set the return value to 2 and take its range. Yields [1, 2].
  ṁ          Mold; cyclically repeat 1 and 2 to match t's length.
             In the first run, ṁ promotes t = n to [1, ..., n].
   x         Repeat the k-th element of the result t[k] times.
             In the first run, x repeats each element t = n times.
    ṁ        Mold; truncate the result to match the length of t.
             In the first run, ṁ promotes t = n to [1, ..., n].                 

예제 실행

n = 5 이라고하자 .

체인의 첫 번째 호출은 1, 2를 주기적으로 반복 하여 길이 5 에 도달 한 다음 각 요소를 5 번 도달 하고 마지막으로 결과를 길이 5로 절단합니다 .

  1         2         1         2         1
x 5         5         5         5         5
---------------------------------------------------
  1 1 1 1 1 2 2 2 2 2 1 1 1 1 1 2 2 2 2 2 1 1 1 1 1

  1 1 1 1 1

길이 5 의 목록이 생성 됩니다. 첫 번째 요소는 Kolakoski 시퀀스의 첫 번째 요소입니다.

체인의 두 번째 호출은 1, 2를 주기적으로 반복하여 길이 5 에 도달 한 다음 k ^번째 요소 j 배 를 반복합니다 . 여기서 j 는 이전 목록 의 k ^번째 요소이며 결과는 길이 5로 잘립니다 .

   1 2 1 2 1
x  1 1 1 1 1
------------
   1 2 1 2 1

   1 2 1 2 1

이렇게하면 길이가 5 인 다른 목록이 생성 됩니다. 처음 두 요소는 Kolakoski 시퀀스의 처음 두 요소입니다.

이 과정은 세 번 더 반복됩니다.

   1 2   1 2   1
x  1 2   1 2   1
----------------
   1 2 2 1 2 2 1

   1 2 2 1 2

   1 2   1   2 1
x  1 2   2   1 2
------------------
   1 2 2 1 1 2 1 1

   1 2 2 1 1

   1 2   1   2 1
x  1 2   2   1 1
----------------
   1 2 2 1 1 2 1

   1 2 2 1 1

이것들은 Kolakoski 시퀀스의 처음 다섯 요소입니다.

파이썬 2 , 51 바이트

l=[2]
print 1,2,
for x in l:print x,;l+=x*[l[-1]^3]

무기한으로 인쇄합니다. l반복되는 목록 을 작성합니다. 의 각 항목 x에 대해 또는의 복사본을 l추가 합니다 (현재 마지막 요소와 반대).x12

주요 어려움은 초기 자기 참조 단편을 다루는 것입니다 [1,2,2]. 이 코드는 이니셜을 인쇄하고 1,2거기서 시작합니다. 추가 인쇄 비용은 12 바이트입니다. 그것없이 :

39 바이트 , 처음 두 항목 누락

l=[2]
for x in l:print x;l+=x*[l[-1]^3]

다른 접근법은 처음 두 항목을 특별히 초기화하는 것입니다. 우리는 초기화 l로 [0,0,2]처음 두 항목이 추가 발생하지 않도록,하지만 print x or n그들로 인쇄 만든다 n.

51 바이트

l=[0,0,2]
n=1
for x in l:print x or n;l+=x*[n];n^=3

또 다른 수정 방법은를 초기화 l=[1]하고에서 수동으로 교대를 추적 n하고 인쇄를 수정하는 것입니다.

51 바이트

n,=l=[1]
for x in l:print(l==[1,1])+x;l+=x*[n];n^=3

이 없으면 (l==[1,1])+인쇄 순서 대신를 시작 1,1,2하는 것 외에 모든 것이 작동합니다 1,2,2. 우리가이 두 번째 단계에 있다는 것을 인식하는 더 좋은 방법이 있어야합니다.

그리고 또 다른 이상한 수정, 어떻게 든 동일한 바이트 수 :

51 바이트

l=[1];q=2
for x in l:print x;l+=x*[l[-1]^3]*q;q=q<2

Wumpus , 13 11 바이트

=[=)O?=!00.

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

구분 기호없이 시퀀스를 무기한으로 인쇄합니다.

이것이 얼마나 짧은 지 정말 놀랍습니다.

설명

기본 아이디어는 시퀀스를 스택에 유지하고 맨 아래 요소를 반복해서 사용하여 다른 런을 생성 한 다음 인쇄하는 것입니다. 우리는 효과적으로 스택을 대기열로 남용하고 있습니다. 0and 1대신에 ( 1및 출력에만 증가) 작업하여 몇 바이트를 절약 할 수 있습니다. 2이 방법으로 스택을 명시 적으로 초기화 할 필요가 없으며 1논리적 부정을 사용하여 두 값 사이를 전환 할 수 있습니다.

     The entire program is run in a loop.
     At the beginning of loop iteration i, a(i)-1 will be at the bottom of the
     stack and the first element of the ith run of values will be on top.
     The caveat is that on the first iteration, the stack is empty, but
     popping from an empty stack produces an implicit zero.
=    Duplicate the top of the stack. Since this is defined as "pop x, push
     x, push x" this will result in 2 zeros when the stack is empty.
     After this we've got two copies of the ith run's value on top of the stack.
[    Pull up a(i)-1 from the bottom of the stack.
=)O  Duplicate, increment to a(i) and print it.
?=   If a(i)-1 is 1 (as opposed to 0), make another copy of the top of the
     stack. We've now got a(i)+1 copies, so one more than the run should be 
     long, but that's great because we can use the additional copy to get 
     the start of the next run.
!    Logical negation which swaps 0 and 1.
00.  Jump back to the beginning of the program.

Brachylog , 30 26 25 23 17 16 14 바이트

~a₀{1|2}ᵐḅlᵐ?l

처음 n 값을 출력 합니다. .입력에 "출력 변수" 를 사용하고 "입력 변수" 에 출력합니다 ?. 온라인으로 사용해보십시오!

설명

나는 이것이 선언적 인 결과에 매우 만족합니다. 프로그램은 기본적으로 출력 목록과 입력과의 관계에 대한 높은 수준의 설명입니다.

~a₀{1|2}ᵐḅlᵐ?l  Input is a number N.
                Output is a term that I'll call T.
~a₀             T is a prefix of a list L.
   {   }ᵐ       Each element of L
    1|2         is either 1 or 2.
         ḅ      If you cut L into blocks of equal elements
          lᵐ    and take the length of each block,
            ?   the result is T.
             l  The length of T is N.

{1|2}ᵐ사전 순서대로 목록을 시도 하기 때문에 출력은 1로 시작합니다.

껍질 , 10 바이트

Ṡωo↑⁰`Ṙ¢ḣ2

처음 n 값을 반환 합니다. 온라인으로 사용해보십시오!

설명

Ṡωo↑⁰`Ṙ¢ḣ2  Input is an integer N.
        ḣ2  The range [1,2]
       ¢    Cycle: C = [1,2,1,2,1,2...
 ω          Iterate until fixed point is found:
Ṡ    `Ṙ      Replicate the list C element-wise according to the current list,
  o↑⁰        then take first N elements.

입력 20의 경우 프로세스는 다음과 같습니다.

[1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2...
[1,2,2,1,2,2,1,2,2,1,2,2,1,2,2,1,2,2,1,2]
[1,2,2,1,1,2,1,1,2,2,1,2,2,1,1,2,1,1,2,2]
[1,2,2,1,1,2,1,2,2,1,2,1,1,2,2,1,2,2,1,1]
[1,2,2,1,1,2,1,2,2,1,2,2,1,1,2,1,1,2,1,2]
[1,2,2,1,1,2,1,2,2,1,2,2,1,1,2,1,1,2,2,1]
[1,2,2,1,1,2,1,2,2,1,2,2,1,1,2,1,1,2,2,1]

자바 (10), 155 (108) 105 (100) 97 바이트

v->{var s="122";for(int i=1;;s+=(1+i%2)*(s.charAt(i)>49?11:1))System.out.print(s.charAt(++i-2));}

구분 기호없이 무기한으로 인쇄합니다.

팁에서 간접 후 바이트 -3 @Neil . @MartinEnder
덕분에 -5 바이트 . Java 8을 Java 10으로 변환하는 -3 바이트

설명:

온라인으로 사용해보십시오 (TIO에서 60 초 후에 시간 초과).

v->{              // Method with empty unused parameter and no return-type
  var s="122";    //  String, starting at "122"
  for(int i=1;;   //  Loop `i` from 1 upwards indefinitely
      s+=         //    After every iteration: Append the String with:
         (1+i%2)  //     1+`i`modulo-2
         *(s.charAt(i)>49?11:1))
                  //     either once or twice depending on the digit at index `i`
    System.out.print(s.charAt(++i-2));}
                  //   Print the character at index `i-2` of the String
                  //   After we've first increased `i` by 1 with `++i`

젤리 , 10 바이트

’߀+\<¹SḂ‘

n ^번째 항을 반환합니다 .

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

작동 원리

’߀+\<¹SḂ‘  Main link. Argument: n (positive integer)

’           Decrement; yield n-1.
 ߀         Recursively map the main link over [1, ..., n-1].
   +\       Take the cumulative sum.
            The k-th sum is the combined length of the first k runs.
     <¹     Compare each sum with n.
       S    Sum the Booleans.
            This counts the number of runs that occur before the n-th term.
            If there's an even number (including 0) of runs, the n-th term is 1.
            If there's an odd number of runs, the n-th term is 2.
        Ḃ   Extract the least significant bit of the count.
         ‘  Increment.

하스켈 , 33 바이트

r=r%1
~(x:t)%n=n:[n|x>1]++t%(3-n)

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

Ørjan Johansen은 접두사를 강제하기 위해 반박 할 수없는 패턴을 사용하여 7 바이트를 절약했습니다.

Gol> <> , 8 7 바이트

:{:PnKz

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

설명

이것은 내 Wumpus 답변 의 포트입니다 . Gol의이> <> 기본적으로 , 포트에 wumpus 사 응답 (특히, 스택의 맨 아래에 암시 제로는, 구현 "중복", "팝, 푸시, 푸시"와 스택 회전 명령)에 필요한 모든 기능을 가지고 언어 만 :

• 그것은 토 로이드 그리드를 가지고있어, 우리는 00.처음으로 되돌아 가기 위해 명시적인 것이 필요하지 않음을 의미 합니다.
• 그것은이 K대체 할 수있다 "팝 N, 그 다음 요소 N 시간을 중복"인 ?=또 다른 바이트를 저장.

따라서 Wumpus에서 Gol> <> 로의 매핑은 다음과 같습니다.

Wumpus   Gol><>
=        :
[        {
=        :
)        P
O        n
?=       K
!        z
00.

셰익스피어 프로그래밍 언어 , 594 583 572 바이트

-10 바이트의 Ed Wynn에게 감사합니다!

,.Ford,.Puck,.Act I:.Scene I:.[Enter Ford and Puck]Ford:You cat!Open heart!You big cat!Open heart!Puck:Remember you!Remember me!Scene V:.Ford:You is the sum ofI a cat!Puck:Recall!Open heart!Ford:Remember a pig!Is I nicer a cat?If notyou be the sum ofyou a big pig!Scene X:.Puck:Recall!Ford:Is I nicer zero?If soremember I!If solet usScene X!Puck:Is I nicer zero?You is the sum ofI a big cat!If soyou is I!Remember zero!Remember I!Remember you!You be the difference betweena big cat you!Scene L:.Ford:Recall!Is you worse I?If so,let usScene V!Puck:Remember I!Let usScene L!

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

이것은 Ed Wynn의 ungolfed 솔루션의 골프 버전으로 , 주석에 링크 된 828 바이트 솔루션 부터 시작 하여 약간 의 견해 를 가지고 있습니다.

설명:

,.Ford,.Puck,.Act I:.Scene I:.[Enter Ford and Puck]    Boilerplate, introducing the characters
Ford:You cat!Open heart!You big cat!Open heart!  Print 1,2 as the first two terms of the sequence

Puck:Remember you!Remember me!  Initialise stack as 0, 2
                                Ford's value is currently 0, representing the value to be pushed to the stack

Scene V:.     Start infinite loop
  Ford:You is the sum ofI a cat!         
  Puck:Recall!Open heart!                 Pop the next value in the stack and print it
  Ford:Remember a pig!                    Push -1 as the end of the stack
  Is I nicer a cat?                       If Ford's value is 2
  If notyou be the sum ofyou a big pig! Subtract 2 from Puck's value to represent making 2 only one copy

        #Reverse the stack until it reaches the terminator value 0 or -1
  Scene X:.Puck:Recall!Ford:Is I nicer zero?If soremember I!If solet usScene X!

  Puck:Is I nicer zero?                          Check if the Puck's value is bigger than 0 (only making one copy)
  You is the sum of Ia big cat!                 Set Ford's value to Puck+2 to counter the change
  If soyou is I!                                But undo it if making one copies
  Remember zero!                                 Push 0 as the stack terminator
  Remember I!                                    Push Ford's value, which is 0 or -1 if this is a single copy, or 1 or 2 for a double copy
  Remember you!                                  Push one copy of Puck's value
  You be the difference betweena big cat you!   Map Ford's value from 1,2 to 1,0

  Scene L:.   #Reverse the stack until it reaches the terminator 0 
     Ford:Recall!Is you worse I?If solet us Scene V!
     Puck:Remember I!Let usScene L!

> <> , 13 12 바이트

0:{:1+n?:0=!

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

Martin Ender의 Wumpus 답변 포트 . 불행히도 ><>증가 또는 반전 명령이 없거나 스택 맨 아래에 암시 적 0이 없으므로 결국 조금 더 길어집니다.

자바 스크립트, 67 66 60 58 52 51 50 바이트

글쎄, 그것은 내 뇌 가려움증을 그 이상으로 만들었습니다! n0 인덱싱 된 용어를 다시 시작합니다 .

s=`122`
x=1
f=n=>s[n]||f(n,s+=s[++x%2]*(s[x]+0-9))

가려운 뇌를 긁는 tsh 덕분에 5 + 1 바이트가 절약되었습니다 !

그것을 테스트

아래 스 니펫은 처음 50 개의 용어를 출력합니다.

s=`122`
x=1
f=n=>s[n]||f(n,s+=s[++x%2]*(s[x]+0-9))
o.innerText=[...Array(50).keys()].map(f).join`, `

<pre id=o></pre>

설명

함수 범위 밖에서 일부 변수를 선언하고 함수 내에서 변수를 수정하고 함수의 후속 호출에서 재사용 할 수있는 드문 경우 중 하나입니다.

s=`122`       :Initialise variable s as the string "122"
x=1           :Initialise variable x as integer 1
f=n=>         :Named function f taking input as an argument through parameter n
 s[n]         :If s has a character at index n, return it and exit
 ||           :Or
 f(n          :Call f with n again
  ,s+=        :At the same time, append to s
  s[++x%2]    :  Increment x, modulo by 2 and get the character at that index in s
  *           :  Multiplied by (the above gets cast to an integer)
  (s[x]+0-9)  :  Append a 0 to the xth character of s and subtract 9
 )            :  (The above gives "1"+0-9="10"-9=1 or "2"+0-9="20"-9=11)

파이썬 (2와 3), 65 60 바이트

f=lambda n:sum([f(i)*[i%2+1]for i in range(2,n)],[1,2,2])[n]

0 인덱스 의 n 번째 항목을 반환합니다 .

대안 (65 바이트) :

f=lambda n:n>1and sum([f(i)*[i%2+1]for i in range(n)],[])[n]or-~n

하스켈 , 48 바이트

nimi 덕분에 -1 바이트. Lynn 덕분에 -2 바이트

c=1:2:c
l=1:2:drop 2(id=<<zipWith replicate l c)

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

모든 요소의 위치 모드를 2 + 1 회 반복하십시오.

brainfuck , 61 바이트

+.+.[.[>]>+++>+++<<<[->+>->-<<<]<[[->+<]<]>>--[[>]<,<[<]>+]>]

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

숫자를 문자 코드로 무기한 인쇄합니다. 명확성을 위해 숫자로 인쇄 하는 버전 이 있습니다 (처음 확인하기 쉬운 첫 두 요소 제외).

작동 방식 :

+.+. Prints the first two elements. These are the self-referential elements
     This also intitialises the tape with the third element, 2
[ Start infinite loop
   . Print current lowest element
   [>]>+++>+++ Move to end of tape and create two 3s
   <<<[->+>->-<<<] Subtract the last element of the tape from these 3s
   <[[->+<]<]>> Move to the beginning of the tape
   --  Subtract two from the first element
       This leaves 2 as 0 and 1 as -1
   [ If the number was 1
     [>]<,  Delete the excess element from the end of the tape
     <[<]>+ Remove the -1
   ]
   > Move to the next element of the list
]

05AB1E , 12 9 바이트

Grimy 덕분에 3 바이트 절약

처음 n 개의 항목을 인쇄합니다 .

Δ2LÞsÅΓI∍

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

설명

Δ           # repeat until ToS doesn't change
 2LÞ        # push [1,2,1,2 ...]               
    sÅΓ     # run-length encode with previous value (initially input)
       I∍   # extend/shorten to the length specified by input

05AB1E , 15 바이트

ƵLS[DNÌ©èF®É>¸«

온라인으로 사용해보십시오! 또는 반복 제한

설명

ƵLS               # push our initial list [1,2,2]
   [              # for every N in [0 ...
    D             # duplicate current list of numbers
     NÌ©è         # get the N+2'th element from the list
         F        # that many times do
          ®É>     # push ((N+2)%2==1)+1
             ¸«   # append to current list

파이썬 3 , 55 54 바이트

n=h=1;l=[]
while n:print(h);n^=3;h,*l=l+[n]*(l+[2])[0]

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

J , 12 바이트

n을 취하고 첫 번째 n 항을 생성하는 단일 인수 함수 입니다. 온라인으로 사용해보십시오!

$(1+2|I.)^:]

예전 질문에 대한 예전 대답 을 쏟아 부었습니다 .

I.는 숫자 배열을 가져와 인덱스 목록을 추출하는 동사이므로 배열 의 k 번째 항목이 n 이면 인덱스 k 가 n 번 나타납니다 . 이를 사용하여 초기 씨앗에서 Kolakowski 시퀀스를 부트 스트랩합니다. 각 단계는 다음과 같이 진행됩니다.

1 2   2   1 1 2   1 2   2   1   (some prefix)
0 1 1 2 2 3 4 5 5 6 7 7 8 8 9   (use I.)
0 1 1 0 0 1 0 1 1 0 1 1 0 0 1   (mod 2)
1 2 2 1 1 2 1 2 2 1 2 2 1 1 2   (add 1) 

이 작업 1+2|I.을 10 번 이상 반복 해서 수행하면 다음과 같이 보입니다.

10
1 1 1 1 1 1 1 1 1 1
1 2 1 2 1 2 1 2 1 2
1 2 2 1 2 2 1 2 2 1 2 2 1 2 2
1 2 2 1 1 2 1 1 2 2 1 2 2 1 1 ...
1 2 2 1 1 2 1 2 2 1 2 1 1 2 2 ...
1 2 2 1 1 2 1 2 2 1 2 2 1 1 2 ...

우리가 매번 점점 더 정확한 용어를 얻는 방법에 주목하고, 잠시 후 처음 n 개의 용어가 수정됩니다. 해결하는 데 필요한 반복 횟수는 정확하게 설명하기 어렵지만 n 에서는 대략 로그인 것처럼 보이 므로 n 번만 실행하면 ^:]괜찮 습니다 ( ). (자세한 정보는 generation lengths , partial sums에 대한 다른 OEIS 시퀀스를 확인하십시오 .)

일단 완료 하면를 사용하여 첫 번째 n 항을 취하기 만하면됩니다 $. $v동사 의 구성 v은 후크의 예이며 n인수로 제공하면 execute가 실행 n $ (v n)됩니다.

다음은 시간과 공간을 훨씬 덜 낭비하는 이전 13 바이트 버전입니다 ($1+2|I.)^:_~.. 모든 단계에서 입력을 자르므로 선형 적으로 여러 번 처리하는 대신 필요한만큼 정확하게 실행할 수 있습니다.

Fueue , 30 바이트

Fueue는 실행중인 프로그램과 해당 데이터가 모두 같은 큐에 있고 큐에서 실행이주기에 따라 진행되는 대기열 기반 esolang이며, 잘못된 시간에 실행되지 않도록 프로그래밍하려면 많은 동기화가 필요합니다.

1)2:[[2:])~)~:~[[1]:~))~:~~]~]

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

위의 끝없는 자릿수 목록을 제어 코드로 인쇄합니다. 34 바이트의 경우 실제 숫자를 인쇄 할 수 있습니다.

49)50:[[50:])~)~:~[[49]:~))~:~~]~]

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

나머지 설명은 후자 버전을 사용합니다.

Fueue 요소 요약

Fueue 대기열에는 다음과 같은 종류의 요소가 포함될 수 있습니다.

• 실행될 때 유니 코드 코드 포인트를 인쇄하는 정수,
• 다행히도 비활성 대괄호 구분 된 서브 블록은 않는 (다만, 큐의 끝으로 이동) )함수 deblocks 그들을 및
• 단일 문자 함수-올바른 유형의 인수가 뒤에 오는 경우 실행되고 그렇지 않으면 비활성 상태로 유지됩니다.
  • 이 프로그램에서 사용되는 유일한 기능은 ~(다음 두 요소 교환), :(다음 요소 복제) 및 )(다음 블록 차단)입니다.

높은 수준의 개요

프로그램의 메인 루프 동안 큐는 다음으로 구성됩니다.

• 반복 될 자릿수를 나타내는 블록 체인;
  • 숫자 1 또는 2는 각각 블록 [49]과 [50:]로 표시됩니다.
• 디지트 블록을 가로 지르고 1과 2를 번갈아 가며 자체적으로 복제하는 자체 복제 메인 루프 섹션.
  • 디 블록 된 디지트 블록은 자체 디지트 d를 인쇄 한 후 다음 블록의 d 사본을 작성하여 설명하는 실행에 대한 디지트를 작성합니다.

처음 10 개 명령의 저수준 추적

Cmds   Explanation              Queue
49     Print '1'.               )50:[[50:])~)~:~[[49]:~))~:~~]~]
)      Inactive, move to end.   50:[[50:])~)~:~[[49]:~))~:~~]~])
50     Print '2'.               :[[50:])~)~:~[[49]:~))~:~~]~])
:[...] Duplicate block.         )[[50:])~)~:~[[49]:~))~:~~]~][[50:])~)~:~[[49]:~))~:~~]~]
)[...] Deblock (rmv. brackets). [[50:])~)~:~[[49]:~))~:~~]~][50:])~)~:~[[49]:~))~:~~]~
[...]  Inactive.                [50:])~)~:~[[49]:~))~:~~]~[[50:])~)~:~[[49]:~))~:~~]~]
[50:]  Inactive.                )~)~:~[[49]:~))~:~~]~[[50:])~)~:~[[49]:~))~:~~]~][50:]
)      Inactive.                ~)~:~[[49]:~))~:~~]~[[50:])~)~:~[[49]:~))~:~~]~][50:])
~)~    Swap ) and ~.            :~[[49]:~))~:~~]~[[50:])~)~:~[[49]:~))~:~~]~][50:])~)
:~     Duplicate ~.             [[49]:~))~:~~]~[[50:])~)~:~[[49]:~))~:~~]~][50:])~)~~

전체 메인 루프 반복 연습

명령을 분리하기 위해 선택적 공백이 삽입되었습니다.

49 ) 50 :[[50:])~)~:~[[49]:~))~:~~]~]

사이클 1 : 49인쇄합니다 1. )비활성 상태이며 메인 루프 블록과 함께 대기합니다. 50인쇄합니다 2. :주 루프 블록을 복제합니다 (자체 복제를 위해 사본이 필요함).

) [[50:])~)~:~[[49]:~))~:~~]~] [[50:])~)~:~[[49]:~))~:~~]~]

사이클 2 : )첫 번째 메인 루프 블록을 차단 해제하여 다음 사이클 실행을 시작합니다.

[50:] ) ~)~ :~ [[49]:~))~:~~] ~[[50:])~)~:~[[49]:~))~:~~]~]

사이클 3 : [50:]체인에서 생성 된 첫 번째 숫자 ( 2아직 차단 해제되지 않음)를 나타냅니다 . )나머지 메인 루프가 통과 한 후에는 다음과 같이 됩니다. ~)~:~의 골프 (스왑 및 사본 사용)의 한주기 지연입니다 ~)~~. [[49]:~))~:~~]비활성 상태입니다. ~다음의 메인 루프 블록을 [50:]숫자 블록을 지나서 바꿉니다.

) ~)~ ~[[49]:~))~:~~][50:] [[50:])~)~:~[[49]:~))~:~~]~]

사이클 4 : )여전히 대기, ~)~생성 ~), 숫자 블록을 지나 ~교환 [[49]:~))~:~~]합니다 [50:].

) ~)[50:] [[49]:~))~:~~] [[50:])~)~:~[[49]:~))~:~~]~]

사이클 5 : 숫자 블록을 지나 ~교환 )합니다 [50:].

)[50:] )[[49]:~))~:~~] [[50:])~)~:~[[49]:~))~:~~]~]

사이클 6 : 첫 번째는 )이제 [50:]디지트 블록을 디 블로킹하고, 다음 )은 서브 프로그램을 디 블로킹합니다 [[49]:~))~:~~].

50 :[49] :~ ) ) ~:~ ~[[50:])~)~:~[[49]:~))~:~~]~]

사이클 7 : 50인쇄는 2, :방금 생산 된 복제 [49]두 가지의 실행 만들기, 숫자 블록을 1들. :~))~:~의 1주기 지연입니다 ~~))~:. ~나머지 메인 루프 블록을 첫 번째 블록을지나 교환합니다 [49].

[49] ~~) ) ~:[49] [[50:])~)~:~[[49]:~))~:~~]~]

사이클 8 : ~~))은 1 사이클 지연이다 )~). 현재 트래버스 된 과거를 ~스왑 :합니다 [49].

[49] ) ~)[49] :[[50:])~)~:~[[49]:~))~:~~]~]

사이클 9 : 과거 ~스왑 . 메인 루프 블록을 복제합니다.)[49]:

[49] )[49] )[[50:])~)~:~[[49]:~))~:~~]~] [[50:])~)~:~[[49]:~))~:~~]~]

사이클 10 : 첫 번째 )는 [49]방금 이동 한 디지트 블록을 디 블로킹하고 , 두 번째 )는 메인 루프를 다시 시작하여 다음 루프를 트래버스합니다 (위의 시작 부분에 표시됨).

x86, 41 37 35 33 28 바이트

이것은 첫 번째 "사소하지 않은"x86 답변이므로 다른 x86 명령어로 많은 시간을 허비했습니다. 실제로 x86-64를 먼저 배웠고 프로그램을 32 비트로 변환하여 많은 바이트를 절약했습니다.

OEIS에서 사용한 알고리즘이 값을 배열로 푸시하여 x86 및 스택에 값을 저장할 수있게합니다 (MIPS에는 스택 명령이 없음).

현재 프로그램은 N값을 입력으로 받아서 n 번째 요소가 시퀀스의 n 번째 값을 나타내는 배열 ecx의 주소를 리턴합니다 ebp. 스택에서 반환하고 추가 값을 계산하는 것이 유효하다고 가정합니다 (어쨌든 배열 이외의 것을 가비지로 간주합니다).

변경 로그

• 반복 x = 2 - n%2할 xor때마다 계산 하여 -4 바이트

• while 루프 대신 do-while을 사용하여 -2 바이트

• 초기 값 1, 2, 2를 사용하여 -2 바이트 사용 eax

• n명시 적으로 저장하지 않고 루프 N시간을 실행 하여 -5 바이트

.section .text
.globl main
main:
        mov     $10, %ecx           # N = 10 

start:
        mov     %esp, %ebp          # Save sp
        push    $1
        push    $2                  # x = 2
        pop     %eax       
        push    %eax                # push 2
        push    %eax                # push 2
        mov     %esp, %esi          # sn = stack+3 addr

loop:                               
        xor     $3, %al             # flip x between 1 <-> 2 
        push    %eax                # push x      
                                    # maybe use jump by parity?
        cmp     $2, (%esi)          # if *sn == 2 
        jne     loop1
        push    %eax                # push x

loop1: 
        sub     $4, %esi            # sn += 1
        loop    loop                # --N, do while (N)
end:
        mov     %ebp, %esp          # Restore sp
        ret

오보 펌프 :

00000005 <start>:
   5:   89 e5                   mov    %esp,%ebp
   7:   6a 01                   push   $0x1
   9:   6a 02                   push   $0x2
   b:   58                      pop    %eax
   c:   50                      push   %eax
   d:   50                      push   %eax
   e:   89 e6                   mov    %esp,%esi

00000010 <loop>:
  10:   34 03                   xor    $0x3,%al
  12:   50                      push   %eax
  13:   83 3e 02                cmpl   $0x2,(%esi)
  16:   75 01                   jne    19 <loop1>
  18:   50                      push   %eax

00000019 <loop1>:
  19:   83 ee 04                sub    $0x4,%esi
  1c:   e2 f2                   loop   10 <loop>

0000001e <end>:
  1e:   89 ec                   mov    %ebp,%esp
  20:   c3                      ret 

C (gcc) , 72 71 65 64 62 바이트

@ceilingcat 덕분에 -9 바이트

x,y;f(z){for(x=y=-1;putchar(49-~x%2);y=-~y|z&x/2)x^=z=y&~-~y;}

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

시퀀스 값을 무한정 생성합니다 (챌린지에서 옵션 3).

펄 5 , 36 바이트

클래식 TPR (0,3) 솔루션을 여전히 간단하게 수정했습니다.

시리즈를에서 0로 출력n

#!/usr/bin/perl
use 5.10.0;
say$_=($n+=!--$_[$n])%2+1for@_=0..<>

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

자바 ES6 - 71 70 68 바이트

(_="122")=>{for(x=1;;_+=(1+x%2)*(_[x]>1?11:1))console.log(_[++x-2])}

Neil 덕분에 1 비트 절약

실수를 수정하고 1 비트를 절약 하기 위해 Shaggy 에 탱크 .

f = (_="122") => {
  for(x=1;x<20;_+=(1+x%2)*(_[x]>1?11:1))
    document.getElementById('content').innerHTML += '   ' + _[++x-2]
}
f()

<div id="content"></div>

사과 씨 , 89 바이트

(def K(lambda()(concat(q(1 2))(drop 2(flatten(zip-with repeat-val(cycle(q(1 2)))(K)))))))

K인수를 사용하지 않고 Kolakoski 시퀀스를 무한 목록으로 반환 하는 함수 를 정의합니다 . 온라인으로 사용해보십시오!

이 접근법은 전적으로 인간의 Haskell 답변 에서 영감을 얻었습니다 . 내 원래의 접근 방식은 더 이상이었다 그리고 아마도 O (^ N 2)이었다. : ^ P

언 골프

(def kolakoski
 (lambda ()
  (concat (list 1 2)
   (drop 2
    (flatten
     (zip-with repeat-val
      (cycle (list 1 2))
      (kolakoski)))))))

반환 목록은로 시작합니다 (1 2). 그 후, 나머지를 생성하려면 (내부에서 읽음) :

• (kolakoski)Kolakoski 시퀀스 목록을 얻기 위해 재귀 적으로 호출 하십시오 (지연 한 평가로 인해 목록이 아직 완전히 생성되지 않은 것은 중요하지 않습니다)
• (cycle (list 1 2)) 무한 목록을 만듭니다 (1 2 1 2 1 2 ...)
• 함수를 사용하여 두 개의 무한 목록을 압축하십시오 repeat-val. 이렇게하면 Kolakoski 목록의 관련 값에 따라 목록 에서 1또는 목록 2에서 cycle한두 번 반복됩니다. 결과:((1) (2 2) (1 1) ...)
• flatten 그 목록에 (1 2 2 1 1 ...)
• 에서 처음 두 항을 이미 얻었 (concat (list 1 2)으므로 drop중복을 피하기 위해 생성 된 목록에서 처음 두 항을 얻었습니다 .

Stax , 12 바이트

╦╥2Bïß▄n»-[╒

실행 및 디버깅

이것은 동일한 프로그램의 ASCII 표현입니다.

G@}2R;D{|;^]*m$

x가 입력 인 순서 x를 확장합니다. 그런 다음 x ^번째 요소 (0 인덱스)를 출력합니다 .

G }             G jumps to trailing } and returns when done
 @              get xth element in array
   2R           [1, 2]
     ;D         repeat the rest x times
       {     m  map array using block
        |;^]    produces [1] and [2] alternately
            *   repeat array specified number of times
              $ flatten array

다음 은 무한 스트림으로 출력을 생성하는 보너스 12 바이트 솔루션입니다. 실행을 눌러 시작하십시오.

R, 63 바이트 또는 61 바이트

구현 1 : 시퀀스 의 n ^번째 항을 인쇄합니다 .

x=scan()
a=c(1,2,2)
for(n in 3:x)a=c(a,rep(2-n%%2,a[n]))
a[x]

구현 2 : 시퀀스 의 처음 n 항을 인쇄합니다 .

x=scan()
a=c(1,2,2)
for(n in 3:x)a=c(a,rep(2-n%%2,a[n]))
a[1:x]

(차이는 마지막 줄에만 있습니다.)

예, 그렇습니다. 내 솔루션이 비효율적이며 실제로 필요한 것보다 더 많은 항을 계산한다고 불평 할 수 있지만 여전히 ...

업데이트 : 9 바이트 를 줄인 @Giuseppe 에게 감사드립니다 .

셰익스피어 프로그래밍 언어, 575 바이트 (그러나 결함) 또는 653 또는 623 바이트

,.Puck,.Ford,.Act I:.Scene X:.[Enter Puck and Ford]Ford:You big cat!Scene L:.Ford:Is I nicer zero?If so,let us Scene V.Is you nicer a big cat?If so,you is the sum of you a big lie.If so,open heart!Open heart!Scene M:.Puck:Remember you!Is I nicer a cat?You big cat.If so,you cat.Ford:Recall!Is you nicer zero?If not,let us Scene X.Is you nicer a big cat?If not,let us Scene M.You is the sum of you a big lie.Scene V:.Ford:Remember you!Is you worse a big big cat?If not, you big cat.Is you as big as a big cat?If not,you zero.You is the sum of I you.Puck:Recall!Let us Scene L.

첫째,이 TIO 버전합니다 (SPL 웹 사이트를 구현)에서 실행되지 않습니다 -하지만 실행 않습니다 뜨겁게 경쟁 SPL의 범주에서, 이것은 결함이 점을 제외하고 조 왕의 현재 항목 (583 바이트), 이길 것이다 펄 version 이므로 심각한 결함이 아닙니다. 둘째, 처음 두 자리를 인쇄하지 않습니다. Jo King의 솔루션에서 해당 결함을 허용하면 결함이있는 솔루션은 553 바이트가되어 결함이있는 솔루션을 꺾습니다.

내 솔루션은 다음 두 가지 이유로 TIO에서 실패합니다. 팝이 발생할 때 빈 스택을 0으로 반환하려고 시도합니다. 그리고 아무도 무대를 떠난 적이 없더라도 "[Enter Ford and Puck]"과 함께 첫 장면으로갑니다. Perl 버전의 경고 일뿐입니다. 나는이 오류를 수정하는 경우 와 처음 두 자릿수에 넣어, 나는 653 바이트에 도달 :

 ,.Puck,.Ford,.Act I:.Scene I:.[Enter Puck and Ford]Ford:You cat!Open heart!You big cat!Open heart!You zero!Scene X:.Ford:Remember you!You big cat!Scene L:.Ford:Is I nicer zero?If so,let us Scene V.Is you nicer a big cat?If so,you is the sum of you a big lie.If so,open heart!Open heart!Scene M:.Puck:Remember you!Is I nicer a cat?You big cat.If so,you cat.Ford:Recall!Is you nicer zero?If not,let us Scene X.Is you nicer a big cat?If not,let us Scene M.You is the sum of you a big lie.Scene V:.Ford:Remember you!Is you worse a big big cat?If not, you big cat.Is you as big as a big cat?If not,you zero.You is the sum of I you.Puck:Recall!Let us Scene L.

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

623 바이트를 사용하여 Perl 구현에서 전체 시퀀스를 생성 할 수 있습니다.

,.Puck,.Ford,.Act I:.Scene I:.[Enter Puck and Ford]Ford:You cat!Open heart!You big cat!Open heart!Scene L:.Ford:Is I nicer zero?If so,let us Scene V.Is you nicer a big cat?If so,you is the sum of you a big lie.If so,open heart!Open heart!Scene M:.Puck:Remember you!Is I nicer a cat?You big cat.If so,you cat.Ford:Recall!Is you worse a cat?If so,you big cat!If so,let us Scene L.Is you nicer a big cat?If not,let us Scene M.You is the sum of you a big lie.Scene V:.Ford:Remember you!Is you worse a big big cat?If not, you big cat.Is you as big as a big cat?If not,you zero.You is the sum of I you.Puck:Recall!Let us Scene L.

그러나이 솔루션은 다른 많은 솔루션에 비해 빠르며 전체 목록을 저장하는 대신 로그 양의 메모리를 사용합니다. (이것은 멀리 떨어져있는 vazt의 C 솔루션과 유사합니다.) 이것은 골프와 별 차이가 없지만, 너무 기뻐합니다. Perl에서 약 1 분 안에 백만 자리를 생성 할 수 있습니다 (예 : sed로 파이프하고 자리 수를 얻기 위해 wc를 사용하는 경우). 다른 솔루션은 수천 자리를 줄 수 있습니다.

설명

퍽의 스택 (아래에서 위로), 퍽의 값, 포드의 값, 포드의 스택 (상단에서 하단) 순서로 변수 시퀀스를 저장합니다. 끝에서 0 값을 제외하고 (왼쪽에 0이 빈 스택을 튀어 나올 수 있음) 각 값은 해당 세대에 다음에 생성되는 숫자이며, 다음 세대에 해당 부모의 다른 자식이 필요하면 2가 추가됩니다. 시퀀스에 N이 아닌 0 값이 있으면 깊이 우선 트리 탐색의 일종으로 N 세대까지의 모든 하위 항목을 생성합니다. N 세대의 값만 인쇄합니다. N 세대가 완전히 생성되면 저장된 값은 실제로 2 세대부터 (N + 1)까지의 시작 값이므로 왼쪽에 2를 추가하고 다시 시작합니다. 이번에는 (N + 1을 생성합니다. ) 세대.

따라서 개요 : 장면 X : 여기에 도달하면 새로운 횡단이 시작됩니다. 퍽 == 0. 선택적으로 0을 Puck의 스택으로 푸시하고 Puck = 2로 설정합니다. 장면 L : Ford == 0이면 인쇄 생성에 도달했습니다. 그렇지 않은 경우 V로 이동하십시오. 인쇄시 Puck의 값에 2가 추가 된 경우 2를 제거하고 두 번 인쇄하십시오. 그렇지 않은 경우 한 번 인쇄하십시오. Scene M : Puck 값을 반복적으로 토글하고 시퀀스를 다시 진행하는 루프입니다. 우리는 끝 (Puck == 0)에 도달 할 때까지 반복하고 (이 경우 X로 이동), 또 다른 자식 (Puck> 2)이 필요한 값에 도달 할 때까지 반복합니다.이 경우 여분의 2를 빼고 V에서 앞으로갑니다. V : 여기로 넘어갑니다. Puck이 2 또는 4 인 경우 다음 세대는 현재 부모의 두 자녀를 포함하므로 Ford + = 2입니다. 시퀀스를 단계별로 진행합니다. 종료를 확인하려면 L로 이동하십시오.

axo , 13 바이트

[:|[1+{#;1;-_

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

설명

이것은 Wumpus 답변 의 대체 솔루션 포트로 시작되었습니다 .

2%)[=]&=[O00.

결과적으로 18 바이트가되었습니다. 나는 그것을 당신이 위에서 본 13 바이트로 골퍼하여 axo가 작동하는 방식에 더 맞추기 시작했다. 그런 다음이 13 바이트 버전은 Wumpus에서 11 바이트로 향상되도록 영감을 주었으므로 이제는 실제로 해당 버전에 더 가깝습니다.

Wumpus의 반복 i 에서와 같이 스택의 맨 아래에는 a (i) -1이 있고 맨 위는 i 번째 실행 의 첫 번째 요소를 보유 하지만 인쇄를 제외하고는 0 과 1로 작업 하고 있습니다.

[:    Store a copy of the top of the stack in register A.
|     Pull up a(i)-1 from the bottom of the stack.
[1+{  Print a(i).
#;    If a(i)-1 is 1, push the value in register A.
1;-   Push another copy of that value and subtract it from 1 to swap
      0 and 1 for the next run.
_     Jump back to the beginning of the program.

루비 , 45 39 바이트

a=*i=0;loop{a+=[k=1+i%2]*p(a[i+=1]||k)}

무기한으로 인쇄

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

오버로드 된 인쇄 기능을 사용하여 구분 기호와 인쇄 된 요소 수를 선택할 수 있습니다.