นี่คือการตีพิมพ์ซ้ำของความท้าทายเก่าเพื่อปรับความต้องการ I / O ให้เป็นมาตรฐานล่าสุดของเรา สิ่งนี้ทำขึ้นเพื่อพยายามให้ภาษาต่าง ๆ มีส่วนร่วมมากขึ้นในการท้าทายเกี่ยวกับลำดับยอดนิยมนี้ ดูโพสต์เมตานี้สำหรับการสนทนาของ repost

ลำดับ Kolakoski เป็นลำดับการอ้างอิงด้วยตนเองที่สนุกซึ่งมีเกียรติในการเป็นลำดับ OEIS A000002 (และง่ายต่อการเข้าใจและนำไปใช้มากกว่า A000001) ลำดับเริ่มต้นด้วย1ประกอบด้วยเพียง1วินาทีและ2วินาทีและองค์ประกอบลำดับ(n)อธิบายความยาวของการรันครั้งที่nของ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,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 TH ระยะของลำดับที่nเริ่มต้นทั้งจาก0หรือ1
2. รับอินพุตnและป้อนเงื่อนไขจนถึงและรวมถึงคำที่nของลำดับโดยที่nเริ่มจาก0หรือ1 (เช่นพิมพ์คำแรกnหรือคำแรกn + 1 )
3. ค่าเอาต์พุตจากลำดับอย่างไม่มีกำหนด

ในกรณีที่สองและสามคุณสามารถเลือกรูปแบบรายการที่สมเหตุสมผลและไม่คลุมเครือ ไม่เป็นไรถ้าไม่มีตัวคั่นระหว่างองค์ประกอบเนื่องจากเป็นตัวเลขหนึ่งหลักเสมอตามคำจำกัดความ

ในกรณีที่สามหากการส่งของคุณเป็นฟังก์ชั่นคุณสามารถส่งกลับรายการที่ไม่มีที่สิ้นสุดหรือเครื่องกำเนิดในภาษาที่รองรับ

คุณสามารถเขียนโปรแกรมหรือฟังก์ชั่นและใช้วิธีการมาตรฐานใด ๆ ของเราในการรับอินพุตและให้เอาต์พุต โปรดทราบว่าช่องโหว่เหล่านี้ถูกห้ามใช้โดยปริยาย

นี่คือรหัสกอล์ฟดังนั้นคำตอบที่สั้นที่สุดที่ถูกต้อง - วัดเป็นไบต์ - ชนะ

เยลลี่ขนาด 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 ^THองค์ประกอบเจครั้งที่เจเป็นk ^THองค์ประกอบของรายการก่อนหน้านี้และในที่สุดก็ตัดทอนผลต่อความยาว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

Python 2 , 51 ไบต์

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

พิมพ์ไปเรื่อย ๆ สร้างรายการlตามที่มีการวนซ้ำผ่าน สำหรับแต่ละรายการxของl, ผนวกxสำเนา1หรือ2แล้วแต่จำนวนใดจะตรงข้ามองค์ประกอบสุดท้ายปัจจุบัน

ปัญหาหลักคือการจัดการกับส่วนเริ่มต้นอ้างอิง[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 nn

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.

ลองออนไลน์!

พิมพ์ลำดับไปเรื่อย ๆ โดยไม่มีตัวคั่น

ฉันรู้สึกประหลาดใจอย่างแท้จริงกับความสั้นนี้

คำอธิบาย

แนวคิดพื้นฐานคือการรักษาลำดับไว้บนสแต็กและใช้องค์ประกอบล่างสุดซ้ำ ๆ เพื่อสร้างการเรียกใช้อีกครั้งจากนั้นพิมพ์ เรากำลังใช้งานสแต็กอย่างมีประสิทธิภาพที่นี่ นอกจากนี้เรายังสามารถบันทึกสองสามไบต์โดยการทำงาน0และ1(เพิ่มเฉพาะสำหรับเอาต์พุต) แทน1และ2เนื่องจากวิธีนี้เราไม่จำเป็นต้องเริ่มต้นสแต็กอย่างชัดเจนด้วย a 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

Huskขนาด 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]

Java 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
-5 ไบต์ขอบคุณที่@MartinEnder
-3 ไบต์แปลง Java 8 เป็น Java 10

คำอธิบาย:

ลองออนไลน์ (หมดเวลาหลังจาก 60 วินาทีใน 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`

เยลลี่ 10 ไบต์

’߀+\<¹SḂ‘

ส่งกลับn ^THระยะ

ลองออนไลน์!

มันทำงานอย่างไร

’߀+\<¹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 ไบต์

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

ลองออนไลน์!

Ørjan Johansen บันทึก 7 ไบต์โดยใช้รูปแบบที่ไม่สามารถหักล้างได้เพื่อบังคับให้นำหน้า

Gol> <> , 8 7 ไบต์

:{:PnKz

ลองออนไลน์!

คำอธิบาย

นี่คือพอร์ตของคำตอบ Wumpus ของฉัน Gol> <> เป็นพื้นภาษาที่มีคุณสมบัติทั้งหมดที่จำเป็นในพอร์ตคำตอบ Wumpus (เฉพาะศูนย์นัยที่ด้านล่างของสแต็ค "ซ้ำ" ดำเนินการ "ป๊อปผลักดัน" และคำสั่งสแต็คหมุน) แต่ :

• มันมีตาราง toroidal ซึ่งหมายความว่าเราไม่จำเป็นต้องชัดเจน00.เพื่อกลับไปที่จุดเริ่มต้น
• มันมีKซึ่งเป็น "pop N จากนั้นทำซ้ำองค์ประกอบถัดไป N ครั้ง" ซึ่งสามารถแทนที่?=บันทึกไบต์อื่น

ดังนั้นการแมปจาก Wumpus ถึง Gol> <> จะกลายเป็น:

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

ภาษาการเขียนโปรแกรมของเช็คสเปียร์ , 594 583 572 ไบต์

ขอบคุณเอ็ดวินน์สำหรับ -10 ไบต์!

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

ลองออนไลน์!

นี่เป็นรุ่นที่ไม่ตีกอล์ฟของเอ็ดวินน์ซึ่งเริ่มต้นจากวิธีแก้ปัญหา 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=!

ลองออนไลน์!

พอร์ตของมาร์ตินพลิกคำตอบ Wumpus น่าเสียดายที่><>ไม่มีคำสั่งเพิ่มหรือคำสั่ง invert หรือไม่มีนัย 0 ที่ด้านล่างของสแต็กดังนั้นสิ่งนี้จึงสิ้นสุดลงอีกเล็กน้อย

JavaScript, 67 66 60 58 52 51 50 ไบต์

นั่นทำให้สมองฉันคันมากกว่าที่ควรจะเป็น! เรียกคืนnคำศัพท์ที่ 0 ซึ่งจัดทำดัชนีไว้

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

5 + 1 ไบต์ที่บันทึกไว้ขอบคุณtshเกาสมองของฉัน!

ทดสอบมัน

ตัวอย่างด้านล่างจะแสดงผล 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)

Python (2 และ 3), 65 60 ไบต์

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

ส่งคืนรายการที่n ที่มีการจัดทำดัชนี 0

ทางเลือก (65 ไบต์):

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

Haskell , 48 ไบต์

-1 ไบต์ขอบคุณ nimi -2 ไบต์ขอบคุณ Lynn

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

ลองออนไลน์!

ทำซ้ำทุกองค์ประกอบของตำแหน่ง mod 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 ไบต์

บันทึก 3 ไบต์ขอบคุณGrimy

พิมพ์รายการ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

Python 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.)^:]

เพียง sprucing คำตอบเก่าของฉันกับคำถามเก่า

I.เป็นคำกริยาที่ใช้อาร์เรย์ของตัวเลขและแยกรายการดัชนีออกมาดังนั้นหากรายการk -th ในอาร์เรย์เป็นnดังนั้นดัชนีkจะปรากฏnครั้ง เราจะใช้มันเพื่อ bootstrap ลำดับ 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ครั้ง ( ^:]) มันควรจะดี (ตรวจสอบลำดับ OEIS อื่น ๆ เหล่านี้สำหรับข้อมูลเพิ่มเติม: ความยาวรุ่น , ผลรวมบางส่วน .)

เมื่อเรากำลังทำที่ทั้งหมดที่เราต้องทำคือการใช้ครั้งแรกn$แง่การใช้ การก่อสร้าง$vสำหรับคำกริยาใด ๆ ที่vเป็นตัวอย่างของเบ็ดและให้มันเป็นอาร์กิวเมนต์จะดำเนินการnn $ (v n)

นี่คือรุ่นเก่า 13 ($1+2|I.)^:_~ไบต์ซึ่งอยู่ไกลน้อยสิ้นเปลืองเวลาและพื้นที่: มันตัดทอนข้อมูลในทุกขั้นตอนดังนั้นเราจึงสามารถเรียกใช้ได้หลายครั้งเท่าที่จำเป็นในการชำระแทนที่จะเป็นแบบเชิงเส้นหลาย ๆ ครั้ง

Fueue , 30 ไบต์

Fueue เป็น esolang ที่อิงกับคิวซึ่งโปรแกรมที่กำลังรันและข้อมูลอยู่ในคิวเดียวกันการดำเนินการไปรอบ ๆ คิวในรอบและการเขียนโปรแกรมต้องการการซิงโครไนซ์จำนวนมากเพื่อป้องกันการดำเนินการใด ๆ ในเวลาที่ไม่ถูกต้อง

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

ลองออนไลน์!

ด้านบนจะพิมพ์รายการตัวเลขที่ไม่สิ้นสุดเป็นรหัสควบคุม สำหรับ 34 ไบต์สามารถพิมพ์ตัวเลขจริงได้:

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

ลองออนไลน์!

ส่วนที่เหลือของคำอธิบายใช้รุ่นหลัง

บทสรุปขององค์ประกอบ Fueue

คิว Fueue สามารถมีองค์ประกอบดังต่อไปนี้:

• จำนวนเต็มซึ่งพิมพ์ Unicode codepoint เมื่อดำเนินการ
• โปรแกรมย่อยที่มีตัวคั่นสี่เหลี่ยมแบบวงเล็บเหลี่ยมซึ่งไม่ได้ใช้งานอย่างมีเมตตา (เพียงแค่ย้ายไปยังจุดสิ้นสุดของคิว) เว้นแต่ว่า)ฟังก์ชันจะทำการดีบั๊กมันและ
• ฟังก์ชั่นอักขระเดี่ยวซึ่งดำเนินการหากมีการตามด้วยอาร์กิวเมนต์ชนิดที่ถูกต้องและยังคงไม่ทำงาน
  • ฟังก์ชั่นเฉพาะที่ใช้ในโปรแกรมนี้คือ~(สลับสององค์ประกอบต่อไปนี้), :(ทำซ้ำองค์ประกอบถัดไป) และ)(deblock บล็อกต่อไปนี้)

ภาพรวมระดับสูง

ระหว่างวนรอบหลักของโปรแกรมคิวประกอบด้วย:

• สายโซ่ของบล็อกแสดงตัวเลขที่จะทำซ้ำผ่าน;
  • ตัวเลข 1 หรือ 2 แสดงโดยบล็อก[49]และ[50:]ตามลำดับ
• ส่วนหลักวนซ้ำตัวเองที่ลัดเลาะบล็อกหลักและทำให้สลับ 1s และ 2s หลังจากพวกเขาจากนั้น deblocks พวกเขา
  • บล็อกหลัก deblocked พิมพ์ของตัวเองหลัก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)502:

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

รอบ 2: )deblocks บล็อกลูปหลักแรกทำให้มันเริ่มดำเนินการรอบถัดไป

[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: ครั้งแรก)ในขณะนี้ deblocks [50:]บล็อกหลักถัดไป)deblocks [[49]:~))~:~~]ย่อย

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

รอบที่ 7: 50พิมพ์2, :ทำซ้ำ[49]บล็อกตัวเลขที่เพิ่งสร้างขึ้น, สร้างจำนวนสอง1วินาที ความล่าช้าหนึ่งวงจรของ:~))~:~ แลกเปลี่ยนที่เหลือบล็อกวงหลักที่ผ่านมาเป็นครั้งแรก~~))~:~[49]

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

รอบ 8: ความล่าช้าหนึ่งวงจรของ~~)) แลกเปลี่ยนที่ผ่านมาสำรวจในปัจจุบัน)~)~:[49]

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

รอบ 9: ~แลกเปลี่ยนที่ผ่านมา) ทำซ้ำบล็อกลูปหลัก[49]:

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

รอบ 10: )deblocks แรกของ[49]บล็อกหลักที่เพิ่งผ่านไปครั้งที่สอง)รีสตาร์ทลูปหลักเพื่อข้ามหนึ่งถัดไป (ด้านบนแสดงที่จุดเริ่มต้นของคิว)

x86, 41 37 35 33 28 ไบต์

ฉันสนุกมากที่ได้ทำตามคำแนะนำ x86 ที่แตกต่างกันเนื่องจากนี่เป็นคำตอบแรกที่ "ไม่สำคัญ" x86 จริง ๆ แล้วฉันเรียนรู้ x86-64 ก่อนและฉันบันทึกหลายไบต์เพียงแค่แปลงโปรแกรมของฉันเป็น 32 บิต

ปรากฎว่าอัลกอริทึมที่ฉันใช้จาก OEIS ส่งค่าไปยังอาร์เรย์ซึ่งทำให้คล้อยตาม x86 และจัดเก็บค่าในสแต็ก (หมายเหตุ MIPS ไม่มีคำแนะนำสแต็ก)

ขณะนี้โปรแกรมใช้Nค่าเป็นอินพุตecxและส่งคืนแอดเดรสในebpอาร์เรย์ด้วยองค์ประกอบที่ n ที่แสดงถึงค่า nth ในลำดับ ฉันสมมติว่าคืนค่าสแต็กและการคำนวณค่าเพิ่มเติมนั้นถูกต้อง (เราพิจารณาว่าอะไรที่เกินกว่าอาร์เรย์เป็นขยะอยู่แล้ว)

การเปลี่ยนแปลง

• -4 ไบต์โดยคำนวณx = 2 - n%2ด้วยxorการวนซ้ำทุกครั้ง

• -2 ไบต์โดยใช้ do-while แทน while ลูป

• -2 ไบต์โดยการกดค่าเริ่มต้น 1, 2, 2 โดยใช้ eax

• -5 ไบต์โดยไม่เก็บnอย่างชัดเจนและแทนที่จะใช้Nเวลาวนรอบแทน

.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 ไบต์

-9 ไบต์ขอบคุณ @ceilingcat

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

ลองออนไลน์!

สร้างค่าของลำดับอย่างไม่มีกำหนด (ตัวเลือก 3 จากการท้าทาย)

Perl 5 , 36 ไบต์

ยังเป็นการปรับเปลี่ยนเล็กน้อยของโซลูชัน TPR แบบคลาสสิก (0,3):

ส่งออกซีรีส์จาก0ถึงn

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

ลองออนไลน์!

Javascript ES6 - 71 70 68 ไบต์

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

ประหยัด 1 บิตขอบคุณNeil

Tanks to Shaggyเพื่อแก้ไขข้อผิดพลาดของฉันเช่นกันสำหรับการบันทึก 1 บิต

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>

Appleseed , 89 ไบต์

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

กำหนดฟังก์ชั่นKที่ไม่มีการขัดแย้งและส่งกลับลำดับ Kolakoski เป็นรายการที่ไม่มีที่สิ้นสุด ลองออนไลน์!

วิธีการนี้ได้รับแรงบันดาลใจจากtotallyhuman คำตอบของ วิธีดั้งเดิมของฉันนานขึ้นและอาจเป็น O (2 ^ n) : ^ P

Ungolfed

(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ซิปสองรายการอนันต์ด้วยกันโดยใช้ฟังก์ชั่น สิ่งนี้จะทำซ้ำ1หรือ2จากcycleรายการหนึ่งหรือสองครั้งขึ้นอยู่กับค่าที่เกี่ยวข้องในรายการ Kolakoski ผลลัพธ์:((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 ^THองค์ประกอบ, 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 ไบต์ที่สร้างเอาต์พุตเป็นสตรีมไม่สิ้นสุด กด Run เพื่อเริ่ม

R, 63 ไบต์หรือ 61 ไบต์

การดำเนินงาน 1:พิมพ์ออกn ^THระยะของลำดับ

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]

(ความแตกต่างอยู่ในบรรทัดสุดท้ายเท่านั้น)

ใช่ใช่คุณอาจบ่นว่าโซลูชันของฉันไม่มีประสิทธิภาพมันคำนวณคำศัพท์มากกว่าที่จำเป็น แต่ยัง ...

อัปเดต:ขอบคุณ@Giuseppeสำหรับการลบขนาด 9 ไบต์

ภาษาการเขียนโปรแกรมของเช็คสเปียร์ 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.

ในหมวด SPL ที่แข่งขันกันอย่างดุเดือดสิ่งนี้จะชนะรายการปัจจุบันของ Jo King (583 ไบต์) ยกเว้นว่ามีข้อบกพร่อง: อันดับแรกจะไม่ทำงานในรุ่น TIO (ใช้งานเว็บไซต์ SPL) - แต่ทำงานในPerl เวอร์ชันดังนั้นอาจไม่ใช่ข้อบกพร่องที่ร้ายแรง ที่สองแม้ว่าจะไม่พิมพ์ตัวเลขสองหลักแรก หากเราอนุญาตให้ข้อบกพร่องนั้นในโซลูชันของ Jo King แสดงว่าโซลูชันที่มีข้อบกพร่องนั้นจะเป็น 553 ไบต์ซึ่งจะเป็นการเต้นโซลูชันที่มีข้อบกพร่องของฉัน

โซลูชันของฉันล้มเหลวใน TIO ด้วยเหตุผลสองประการ: เราพยายามพึ่งพาสแต็กเปล่าที่คืนค่าศูนย์เมื่อผุด และเราได้ฉากแรกโดยใช้ "[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.

ลองออนไลน์!

ฉันสามารถสร้างลำดับเต็มในการใช้ Perl โดยใช้ 623 bytes:

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

อย่างไรก็ตามฉันจะชี้ให้เห็นว่าวิธีนี้เร็วกว่าโซลูชั่นอื่น ๆ มากมายและใช้หน่วยความจำลอการิทึมแทนการเก็บรายการทั้งหมด (นี่คล้ายกับโซลูชัน C ของ vazt ซึ่งมีความสัมพันธ์กันอย่างห่างไกล) นี่ไม่ได้สร้างความแตกต่างสำหรับการเล่นกอล์ฟ แต่ฉันก็พอใจกับมันเช่นกัน คุณสามารถสร้างล้านหลักในเวลาประมาณหนึ่งนาทีใน Perl (ตัวอย่างเช่นถ้าคุณไปที่ sed และ wc เพื่อรับจำนวนหลัก) ซึ่งโซลูชันอื่นอาจให้คุณสองสามพันหลัก

คำอธิบาย

เราเก็บลำดับของตัวแปรตามลำดับ: สแต็คของ Puck (จากล่างขึ้นบน), ค่าของ Puck, ค่าของฟอร์ด, สแต็คของฟอร์ด (บนลงล่าง) นอกเหนือจากศูนย์ค่าที่จุดสิ้นสุด (โดยที่ศูนย์ทางด้านซ้ายอาจจะมาจากการ p กองที่ว่างเปล่า) แต่ละค่าคือตัวเลขที่สร้างขึ้นถัดไปที่รุ่นนั้นด้วย 2 เพิ่มถ้ารุ่นต่อไปต้องมีลูกอีกคนจากผู้ปกครองนั้น เมื่อเรามีค่า N ที่ไม่เป็นศูนย์ในลำดับเราจะสร้างเด็ก ๆ ทั้งหมดและรวมถึงรุ่นที่ N ในรูปแบบของการสำรวจเส้นทางแบบทรีแรก เราพิมพ์ค่าจากรุ่นที่ N เท่านั้น เมื่อการสร้างยุคที่ N ถูกสร้างขึ้นอย่างสมบูรณ์แล้วค่าที่เก็บไว้นั้นเป็นค่าเริ่มต้นสำหรับรุ่นที่ 2 ถึง (N + 1) ดังนั้นเราจึงผนวก 2 ทางซ้ายและเริ่มอีกครั้งคราวนี้จะสร้าง (N + 1 ) - รุ่นที่

ดังนั้นโครงร่าง: ฉากที่ X: เมื่อเรามาถึงที่นี่นี่เป็นการเริ่มต้นการสำรวจเส้นทางใหม่ เด็กซน == 0 เราเลือกที่จะผลักดันศูนย์นั้นไปที่กองซ้อนของ Puck และตั้งค่า Puck = 2 ฉาก L: ถ้าฟอร์ด == 0 เราได้มาถึงยุคแห่งการพิมพ์ ถ้าไม่ได้ข้ามไป V. สำหรับการพิมพ์หากค่าใน Puck มี 2 เพิ่มให้ลบ 2 แล้วพิมพ์สองครั้ง หากไม่พิมพ์ออกมาหนึ่งครั้ง ฉาก M: นี่คือลูปที่เราสลับค่าของ Puck ซ้ำ ๆ และย้อนกลับไปตามลำดับ เราทำซ้ำจนกว่าจะถึงจุดสิ้นสุด (Puck == 0) ในกรณีที่ goto X หรือเราถึงค่าที่ต้องการลูกอีกคน (Puck> 2) ซึ่งในกรณีนี้จะลบ 2 พิเศษและไปข้างหน้าใน V. Scene V: ที่นี่เราไปข้างหน้า หาก Puck เป็น 2 หรือ 4 รุ่นถัดไปจะมีลูกสองคนจากพาเรนต์ปัจจุบันดังนั้น Ford + = 2 ขั้นตอนการส่งต่อผ่านลำดับ ไปที่ L เพื่อตรวจสอบการเลิกจ้าง

axo , 13 ไบต์

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

ลองออนไลน์!

คำอธิบาย

สิ่งนี้เริ่มต้นจากการเป็นพอร์ตของโซลูชันทางเลือกในคำตอบของ Wumpus ของฉัน :

2%)[=]&=[O00.

สิ่งนี้ส่งผลให้ 18 ไบต์ ฉันลงเอยด้วยการตีลูกกอล์ฟลงถึง 13 ไบต์ที่คุณเห็นด้านบนเพื่อปรับให้มากขึ้นตามวิธีการทำงานของ axo รุ่น 13- ไบต์นี้แล้วลงเอยด้วยการสร้างแรงบันดาลใจในการพัฒนาถึง 11 ไบต์ใน Wumpus ดังนั้นตอนนี้จริง ๆ แล้วใกล้เคียงกับรุ่นนั้นมากขึ้น

เช่นเดียวกับ Wumpus ในการวนซ้ำiด้านล่างของสแต็กถือ(i) -1และด้านบนเก็บองค์ประกอบแรกของi th run แต่เราทำงานกับ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.

Ruby , 45 39 ไบต์

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

พิมพ์ไปเรื่อย ๆ

ลองออนไลน์!

ลองด้วยฟังก์ชั่นการพิมพ์ที่มากเกินไปที่ช่วยให้คุณเลือกตัวคั่นและจำนวนองค์ประกอบที่พิมพ์