Ini adalah repost dari tantangan lama , untuk menyesuaikan persyaratan I / O dengan standar terbaru kami. Ini dilakukan sebagai upaya untuk memungkinkan lebih banyak bahasa untuk berpartisipasi dalam tantangan tentang urutan populer ini. Lihat posting meta ini untuk diskusi tentang repost.

Urutan Kolakoski adalah urutan referensial diri yang menyenangkan, yang mendapat kehormatan sebagai urutan OEIS A000002 (dan itu jauh lebih mudah untuk dipahami dan diimplementasikan daripada A000001). Urutan dimulai dengan 1 , hanya terdiri dari 1 dan 2 dan urutan elemen a (n) menjelaskan panjang n th menjalankan 1 s atau 2 s dalam urutan. Ini secara unik mendefinisikan urutan menjadi (dengan visualisasi berjalan di bawahnya):

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

Tugas Anda, tentu saja, untuk mengimplementasikan urutan ini. Anda dapat memilih salah satu dari tiga format untuk melakukannya:

1. Ambil input n dan output istilah ke- n dari urutan, di mana n dimulai dari 0 atau 1 .
2. Ambil input n dan output istilah hingga dan termasuk istilah n urutan, di mana n dimulai baik dari 0 atau 1 (yaitu mencetak n pertama atau n pertama + 1 syarat).
3. Nilai output dari urutan tanpa batas.

Dalam kasus kedua dan ketiga, Anda dapat memilih format daftar yang masuk akal dan tidak ambigu. Tidak apa-apa jika tidak ada pemisah antara elemen, karena mereka selalu satu digit menurut definisi.

Dalam kasus ketiga, jika kiriman Anda adalah fungsi, Anda juga bisa mengembalikan daftar tanpa batas atau generator dalam bahasa yang mendukungnya.

Anda dapat menulis sebuah program atau fungsi dan menggunakan salah satu metode standar kami untuk menerima input dan memberikan output. Perhatikan bahwa celah ini dilarang secara default.

Ini adalah kode-golf , sehingga jawaban terpendek yang valid - diukur dalam byte - menang.

Jelly , 7 byte

2Rṁxṁµ¡

Ini adalah program lengkap yang mencetak istilah n pertama .

Cobalah online!

Bagaimana itu bekerja

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

Contoh dijalankan

Misalkan n = 5 .

Doa pertama dari rantai berulang 1, 2 secara siklik untuk mencapai panjang 5 , kemudian setiap elemen 5 kali, dan akhirnya memotong hasilnya menjadi panjang 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

Ini menghasilkan daftar panjang 5 . Elemen pertama adalah elemen pertama dari urutan Kolakoski.

Doa kedua rantai mengulangi 1, 2 siklis untuk mencapai panjang 5 , maka mengulangi k ^th elemen j kali, di mana j adalah k ^th elemen dari daftar sebelumnya, dan akhirnya memotong hasil dengan panjang 5 .

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

   1 2 1 2 1

Ini menghasilkan daftar panjang 5 lainnya . Dua elemen pertama adalah dua elemen pertama dari urutan Kolakoski.

Proses berlanjut untuk tiga iterasi lagi.

   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

Ini adalah lima elemen pertama dari urutan Kolakoski.

Python 2 , 51 byte

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

Mencetak tanpa batas. Bangun daftar lketika sedang diulangi. Untuk setiap entri xdari l, menambahkan xsalinan 1atau 2, mana yang berlawanan elemen terakhir saat ini.

Kesulitan utama adalah berurusan dengan fragmen referensi-diri awal [1,2,2]. Kode ini hanya mencetak awal 1,2dan hasil dari sana. Biaya pencetakan tambahan 12 byte. Tanpa itu:

39 byte , hilang dua entri pertama:

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

Pendekatan lain adalah menginisialisasi dua entri pertama secara khusus. Kami menginisialisasi lsebagai [0,0,2]sehingga dua entri pertama tidak menyebabkan menambahkan, tetapi print x or nmembuat mereka dicetak sebagai n.

51 byte

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

Perbaikan lain adalah menginisialisasi l=[1], melacak pergantian secara manual n, dan memperbaiki pencetakan:

51 byte

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

Tanpa (l==[1,1])+, semuanya berfungsi kecuali urutan cetak dimulai, 1,1,2bukan 1,2,2. Harus ada cara yang lebih baik untuk mengenali kita pada langkah kedua ini.

Dan perbaikan aneh lainnya, entah bagaimana jumlah byte yang sama:

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.

Cobalah online!

Mencetak urutan tanpa batas tanpa pemisah.

Saya benar-benar terkejut dengan betapa singkatnya ini.

Penjelasan

Ide dasarnya adalah untuk menjaga urutan pada tumpukan dan berulang kali menggunakan elemen paling bawah untuk menghasilkan proses lain dan kemudian mencetaknya. Kami secara efektif menyalahgunakan tumpukan sebagai antrian di sini. Kita juga dapat menyimpan beberapa byte dengan bekerja 0dan 1(hanya menambah output) daripada 1dan 2, karena cara ini kita tidak perlu secara eksplisit menginisialisasi stack dengan a 1dan kita dapat menggunakan negasi logis untuk beralih di antara dua nilai.

     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

Menghasilkan nilai n pertama . Menggunakan "variabel output" .untuk input, dan output ke "variabel input" ?. Cobalah online!

Penjelasan

Saya cukup senang dengan bagaimana deklaratif ini ternyata: program ini pada dasarnya adalah deskripsi tingkat tinggi dari daftar output dan hubungannya dengan input.

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

Karena {1|2}ᵐmencoba daftar dalam urutan leksikografis, output akan dimulai dengan 1.

Sekam , 10 byte

Ṡωo↑⁰`Ṙ¢ḣ2

Mengembalikan nilai n pertama . Cobalah online!

Penjelasan

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

Untuk input 20, prosesnya seperti ini:

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

Mencetak tanpa batas tanpa pembatas.

-3 byte setelah tip tidak langsung dari @Neil .
-5 byte terima kasih kepada @MartinEnder .
-3 byte mengkonversi Java 8 ke Java 10.

Penjelasan:

Cobalah online (waktu habis setelah 60 detik pada 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`

Jelly , 10 byte

’߀+\<¹SḂ‘

Mengembalikan istilah ^ke- n .

Cobalah online!

Bagaimana itu bekerja

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

Cobalah online!

Ørjan Johansen menyimpan 7 byte menggunakan pola yang tak terbantahkan untuk memaksa awalan.

Gol> <> , 8 7 byte

:{:PnKz

Cobalah online!

Penjelasan

Ini adalah port dari jawaban Wumpus saya . Gol> <> pada dasarnya adalah bahasa yang memiliki semua fitur yang diperlukan untuk mem-port jawaban Wumpus (khususnya, nol implisit di bagian bawah tumpukan, "duplikat" yang diterapkan "pop, push, push", dan perintah rotasi stack), tetapi :

• Ini memiliki kotak toroidal, yang berarti kita tidak perlu eksplisit 00.untuk melompat kembali ke awal.
• Itu memiliki K, yaitu "pop N, lalu duplikat elemen N kali berikutnya", yang dapat menggantikan ?=, menyimpan byte lain.

Jadi pemetaan dari Wumpus ke Gol> <> menjadi:

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

Bahasa Pemrograman Shakespeare , 594 583 572 byte

Terima kasih kepada Ed Wynn untuk -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!

Cobalah online!

Ini adalah versi paripurna dari solusi ungolfed Ed Wynn , mulai dari solusi 828 byte yang dia tautkan di komentar dan menjadi sedikit gila dari sana.

Penjelasan:

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

Cobalah online!

Port jawaban Wumpus Martin Ender . Sayangnya, ><>tidak memiliki kenaikan atau perintah pembalik juga tidak memiliki 0s implisit di bagian bawah tumpukan, jadi ini berakhir menjadi sedikit lebih lama.

JavaScript, 67 66 60 58 52 51 50 byte

Nah, itu membuat otak saya gatal lebih dari yang seharusnya! Memulai kembali nistilah ke-0, diindeks.

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

5 + 1 byte disimpan berkat tsh menggaruk otak gatal saya!

Menguji

Cuplikan di bawah ini akan menampilkan 50 istilah pertama.

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>

Penjelasan

Ini adalah salah satu kesempatan langka ketika kita dapat mendeklarasikan beberapa variabel di luar ruang lingkup fungsi kita, memodifikasinya di dalam fungsi dan masih dapat menggunakannya kembali pada panggilan fungsi berikutnya.

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 dan 3), 65 60 byte

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

Mengembalikan entri ke- n , diindeks 0.

Alternatif (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 terima kasih kepada nimi. -2 byte terima kasih kepada Lynn.

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

Cobalah online!

Ulangi setiap elemen posisinya mod 2 + 1 kali.

brainfuck , 61 byte

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

Cobalah online!

Mencetak angka sebagai kode char tanpa batas. Untuk kejelasan, inilah versi yang mencetak dalam angka (kecuali untuk dua elemen pertama, yang cukup mudah untuk diverifikasi).

Bagaimana itu bekerja:

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

Disimpan 3 byte berkat Grimy

Mencetak pertama n item.

Δ2LÞsÅΓI∍

Cobalah online!

Penjelasan

Δ           # 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®É>¸«

Cobalah online! atau dengan batas iterasi

Penjelasan

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

Cobalah online!

J , 12 byte

Fungsi argumen tunggal mengambil n dan menghasilkan istilah n pertama . Cobalah online!

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

Hanya merapikan jawaban lama saya untuk pertanyaan lama.

I.adalah kata kerja yang mengambil array angka dan mengeluarkan daftar indeks, sehingga jika item k -th dalam array adalah n , maka indeks k muncul n kali. Kami akan menggunakannya untuk mem-bootstrap urutan Kolakowski naik dari seed awal. Setiap langkah akan dilanjutkan sebagai berikut:

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) 

Jika kami melakukan operasi ini ( 1+2|I.) berulang-ulang mulai dari 10, akan terlihat seperti ini:

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

Perhatikan bagaimana kita mendapatkan istilah yang lebih banyak dan lebih benar setiap kali, dan setelah beberapa saat n istilah pertama diperbaiki. Jumlah iterasi yang diperlukan untuk menyelesaikannya sulit untuk dijelaskan secara tepat, tetapi tampaknya secara kasar logaritmik dalam n , jadi jika kita hanya menjalankannya n kali ( ^:]) itu harus baik-baik saja. (Lihat urutan OEIS lainnya untuk info lebih lanjut: panjang generasi , jumlah parsial .)

Setelah kita selesai melakukannya, yang harus kita lakukan adalah mengambil n istilah pertama menggunakan $. Konstruksi $vuntuk kata kerja apa pun vadalah contoh dari hook, dan memberikannya nsebagai argumen akan dieksekusi n $ (v n).

Berikut adalah versi lama 13-byte yang jauh lebih boros waktu dan ruang: ($1+2|I.)^:_~. Ini memotong input pada setiap langkah, sehingga kita dapat menjalankan tepat sebanyak yang diperlukan untuk menyelesaikan, bukan berkali-kali secara linear.

Fueue , 30 byte

Fueue adalah esolang berbasis antrian di mana program yang sedang berjalan dan datanya sama-sama berada dalam antrian yang sama, eksekusi berjalan di sekitar antrian dalam siklus, dan pemrograman membutuhkan banyak sinkronisasi untuk menjaga agar tidak ada yang dieksekusi pada waktu yang salah.

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

Cobalah online!

Di atas mencetak daftar angka yang tak berujung sebagai kode kontrol. Untuk 34 byte, ia dapat mencetak angka aktual:

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

Cobalah online!

Sisa dari penjelasan menggunakan versi yang terakhir.

Ringkasan elemen Fueue

Antrian Fueue dapat berisi elemen-elemen berikut:

• Integer, yang mencetak titik kode Unicode saat dijalankan,
• Blok subprogram terbatas braket persegi, yang untungnya tidak aktif (hanya bergerak ke ujung antrian) kecuali )fungsi deblocks mereka, dan
• Fungsi karakter tunggal, yang mengeksekusi jika diikuti oleh tipe argumen yang tepat dan tetap tidak aktif.
  • Satu-satunya fungsi yang digunakan dalam program ini adalah ~(menukar dua elemen berikut), :(duplikat elemen berikutnya), dan )(deblock blok berikut).

Ikhtisar tingkat tinggi

Selama loop utama program, antrian terdiri dari:

• rantai blok yang mewakili digit untuk diulangi;
  • Digit 1 atau 2 diwakili oleh blok [49]dan [50:], masing-masing.
• bagian loop utama yang dapat direplikasi sendiri yang melintasi blok digit dan menempatkan bolak-balik 1s dan 2s setelah mereka, kemudian deblocks mereka.
  • Blok digit yang tidak terkunci akan mencetak digitnya sendiri d , dan kemudian membuat salinan d dari blok berikut, sehingga menciptakan digit untuk proses yang dijelaskan.

Jejak tingkat rendah dari 10 perintah pertama

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

Panduan dari iterasi loop penuh penuh

Ruang kosong opsional telah dimasukkan untuk memisahkan perintah.

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

Siklus 1: 49mencetak 1. )tidak aktif, menunggu untuk disatukan dengan blok loop utama. 50cetakan 2. :menduplikasi blok loop utama (yang membutuhkan salinan untuk replikasi diri.)

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

Siklus 2: )deblocks blok loop utama pertama, membuatnya mulai menjalankan siklus berikutnya.

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

Siklus 3: [50:]mewakili digit pertama yang diproduksi dalam rantai, 2belum di-deblock. Berikut )ini pada akhirnya akan melakukannya setelah sisa dari loop utama telah melewatinya. ~)~:~adalah penundaan satu siklus dari golf (menggunakan swap dan salinan) ~)~~. [[49]:~))~:~~]tidak aktif. ~menukar blok loop utama berikut melewati [50:]blok digit.

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

Siklus 4: )masih menunggu, ~)~menghasilkan ~), ~bertukar [[49]:~))~:~~]melewati [50:]blok digit.

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

Siklus 5: ~swap )melewati [50:]blok digit.

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

Siklus 6: Yang pertama )sekarang deblocks [50:]blok digit, yang berikutnya )deblocks subprogram [[49]:~))~:~~].

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

Siklus 7: 50mencetak 2, :menduplikasi [49]blok digit yang baru saja diproduksi , membuat proses dua 1detik. :~))~:~adalah penundaan satu siklus ~~))~:. ~menukar blok loop utama yang tersisa melewati yang pertama [49].

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

Siklus 8: ~~))adalah penundaan satu siklus )~). ~swap :melewati yang saat ini dilalui [49].

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

Siklus 9: ~bertukar )masa lalu [49]. :menduplikasi blok loop utama.

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

Siklus 10: )Deblocks pertama [49]blok angka yang baru saja dilalui, yang kedua )restart loop utama untuk melintasi yang berikutnya (di atas ditunjukkan pada awal antrian.)

x86, 41 37 35 33 28 byte

Saya senang bermain-main dengan instruksi x86 yang berbeda, karena ini adalah jawaban x86 "non-sepele" pertama saya. Saya sebenarnya belajar x86-64 terlebih dahulu, dan saya menyimpan banyak byte hanya dengan mengubah program saya menjadi 32-bit.

Ternyata algoritma yang saya gunakan dari OEIS mendorong nilai ke array, yang membuatnya setuju dengan x86 dan menyimpan nilai pada stack (perhatikan MIPS tidak memiliki instruksi stack).

Saat ini program mengambil Nnilai sebagai input ecxdan mengembalikan alamat dalam ebparray dengan elemen n yang mewakili nilai ke-n dalam urutan. Saya berasumsi kembali pada stack dan menghitung nilai tambahan adalah valid (kami menganggap apa yang di luar array sebagai sampah).

Changelog

• -4 byte dengan komputasi x = 2 - n%2dengan xorsetiap iterasi

• -2 byte dengan menggunakan do-while bukan while.

• -2 byte dengan mendorong nilai awal 1, 2, 2 menggunakan eax

• -5 byte dengan tidak menyimpan nsecara eksplisit dan bukannya menjalankan Nwaktu loop

.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 berkat @ceilingcat

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

Cobalah online!

Menghasilkan nilai dari urutan tanpa batas (opsi 3 dari tantangan)

Perl 5 , 36 byte

Masih merupakan modifikasi sepele dari solusi TPR (0,3) klasik:

Keluarkan seri dari 0hinggan

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

Cobalah online!

Javascript ES6 - 71 70 68 byte

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

1 bit disimpan berkat Neil

Tanks to Shaggy untuk memperbaiki kesalahan saya, juga untuk menghemat 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>

Diaplikasikan , 89 byte

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

Menentukan fungsi Kyang tidak menggunakan argumen dan mengembalikan urutan Kolakoski sebagai daftar tanpa batas. Cobalah online!

Pendekatan ini terinspirasi oleh jawaban Haskell yang sepenuhnya manusiawi . Pendekatan asli saya lebih lama dan mungkin O (2 ^ n). : ^ P

Tidak disatukan

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

Daftar kembali dimulai dengan (1 2). Setelah itu, untuk menghasilkan sisanya (membaca dari dalam ke luar):

• Panggilan rekursif (kolakoski) untuk mendapatkan daftar urutan Kolakoski (karena evaluasi malas, tidak masalah bahwa daftar belum sepenuhnya dihasilkan)
• (cycle (list 1 2)) membuat daftar tanpa batas (1 2 1 2 1 2 ...)
• Zip dua daftar yang tak terbatas bersama-sama menggunakan fungsi repeat-val. Ini akan mengulangi 1atau 2dari cycledaftar satu atau dua kali tergantung pada nilai yang terkait dalam daftar Kolakoski. Hasil:((1) (2 2) (1 1) ...)
• flatten daftar itu menjadi (1 2 2 1 1 ...)
• Kami sudah mendapatkan dua istilah pertama dari (concat (list 1 2), jadi kami dua istilah droppertama dari daftar yang dihasilkan untuk menghindari duplikasi.

Stax , 12 byte

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

Jalankan dan debug itu

Ini adalah representasi ascii dari program yang sama.

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

Itu memperluas urutan x kali di mana x adalah input. Kemudian output x ^th elemen, 0-diindeks.

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

Berikut adalah solusi 12-byte bonus yang menghasilkan output sebagai aliran tanpa batas. Tekan Jalankan untuk memulai.

R, 63 byte atau 61 byte

Implementasi 1: mencetak istilah urutan ^ke- n .

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

Implementasi 2: mencetak n istilah pertama dari urutan.

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

(Perbedaannya hanya pada baris terakhir.)

Ya, ya, Anda mungkin mengeluh bahwa solusi saya tidak efisien, yang menghitung lebih banyak persyaratan daripada yang dibutuhkan, tetapi masih ...

Pembaruan: Terima kasih kepada @Giuseppe karena telah memangkas 9 byte.

Bahasa Pemrograman Shakespeare, 575 byte (tetapi cacat), atau 653 atau 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.

Dalam kategori SPL yang diperebutkan, ini akan mengalahkan entri Jo King saat ini (583 bytes), kecuali bahwa itu rusak: Pertama, itu tidak berjalan dalam versi TIO (menerapkan situs web SPL) - tetapi itu berjalan di Perl versi , jadi mungkin itu bukan cacat serius. Namun, kedua, itu tidak mencetak dua digit pertama. Jika kita membiarkan cacat itu dalam solusi Jo King, maka solusi yang rusak itu akan menjadi 553 byte, mengalahkan solusi yang rusak saya.

Solusi saya gagal pada TIO karena dua alasan: kami mencoba mengandalkan tumpukan kosong yang mengembalikan nol ketika muncul; dan kami pergi ke adegan pertama, dengan "[Enter Ford and Puck]" meskipun tidak ada yang meninggalkan panggung. Ini hanyalah peringatan dalam versi Perl. Jika saya memperbaiki kesalahan ini dan memasukkan dua digit pertama, saya mencapai 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.

Cobalah online!

Saya dapat menghasilkan urutan penuh dalam implementasi Perl menggunakan 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.

Namun, saya akan menunjukkan bahwa solusi ini cepat dibandingkan dengan banyak solusi lainnya, dan menggunakan jumlah memori logaritmik daripada menyimpan seluruh daftar. (Ini mirip dengan solusi vazt's C, yang sangat terkait dengannya.) Ini tidak ada bedanya untuk golf, tapi saya senang dengan itu. Anda dapat menghasilkan satu juta digit dalam waktu sekitar satu menit di Perl (misalnya jika Anda mengirim ke sed dan wc untuk mendapatkan jumlah digit), di mana solusi lain mungkin memberi Anda beberapa ribu digit.

Penjelasan

Kami menyimpan urutan variabel secara berurutan: Puck's stack (bawah ke atas), nilai Puck's, nilai Ford, Ford's stack (atas ke bawah). Terlepas dari nilai nol di ujungnya (dengan angka nol di sebelah kiri mungkin muncul dari tumpukan kosong), setiap nilai adalah digit yang dihasilkan selanjutnya pada generasi itu, dengan 2 ditambahkan jika generasi berikutnya perlu memiliki anak lagi dari orangtua tersebut. Ketika kita memiliki N nilai bukan nol dalam urutan, kita menghasilkan semua anak hingga dan termasuk generasi ke-N, dalam semacam traversal pohon kedalaman-pertama. Kami mencetak nilai hanya dari generasi ke-N. Ketika generasi ke-N telah sepenuhnya dihasilkan, nilai yang disimpan sebenarnya adalah nilai awal untuk generasi 2 hingga (N + 1), jadi kami menambahkan angka 2 di sebelah kiri dan mulai lagi, kali ini menghasilkan (N + 1 ) generasi ke-5.

Jadi, garis besar: Adegan X: Ketika kita sampai di sini, ini awal dari traversal baru. Keping == 0. Kami secara opsional mendorong nol itu ke tumpukan Puck, dan mengatur Puck = 2. Adegan L: Jika Ford == 0, kami telah mencapai generasi pencetakan. Jika tidak, goto V. Untuk mencetak, jika nilai dalam Puck memiliki 2 tambahan, hapus 2 dan cetak dua kali; jika tidak, cetak sekali. Adegan M: Ini adalah loop di mana kita berulang kali mengaktifkan nilai Puck dan kembali melalui urutan. Kita ulangi sampai kita mencapai akhir (Keping == 0), dalam hal ini goto X, atau kita mencapai nilai yang membutuhkan anak lain (Keping> 2), dalam hal ini kurangi 2 ekstra dan maju ke depan dalam V. Adegan V: Di sini kita maju. Jika Puck 2 atau 4, generasi berikutnya akan mengandung dua anak dari orang tua saat ini, jadi Ford + = 2. Langkah maju melalui urutan. Goto L untuk memeriksa pemutusan hubungan kerja.

axo , 13 byte

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

Cobalah online!

Penjelasan

Ini dimulai sebagai port solusi alternatif dalam jawaban Wumpus saya :

2%)[=]&=[O00.

Ini menghasilkan 18 byte. Saya akhirnya bermain golf hingga 13 byte yang Anda lihat di atas untuk lebih menyesuaikannya dengan cara kerja axo. Versi 13-byte ini kemudian menginspirasi peningkatan hingga 11 byte di Wumpus, jadi sekarang ini sebenarnya lebih dekat ke versi itu.

Seperti pada Wumpus, dalam iterasi i , bagian bawah tumpukan menampung a (i) -1 dan bagian atas memegang elemen pertama dari run ke- i , tetapi kami bekerja dengan seluruh 0 dan 1 , kecuali untuk mencetak.

[:    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)}

mencetak tanpa batas

Cobalah online!

Cobalah dengan fungsi cetak kelebihan beban yang memungkinkan Anda memilih pemisah dan jumlah elemen yang dicetak