Đây là một bản đăng lại của một thách thức cũ , để điều chỉnh các yêu cầu I / O theo các tiêu chuẩn gần đây của chúng tôi. Điều này được thực hiện trong nỗ lực cho phép nhiều ngôn ngữ tham gia vào một thách thức về trình tự phổ biến này. Xem bài đăng meta này để thảo luận về repost.

Trình tự Kolakoski là một chuỗi tự giới thiệu thú vị, có vinh dự là trình tự OEIS A000002 (và nó dễ hiểu và dễ thực hiện hơn A000001). Chuỗi bắt đầu bằng 1 , chỉ gồm 1 s và 2 s và phần tử chuỗi a (n) mô tả độ dài của lần chạy thứ n là 1 s hoặc 2 s trong chuỗi. Điều này xác định duy nhất chuỗi sẽ là (với một hình ảnh trực quan của các lần chạy bên dưới):

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

Nhiệm vụ của bạn là, tất nhiên, để thực hiện trình tự này. Bạn có thể chọn một trong ba định dạng để làm như vậy:

1. Lấy một đầu vào n và xuất ra số hạng thứ n của chuỗi, trong đó n bắt đầu từ 0 hoặc 1 .
2. Lấy một đầu vào n và xuất các thuật ngữ lên đến và bao gồm số hạng thứ n của chuỗi, trong đó n bắt đầu từ 0 hoặc 1 (nghĩa là in n đầu tiên hoặc n + 1 đầu tiên ).
3. Giá trị đầu ra từ chuỗi vô thời hạn.

Trong trường hợp thứ hai và thứ ba, bạn có thể chọn bất kỳ định dạng danh sách hợp lý, rõ ràng. Thật tốt nếu không có dấu phân cách giữa các phần tử, vì chúng luôn luôn là một chữ số duy nhất theo định nghĩa.

Trong trường hợp thứ ba, nếu trình của bạn là một hàm, bạn cũng có thể trả về một danh sách vô hạn hoặc một trình tạo bằng các ngôn ngữ hỗ trợ chúng.

Bạn có thể viết chương trình hoặc chức năng và sử dụng bất kỳ phương pháp tiêu chuẩn nào để nhận đầu vào và cung cấp đầu ra. Lưu ý rằng các sơ hở này bị cấm theo mặc định.

Đây là môn đánh gôn , vì vậy câu trả lời hợp lệ ngắn nhất - được đo bằng byte - thắng.

Thạch , 7 byte

2Rṁxṁµ¡

Đây là một chương trình đầy đủ in các điều khoản n đầu tiên .

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

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

Chạy ví dụ

Đặt n = 5 .

Lệnh gọi đầu tiên của chuỗi lặp lại 1, 2 theo chu kỳ để đạt độ dài 5 , sau đó mỗi phần tử 5 lần và cuối cùng cắt kết quả thành chiều dài 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

Điều này mang lại một danh sách dài 5 . Phần tử đầu tiên là phần tử đầu tiên của chuỗi Kolakoski.

Lệnh thứ hai của chuỗi lặp lại 1, 2 theo chu kỳ để đạt độ dài 5 , sau đó lặp lại phần tử ^thứ k ^lần j , trong đó j là phần tử ^thứ k của danh sách trước và cuối cùng cắt kết quả thành chiều dài 5 .

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

   1 2 1 2 1

Điều này mang lại một danh sách dài 5 . Hai yếu tố đầu tiên là hai yếu tố đầu tiên của chuỗi Kolakoski.

Quá trình tiếp tục cho ba lần lặp lại.

   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

Đây là năm yếu tố đầu tiên của chuỗi Kolakoski.

Python 2 , 51 byte

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

In vô thời hạn. Xây dựng danh sách lkhi nó được lặp đi lặp lại. Đối với mỗi mục xcủa l, gắn thêm xbản sao 1hoặc 2, nào là ngược lại yếu tố cuối cùng hiện tại.

Khó khăn chính là đối phó với các đoạn tự tham chiếu ban đầu [1,2,2]. Mã này chỉ in ban đầu 1,2và tiến hành từ đó. Việc in thêm có giá 12 byte. Ngoài điều đó ra:

39 byte , thiếu hai mục đầu tiên:

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

Một cách tiếp cận khác là đặc biệt khởi tạo hai mục đầu tiên. Chúng tôi khởi tạo lnhư [0,0,2]vì vậy mà hai mục đầu tiên không gây ra phụ thêm, nhưng print x or nchúng làm cho được in như n.

51 byte

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

Một cách khắc phục khác là khởi tạo l=[1], theo dõi xen kẽ thủ công nvà sửa lỗi in:

51 byte

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

Không có (l==[1,1])+, mọi thứ hoạt động ngoại trừ các chuỗi in bắt đầu 1,1,2thay vì 1,2,2. Phải có một cách tốt hơn để nhận ra chúng ta ở bước thứ hai này.

Và một sửa chữa kỳ lạ khác, bằng cách nào đó cũng có cùng số byte:

51 byte

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

Wumpus , 13 11 byte

=[=)O?=!00.

Hãy thử trực tuyến!

In trình tự vô thời hạn mà không có dấu phân cách.

Tôi thực sự ngạc nhiên bởi sự ngắn ngủi này.

Giải trình

Ý tưởng cơ bản là giữ chuỗi trên ngăn xếp và liên tục sử dụng phần tử dưới cùng để tạo ra một lần chạy khác và sau đó in nó. Chúng tôi thực sự lạm dụng ngăn xếp như một hàng đợi ở đây. Chúng ta cũng có thể lưu một vài byte bằng cách làm việc 0và 1(chỉ tăng cho đầu ra) thay vì 1và 2, vì cách này chúng ta không cần phải khởi tạo rõ ràng ngăn xếp với a 1và chúng ta có thể sử dụng phủ định logic để chuyển đổi giữa hai giá trị.

     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 byte

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

Xuất ra các giá trị n đầu tiên . Sử dụng "biến đầu ra" .cho đầu vào và đầu ra cho "biến đầu vào" ?. Hãy thử trực tuyến!

Giải trình

Tôi khá hài lòng với cách khai báo này: chương trình về cơ bản là một mô tả cấp cao của danh sách đầu ra và mối quan hệ của nó với đầu vào.

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

Vì {1|2}ᵐthử các danh sách theo thứ tự từ điển, đầu ra sẽ bắt đầu bằng 1.

Husk , 10 byte

Ṡωo↑⁰`Ṙ¢ḣ2

Trả về n giá trị đầu tiên . Hãy thử trực tuyến!

Giải trình

Ṡω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.

Đối với đầu vào 20, quá trình diễn ra như sau:

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

Java 10, 155 108 105 100 97 byte

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));}

In vô thời hạn mà không có dấu phân cách.

-3 byte sau một mẹo gián tiếp từ @Neil .
-5 byte nhờ @MartinEnder .
-3 byte chuyển đổi Java 8 sang Java 10.

Giải trình:

Dùng thử trực tuyến (hết thời gian sau 60 giây trên TIO).

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`

Thạch , 10 byte

’߀+\<¹SḂ‘

Trả về số hạng ^thứ n .

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

’߀+\<¹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.

Haskell , 33 byte

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

Hãy thử trực tuyến!

Ørjan Johansen đã lưu 7 byte bằng cách sử dụng một mẫu không thể bác bỏ để buộc tiền tố.

Gol> <> , 8 7 byte

:{:PnKz

Hãy thử trực tuyến!

Giải trình

Đây là một cổng của câu trả lời Wumpus của tôi . Gol> <> về cơ bản là ngôn ngữ có tất cả các tính năng cần thiết để chuyển câu trả lời của Wumpus (cụ thể là các số 0 ẩn ở dưới cùng của ngăn xếp, "trùng lặp" được thực hiện "pop, đẩy, đẩy" và lệnh xoay ngăn xếp), nhưng :

• Nó có một lưới hình xuyến, có nghĩa là chúng ta không cần rõ ràng 00.để quay trở lại từ đầu.
• Nó có K"pop N, sau đó nhân đôi phần tử N tiếp theo", có thể thay thế ?=, lưu một byte khác.

Vì vậy, ánh xạ từ Wumpus đến Gol> <> trở thành:

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

Ngôn ngữ lập trình Shakespeare , 594 583 572 byte

Cảm ơn Ed Wynn cho -10 byte!

,.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!

Hãy thử trực tuyến!

Đây là một phiên bản chơi golf của giải pháp vô căn cứ của Ed Wynn , bắt đầu từ giải pháp 828 byte mà anh ta liên kết trong các bình luận và đi một chút hạt từ đó.

Giải trình:

,.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 byte

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

Hãy thử trực tuyến!

Một câu trả lời Wumpus của Martin Ender . Thật không may, ><>không có lệnh tăng hoặc lệnh đảo ngược và cũng không có 0 ẩn ở dưới cùng của ngăn xếp, vì vậy điều này kết thúc lâu hơn một chút.

JavaScript, 67 66 60 58 52 51 50 byte

Chà, điều đó làm cho não tôi ngứa nhiều hơn nó nên có! Lấy lại nthuật ngữ thứ 0, được lập chỉ mục 0.

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

5 + 1 byte được lưu nhờ tsh gãi não ngứa của tôi!

Kiểm tra nó

Đoạn mã dưới đây sẽ xuất ra 50 điều khoản đầu tiên.

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>

Giải trình

Đây là một trong những trường hợp hiếm hoi khi chúng ta có thể khai báo một số biến ngoài phạm vi hàm của chúng ta, sửa đổi chúng trong hàm và vẫn có thể sử dụng lại chúng trong các lệnh gọi tiếp theo của hàm.

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)

Python (2 và 3), 65 60 byte

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

Trả về mục thứ n , 0-index.

Thay thế (65 byte):

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

Haskell , 48 byte

-1 byte nhờ nimi. -2 byte nhờ Lynn.

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

Hãy thử trực tuyến!

Lặp lại mọi yếu tố vị trí của nó mod 2 + 1 lần.

Brainfuck , 61 byte

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

Hãy thử trực tuyến!

In số dưới dạng mã char vô thời hạn. Để rõ ràng, đây là một phiên bản in bằng số (ngoại trừ hai yếu tố đầu tiên, đủ dễ để xác minh).

Làm thế nào nó hoạt động:

+.+. 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 byte

Đã lưu 3 byte nhờ Grimy

In n mục đầu tiên .

Δ2LÞsÅΓI∍

Hãy thử trực tuyến!

Giải trình

Δ           # 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 byte

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

Hãy thử trực tuyến! hoặc với giới hạn lặp

Giải trình

Ƶ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

Python 3 , 55 54 byte

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

Hãy thử trực tuyến!

J , 12 byte

Hàm đối số đơn lấy n và tạo ra các số hạng n đầu tiên . Hãy thử trực tuyến!

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

Chỉ cần đưa ra câu trả lời cũ của tôi cho câu hỏi cũ.

I.là một động từ lấy một mảng các số và phun ra một danh sách các chỉ số, để nếu mục thứ k trong mảng là n , thì chỉ số k xuất hiện n lần. Chúng tôi sẽ sử dụng nó để khởi động chuỗi Kolakowski từ một hạt giống ban đầu. Mỗi bước sẽ tiến hành như sau:

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) 

Nếu chúng tôi thực hiện thao tác này ( 1+2|I.) nhiều lần bắt đầu từ 10, thì nó trông giống như thế này:

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

Lưu ý cách chúng tôi nhận được ngày càng nhiều thuật ngữ chính xác mỗi lần và sau một thời gian, các điều khoản n đầu tiên được sửa. Số lần lặp cần thiết để giải quyết rất khó để mô tả chính xác, nhưng có vẻ như là logarit trong n , vì vậy nếu chúng ta chỉ chạy nó n lần ( ^:]) thì sẽ ổn thôi. (Kiểm tra các chuỗi OEIS khác này để biết thêm thông tin: độ dài thế hệ , tổng một phần .)

Khi chúng tôi đã hoàn thành việc đó, tất cả những gì chúng tôi phải làm là sử dụng n thuật ngữ đầu tiên bằng cách sử dụng $. Cấu trúc $vcho bất kỳ động từ nào vlà một ví dụ về hook và đưa nó nlàm đối số sẽ thực thi n $ (v n).

Đây là phiên bản 13 byte cũ, ít lãng phí thời gian và không gian hơn : ($1+2|I.)^:_~. Nó cắt ngắn đầu vào ở mỗi bước, vì vậy chúng ta có thể chạy chính xác bao nhiêu lần cần thiết để giải quyết, thay vì tuyến tính nhiều lần.

Fueue , 30 byte

Fueue là một esolang dựa trên hàng đợi, trong đó chương trình đang chạy và dữ liệu của nó đều nằm trong cùng một hàng đợi, việc thực thi diễn ra xung quanh hàng đợi theo chu kỳ và lập trình đòi hỏi rất nhiều đồng bộ hóa để ngăn chặn mọi thứ thực thi không đúng lúc.

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

Hãy thử trực tuyến!

Ở trên in một danh sách không giới hạn các chữ số dưới dạng mã kiểm soát. Đối với 34 byte, nó có thể in các chữ số thực tế:

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

Hãy thử trực tuyến!

Phần còn lại của lời giải thích sử dụng phiên bản sau.

Tóm tắt các yếu tố Fueue

Hàng đợi Fueue có thể chứa các loại phần tử sau:

• Các số nguyên, in mã điểm Unicode của chúng khi được thực thi,
• Các khối chương trình con được phân tách bằng dấu ngoặc vuông, không hoạt động một cách thương xót (chỉ di chuyển đến cuối hàng đợi) trừ khi )hàm gỡ lỗi chúng và
• Các hàm ký tự đơn, thực thi nếu chúng được theo sau bởi đúng loại đối số và vẫn không hoạt động.
  • Các hàm duy nhất được sử dụng trong chương trình này là ~(hoán đổi hai phần tử sau), :(phần tử tiếp theo trùng lặp) và )(gỡ lỗi khối sau).

Tổng quan cấp cao

Trong vòng lặp chính của chương trình, hàng đợi bao gồm:

• một chuỗi các khối biểu thị các chữ số được lặp qua;
  • Một chữ số 1 hoặc 2 được biểu thị bằng các khối [49]và [50:], tương ứng.
• một phần vòng lặp chính tự sao chép đi qua các khối chữ số và đặt xen kẽ 1 và 2 sau chúng, sau đó gỡ lỗi chúng.
  • Một khối chữ số được gỡ rối in chữ số d của chính nó , và sau đó tạo các bản sao d của khối sau, do đó tạo ra các chữ số cho lần chạy mà nó mô tả.

Dấu vết cấp thấp của 10 lệnh đầu tiên

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:])~)~~

Hướng dẫn của một vòng lặp chính đầy đủ

Khoảng trắng tùy chọn đã được chèn vào các lệnh riêng biệt.

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

Chu kỳ 1: 49in 1. )không hoạt động, chờ đợi để được kết hợp với khối vòng lặp chính. 50in 2. :sao chép khối vòng lặp chính (cần một bản sao để tự sao chép.)

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

Chu kỳ 2: )gỡ lỗi khối vòng lặp chính đầu tiên, làm cho nó bắt đầu thực hiện chu kỳ tiếp theo.

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

Chu kỳ 3: [50:]đại diện cho chữ số đầu tiên được tạo ra trong chuỗi, 2chưa được gỡ lỗi. Sau đây )cuối cùng sẽ làm như vậy sau khi phần còn lại của vòng lặp chính đã đi qua nó. ~)~:~là một golfed (sử dụng một trao đổi và một bản sao) chậm trễ một chu kỳ của ~)~~. [[49]:~))~:~~]không hoạt động. ~hoán đổi khối vòng lặp chính sau qua [50:]khối chữ số.

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

Chu kỳ 4: )vẫn chờ, ~)~sản xuất ~), ~hoán đổi [[49]:~))~:~~]qua [50:]khối chữ số.

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

Chu kỳ 5: ~hoán đổi )qua [50:]khối chữ số.

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

Chu kỳ 6: Lần đầu tiên )bây giờ gỡ lỗi [50:]khối chữ số, lần tiếp theo )gỡ lỗi chương trình con [[49]:~))~:~~].

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

Chu kỳ 7: 50in 2, :sao chép [49]khối chữ số vừa tạo , tạo ra một chuỗi hai 1s. :~))~:~là một sự chậm trễ một chu kỳ của ~~))~:. ~hoán đổi khối vòng lặp chính còn lại qua đầu tiên [49].

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

Chu kỳ 8: ~~))là độ trễ một chu kỳ của )~). ~hoán đổi :qua hiện tại đi qua [49].

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

Chu kỳ 9: ~hoán đổi )quá khứ [49]. :nhân đôi khối vòng lặp chính.

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

Chu kỳ 10: Lần đầu tiên )gỡ lỗi [49]khối chữ số vừa đi qua, lần thứ hai )khởi động lại vòng lặp chính để đi qua vòng tiếp theo (ở trên hiển thị ở đầu hàng đợi.)

x86, 41 37 35 33 28 byte

Tôi đã có rất nhiều điều thú vị xung quanh với các hướng dẫn x86 khác nhau, vì đây là câu trả lời x86 "không tầm thường" đầu tiên của tôi. Tôi thực sự đã học x86-64 trước tiên và tôi đã lưu nhiều byte chỉ bằng cách chuyển đổi chương trình của mình thành 32 bit.

Hóa ra thuật toán mà tôi đã sử dụng từ OEIS đẩy các giá trị lên một mảng, điều này làm cho nó có thể sửa đổi thành x86 và lưu trữ các giá trị trên ngăn xếp (lưu ý MIPS không có hướng dẫn ngăn xếp).

Hiện tại chương trình lấy Ncác giá trị làm đầu vào ecxvà trả về một địa chỉ trong ebpmột mảng với phần tử thứ n đại diện cho giá trị thứ n trong chuỗi. Tôi giả sử trả về ngăn xếp và tính toán các giá trị bổ sung là hợp lệ (dù sao chúng tôi cũng coi những gì nằm ngoài mảng là rác).

Thay đổi

• -4 byte bằng cách tính toán x = 2 - n%2với xormỗi lần lặp

• -2 byte bằng cách sử dụng vòng lặp do-while thay vì vòng lặp while.

• -2 byte bằng cách đẩy các giá trị ban đầu 1, 2, 2 bằng cách sử dụng eax

• -5 byte bằng cách không lưu trữ nrõ ràng và thay vào đó chạy Nthời gian vòng lặp

.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

Objdump:

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 byte

-9 byte nhờ @ceilingcat

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

Hãy thử trực tuyến!

Tạo các giá trị của chuỗi vô thời hạn (tùy chọn 3 từ thử thách)

Perl 5 , 36 byte

Vẫn là một sửa đổi nhỏ của giải pháp TPR (0,3) cổ điển:

Xuất ra chuỗi từ 0đếnn

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

Hãy thử trực tuyến!

Javascript ES6 - 71 70 68 byte

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

Lưu 1 bit nhờ Neil

Xe tăng đến Shaggy để sửa lỗi của tôi, cũng để tiết kiệm 1 bit.

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>

Đã áp dụng , 89 byte

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

Xác định hàm Kkhông có đối số và trả về chuỗi Kolakoski dưới dạng danh sách vô hạn. Hãy thử trực tuyến!

Cách tiếp cận này được lấy cảm hứng từ câu trả lời Haskell hoàn toàn của con người . Cách tiếp cận ban đầu của tôi dài hơn và có lẽ là O (2 ^ n). : ^ P

Ung dung

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

Danh sách trả lại bắt đầu bằng (1 2). Sau đó, để tạo phần còn lại của nó (đọc từ trong ra ngoài):

• Gọi đệ quy (kolakoski)để lấy danh sách trình tự Kolakoski (do đánh giá lười biếng, không có vấn đề gì khi danh sách chưa được tạo đầy đủ)
• (cycle (list 1 2)) tạo một danh sách vô hạn (1 2 1 2 1 2 ...)
• Zip hai danh sách vô hạn với nhau bằng cách sử dụng chức năng repeat-val. Điều này sẽ lặp lại 1hoặc 2từ cycledanh sách một hoặc hai lần tùy thuộc vào giá trị được liên kết trong danh sách Kolakoski. Kết quả:((1) (2 2) (1 1) ...)
• flatten danh sách đó vào (1 2 2 1 1 ...)
• Chúng tôi đã có hai thuật ngữ đầu tiên từ đó (concat (list 1 2), vì vậy chúng tôi hai thuật ngữ dropđầu tiên từ danh sách được tạo để tránh trùng lặp.

Stax , 12 byte

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

Chạy và gỡ lỗi nó

Đây là đại diện ascii của cùng một chương trình.

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

Nó mở rộng chuỗi x lần trong đó x là đầu vào. Sau đó, nó xuất ra phần tử ^thứ x , được lập chỉ mục 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

Đây là một giải pháp 12 byte thưởng tạo ra đầu ra dưới dạng luồng vô hạn. Nhấn Run để bắt đầu.

R, 63 byte hoặc 61 byte

Thực hiện 1: in ra thuật ngữ ^thứ n của chuỗi.

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

Thực hiện 2: in ra n điều khoản đầu tiên của chuỗi.

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

(Sự khác biệt chỉ ở dòng cuối cùng.)

Vâng, vâng, bạn có thể phàn nàn rằng giải pháp của tôi không hiệu quả, rằng nó tính toán thực sự nhiều điều khoản hơn mức cần thiết, nhưng vẫn ...

Cập nhật: Cảm ơn @Giuseppe đã loại bỏ 9 byte.

Ngôn ngữ lập trình Shakespeare, 575 byte (nhưng bị lỗi) hoặc 653 hoặc 623 byte

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

Trong danh mục SPL được tranh luận sôi nổi, điều này sẽ đánh bại mục hiện tại của Jo King (583 byte), ngoại trừ bị lỗi: Đầu tiên, nó không chạy trong phiên bản TIO (triển khai trang web SPL) - nhưng nó chạy trong Perl phiên bản , vì vậy có lẽ đó không phải là một khiếm khuyết nghiêm trọng. Thứ hai, mặc dù, nó không in hai chữ số đầu tiên. Nếu chúng tôi cho phép khiếm khuyết đó trong giải pháp Jo King, thì giải pháp bị lỗi đó sẽ là 553 byte, đánh bại giải pháp bị lỗi của tôi.

Giải pháp của tôi thất bại trên TIO vì hai lý do: chúng tôi cố gắng dựa vào một ngăn xếp trống trở về 0 khi bật; và chúng tôi đã quay cảnh đầu tiên, với "[Enter Ford and Puck]" mặc dù không ai rời khỏi sân khấu. Đây chỉ là những cảnh báo trong phiên bản Perl. Nếu tôi sửa các lỗi này và đặt vào hai chữ số đầu tiên, tôi đạt 653 byte:

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

Hãy thử trực tuyến!

Tôi có thể tạo chuỗi đầy đủ trong triển khai Perl bằng 623 byte:

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

Tuy nhiên, tôi sẽ chỉ ra rằng giải pháp này nhanh so với nhiều giải pháp khác và sử dụng lượng bộ nhớ logarit thay vì lưu trữ toàn bộ danh sách. (Điều này tương tự như giải pháp C của vazt, mà nó có liên quan xa.) Điều này không tạo ra sự khác biệt cho golf, nhưng tôi hài lòng với nó ngay cả như vậy. Bạn có thể tạo ra một triệu chữ số trong khoảng một phút bằng Perl (ví dụ: nếu bạn chuyển sang sed và wc để lấy số chữ số), trong đó giải pháp khác có thể cung cấp cho bạn vài nghìn chữ số.

Giải trình

Chúng tôi lưu trữ một chuỗi các biến theo thứ tự: Ngăn xếp của Puck (từ dưới lên trên), giá trị của Puck, giá trị của Ford, ngăn xếp của Ford (từ trên xuống dưới). Ngoài các giá trị 0 ở cuối (với số 0 ở bên trái có thể xuất hiện một ngăn xếp trống), mỗi giá trị là chữ số được tạo tiếp theo ở thế hệ đó, với 2 được thêm vào nếu thế hệ tiếp theo cần có một đứa con khác từ cha mẹ đó. Khi chúng ta có N giá trị khác không trong chuỗi, chúng ta tạo ra tất cả các phần tử con lên đến và bao gồm cả thế hệ thứ N, trong một kiểu truyền qua cây sâu đầu tiên. Chúng tôi chỉ in các giá trị từ thế hệ thứ N. Khi thế hệ thứ N đã được tạo hoàn toàn, các giá trị được lưu trữ trên thực tế là các giá trị bắt đầu cho các thế hệ 2 đến (N + 1), vì vậy chúng tôi nối thêm 2 ở bên trái và bắt đầu lại, lần này tạo ra (N + 1 ) - thế hệ thứ.

Vì vậy, một phác thảo: Cảnh X: Khi chúng ta đến đây, đây là khởi đầu của một giao dịch mới. Puck == 0. Chúng tôi tùy ý đẩy số 0 đó lên ngăn xếp của Puck và đặt Puck = 2. Cảnh L: Nếu Ford == 0, chúng tôi đã đạt đến thế hệ in. Nếu không, goto V. Để in, nếu giá trị trong Puck đã được thêm 2, hãy xóa 2 và in hai lần; nếu không, hãy in nó một lần. Cảnh M: Đây là một vòng lặp trong đó chúng tôi liên tục chuyển đổi giá trị của Puck và quay lại trình tự. Chúng tôi lặp lại cho đến khi chúng tôi đạt đến điểm cuối (Puck == 0), trong trường hợp đó là goto X hoặc chúng tôi đạt đến một giá trị cần một đứa trẻ khác (Puck> 2), trong trường hợp đó, trừ 2 thêm và đi tiếp trong V. Cảnh V: Ở đây chúng tôi đi về phía trước. Nếu Puck là 2 hoặc 4, thế hệ tiếp theo sẽ chứa hai con từ cha mẹ hiện tại, vì vậy Ford + = 2. Bước chuyển tiếp qua trình tự. Goto L để kiểm tra chấm dứt.

axo , 13 byte

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

Hãy thử trực tuyến!

Giải trình

Điều này bắt đầu như là một cổng của một giải pháp thay thế trong câu trả lời Wumpus của tôi :

2%)[=]&=[O00.

Điều này dẫn đến 18 byte. Tôi đã kết thúc việc đánh gôn xuống 13 byte mà bạn thấy ở trên để điều chỉnh nó nhiều hơn với cách thức hoạt động của axo. Phiên bản 13 byte này sau đó đã truyền cảm hứng cho việc cải thiện xuống còn 11 byte trong Wumpus, vì vậy bây giờ nó thực sự gần với phiên bản đó hơn.

Như trong Wumpus, trong lần lặp i , phần dưới cùng của ngăn xếp giữ một (i) -1 và phần trên giữ phần tử đầu tiên của lần chạy thứ i , nhưng chúng tôi đang làm việc với 0 và 1 trong suốt, ngoại trừ việc in.

[:    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.

Ruby , 45 39 byte

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

in vô thời hạn

Hãy thử trực tuyến!

Hãy thử nó với chức năng in quá tải cho phép bạn chọn một dấu phân cách và số lượng phần tử được in