Bu, G / Ç gereksinimlerini en son standartlarımıza göre ayarlamak için eski bir mücadelenin tekrarıdır . Bu, daha fazla dilin bu popüler dizi hakkında bir mücadeleye katılmasına izin vermek amacıyla yapılır. Bkz bu meta yazı Repost bir tartışma için.

Kolakoski dizisi OEIS dizisi olma onuruna sahip eğlenceli bir özüne dizisi olan A000002 (ve anlamak ve A000001 göre uygulanması daha kolaydır). Dizisi ile başlar , 1 , sadece aşağıdaki kısımları kapsamaktadır 1 s ve 2 s ve sekans elemanının bir (n) uzunluğunu tanımlamaktadır n koşmak inci 1 s veya 2 sırayla s. Bu benzersiz olması sırasını tanımlar (altındaki koşuların görselleştirilmesiyle):

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

Göreviniz elbette bu sırayı uygulamaktır. Bunu yapmak için üç formattan birini seçebilirsiniz:

1. Bir giriş al , n ve çıkış n dizisinin süresi inci N başlar birinden 0 ya da 1 .
2. Bir giriş al , n ve çıkış koşulları kadar ve n dizisinin süresi inci N başlar birinden 0 ya da 1 (yani, ya baskı ilk N veya birinci n + 1 anlamında).
3. Süresiz diziden çıkış değerleri.

İkinci ve üçüncü durumda, makul herhangi bir makul liste biçimini seçebilirsiniz. Elementler arasında bir ayırıcı yoksa sorun değil, çünkü bunlar tanımı gereği her zaman bir rakamdır.

Üçüncü durumda, gönderiminiz bir işlevse, sınırsız bir listeyi veya bir üreticiyi onları destekleyen dillerde de döndürebilirsiniz.

Bir program veya bir işlev yazabilir ve standart girdi alma ve çıktı alma yöntemlerimizden herhangi birini kullanabilirsiniz . Bu boşlukların varsayılan olarak yasak olduğunu unutmayın .

Bu kod-golf , yani en kısa geçerli cevap - bayt olarak ölçülen - kazanır.

Jöle , 7 bayt

2Rṁxṁµ¡

Bu, ilk n terimini yazan tam bir programdır .

Çevrimiçi deneyin!

Nasıl çalışır

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

Örnek çalışma

Let n = 5 .

Zincirin ilk çalıştırılması uzunluğu 5'e , ardından her bir elemente 5 kez ulaşmak için periyodik olarak 1, 2 tekrar eder ve sonuçta uzunluğu 5'e keser .

  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

Bu, 5 uzunluğunun bir listesini verir . İlk eleman, Kolakoski dizisinin ilk elemanıdır.

Zincir tekrarlarının ikinci çağırma 1, 2 siklik uzunluğu ulaşmak için 5 daha sonra tekrar, k ^inci elemanı j burada, saat j olan k ^inci önceki liste elemanı, ve son olarak uzunluğuna sonucu keser 5 .

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

   1 2 1 2 1

Bu, başka bir uzunluk 5 listesi verir . İlk iki element, Kolakoski sekansının ilk iki elementidir.

Süreç, üç tekrar daha devam ediyor.

   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

Bunlar Kolakoski sekansının ilk beş elementidir.

Python 2 , 51 bayt

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

Süresiz yazdırır. Listeyi lyinelendiği gibi oluşturur . Her giriş xiçin l, hangisinin geçerli son öğenin karşısında olduğu veya hangisinin xkopyasını ekler .12

Asıl zorluk, ilk öz-referans parçasını ele almaktır [1,2,2]. Bu kod yalnızca başlangıç ​​harfini yazdırır 1,2ve oradan devam eder. Ekstra baskı maliyeti 12 bayttır. Onsuz:

39 bayt , ilk iki girişi eksik:

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

Diğer bir yaklaşım, ilk iki girişi özel olarak başlatmaktır. Biz başlatmak lolarak [0,0,2]ilk iki giriş ekleme neden kalmamanız ama print x or nonlara olarak basılacak yapar n.

51 bayt

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

Diğer bir düzeltme, l=[1]değişimleri elle başlatmak nve yazdırmayı düzeltmektir:

51 bayt

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

Olmadan, (l==[1,1])+basılan diziler dışındaki her şey 1,1,2yerine çalışır 1,2,2. Bu ikinci adımda olduğumuzu tanımanın daha iyi bir yolu olmalı.

Ve başka bir garip düzeltme, ayrıca bir şekilde aynı byte sayısı:

51 bayt

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

Wumpus , 13 11 bayt

=[=)O?=!00.

Çevrimiçi deneyin!

Diziyi ayırıcılar olmadan süresiz olarak yazdırır.

Bunun ne kadar kısa olduğuna gerçekten şaşırdım.

açıklama

Temel fikir, diziyi yığında tutmak ve art arda başka bir işlem oluşturmak için en alttaki öğeyi kullanmak ve ardından yazdırmaktır. Yığını burada bir sıra olarak kötüye kullanıyoruz. Birkaç byte'ı tasarruf ederek 0ve 1(yalnızca çıktı için artırma) yerine 1ve 2böylece 1artırabiliriz , çünkü bu şekilde yığını a ile açıkça başlatmamız gerekmez ve iki değer arasında geçiş yapmak için mantıksal olumsuzlamayı kullanabiliriz.

     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 bayt

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

İlk n değerini verir. Giriş için "çıkış değişkeni" kullanır ve " .giriş değişkenine" çıkar ?. Çevrimiçi deneyin!

açıklama

Bunun nasıl açıklayıcı olduğunun farkındayım: program temelde çıktı listesinin ve girdi ile ilişkisinin üst düzey bir açıklamasıdır.

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

Çünkü {1|2}ᵐlexicographic sırayla listelerini dener, çıkış 1'den başlayacaktır.

Kabuğu , 10 bayt

Ṡωo↑⁰`Ṙ¢ḣ2

İlk n değerini döndürür . Çevrimiçi deneyin!

açıklama

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

Giriş 20 için işlem şöyle devam eder:

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

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

Sınırlayıcı olmadan süresiz olarak yazdırır.

@Neil'den gelen dolaylı bir ipucundan sonra -3 bayt . @MartinEnder
sayesinde -5 bayt .
Java 8'i Java 10'a dönüştüren -3 bayt.

Açıklama:

Çevrimiçi deneyin (TIO'da 60 saniye sonra zaman aşımına uğradı).

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`

Jöle , 10 bayt

’߀+\<¹SḂ‘

N değerini döndürür ^inci dönem.

Çevrimiçi deneyin!

Nasıl çalışır

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

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

Çevrimiçi deneyin!

Ørjan Johansen, ön eki zorlamak için reddedilemez bir desen kullanarak 7 bayt kurtardı.

Gol> <> , 8 7 bayt

:{:PnKz

Çevrimiçi deneyin!

açıklama

Bu Wumpus cevabımın bir limanı . Gol> <> temel olarak Wumpus cevabını iletmek için gerekli tüm özelliklere sahip bir dildir (özellikle yığının altındaki "sıfır", "yinelenen" uygulanmış "pop, bas, bas" ve bir yığın dönüş komutu) :

• Toroidal bir ızgaraya sahiptir, yani en 00.başa geri dönmek için açık bir şekilde ihtiyacımız yoktur .
• It has Kyerini alabilecek, "pop N, ardından bir sonraki eleman N kez yinelenen" olan ?=başka bir bayt tasarruf.

Böylece Wumpus'tan Gol'e <>> eşleşme olur:

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

Shakespeare Programlama Dili , 594 583 572 bayt

-10 bayt için Ed Wynn'e teşekkürler!

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

Çevrimiçi deneyin!

Bu, yorumlarda bağlantı kurduğu 828 baytlık çözümden başlayarak ve oradan küçük bir çıldırmaya başlayan Ed Wynn’in ungolfed çözümünün golf versiyonudur .

Açıklama:

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

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

Çevrimiçi deneyin!

Martin Ender'in Wumpus cevabının limanı . Ne yazık ki, ><>bir artım veya bir invert komutuna sahip değil, yığının altında 0s şeklinde de bulunmuyor, bu yüzden bu işlem biraz daha uzun sürüyor.

JavaScript, 67 66 60 58 52 51 50 bayt

Beynimi olması gerekenden daha fazla kaşındırdı! n0 indeksli th terimini yeniden başlatır .

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

Kaşıntılı beynimi çizdiğim için 5 + 1 bayt kurtarıldı !

Dene

Aşağıdaki kod parçacığı ilk 50 terimi gösterecektir.

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>

açıklama

Bu, bazı değişkenleri fonksiyonumuzun kapsamı dışında ilan edebileceğimiz, onları fonksiyonun içinde değiştirebileceğimiz ve yine de fonksiyonun sonraki çağrılarında tekrar kullanabileceğimiz nadir durumlardan biridir.

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 ve 3), 65 60 bayt

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

İade n girişi inci, 0-endekslendi.

Alternatif (65 bayt):

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

Haskell , 48 bayt

Nimi sayesinde -1 bayt. Lynn sayesinde -2 bayt.

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

Çevrimiçi deneyin!

Her elemanı mod 2 + 1 kez tekrar edin.

brainfuck , 61 bayt

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

Çevrimiçi deneyin!

Sayıları süresiz olarak char kodları olarak yazdırır. Netlik açısından, işte rakamlarla basılan bir sürüm (ilk iki öğe hariç, doğrulaması kolay).

Nasıl çalışır:

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

Grimy sayesinde 3 bayt kurtarıldı

İlk n maddeyi yazdırır .

Δ2LÞsÅΓI∍

Çevrimiçi deneyin!

açıklama

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

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

Çevrimiçi deneyin! veya bir yineleme sınırı ile

açıklama

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

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

Çevrimiçi deneyin!

J , 12 bayt

Tek argüman fonksiyonu alarak n ve birinci üretim n terimleri. Çevrimiçi deneyin!

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

Sadece sprucing benim Eski soruya eski cevabımı .

I.eğer ki, sayılar dizisi alır ve endeks bir listesini tükürür bir fiildir k dizide oyunu bırakanların öğedir n , o zaman endeks k görünür n defa. İlk tohumdan Kolakowski dizisini yeniden başlatmak için kullanacağız. Her adım aşağıdaki gibi ilerleyecektir:

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) 

Bu işlemi ( 1+2|I.), 10'dan başlayarak tekrar tekrar yaparsak , şöyle görünür:

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

Her seferinde daha doğru terimleri nasıl aldığımızı ve bir süre sonra ilk n terimlerinin sabit olduğunu fark edin. Yerleşmesi gereken yinelemelerin sayısını tam olarak tarif etmek zordur, ancak n'de kabaca logaritmik görünmektedir , bu yüzden n kere çalıştırırsak ( ^:]) iyi olmalı. (Daha fazla bilgi için bu diğer OEIS sekanslarına göz atın: üretim uzunlukları , kısmi toplamlar .)

Bunu yaptıktan sonra, tek yapmamız gereken ilk n terimini kullanmak $. $vHerhangi bir fiilin yapılışı vbir kanca örneğidir ve onu nargüman olarak veren çalıştırılır n $ (v n).

Burada zaman ve mekân çok daha az savurgan eski 13 bayt sürümü: ($1+2|I.)^:_~. Her adımda girişi keser, böylece doğrusal olarak birçok kez yerine, yerleşmek için tam olarak gerektiği kadar çalışabiliriz.

Fueue , 30 bayt

Fueue, çalışan programın ve verilerinin her ikisinin de aynı sırada olduğu, yürütmenin kuyruğun etrafında döndüğü ve programlamanın, herhangi bir şeyin yanlış zamanda çalışmasını engellemek için çok fazla senkronizasyon gerektiren bir sıra tabanlı esolang olduğunu.

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

Çevrimiçi deneyin!

Yukarıdakiler, kontrol kodu olarak bitmeyen bir rakam listesi yazdırır. 34 bayt için gerçek basamakları yazdırabilir:

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

Çevrimiçi deneyin!

Açıklamanın geri kalanı ikinci versiyonu kullanıyor.

Fueue öğelerinin özeti

Fueue kuyruğu aşağıdaki unsurları içerebilir:

• Unicode kod noktasını yürütüldüğü zaman basan Integers,
• Köşeli parantez, )işlev deblock yapmıyorsa , merhametle etkin olmayan (sadece sıranın sonuna kadar hareket eden) alt program bloklarını sınırlandırır. onları ve
• Tek karakterli fonksiyonlar, eğer doğru argüman türlerini takip ederlerse yürütülürler ve aksi halde aktif olmazlar.
  • Bu programda kullanılan tek işlevler ~(takip eden iki öğeyi takas et), :(sonraki öğeyi kopyala) ve )(bloktan sonraki blokaj).

Üst düzey genel bakış

Programın ana döngüsü sırasında, sıra aşağıdakilerden oluşur:

• yinelenecek basamakları temsil eden bir blok zinciri;
  • Bir rakam, 1 veya 2 blok ile temsil edilir [49]ve [50:]sırası ile,.
• Rakam bloklarını geçen ve ard arda gelen 1 ve 2'leri yerleştiren, sonraları deblok yapan kendi kendini kopyalayan bir ana döngü bölümü.
  • Bir deblokeli basamak bloğu kendi basamağını d yazdırır ve ardından aşağıdaki bloğun d kopyasını oluşturur , böylece açıkladığı çalışma için rakamları oluşturur.

İlk 10 komutun düşük seviye izi

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

Tam bir ana döngü yinelemenin adım adım

İsteğe bağlı boşluklar, komutları ayırmak için eklenmiş.

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

Döngü 1: 49yazdırır 1. )etkin değil, ana döngü bloğu ile bir araya getirilmeyi bekliyor. 50yazdırır 2. :Ana döngü bloğunu çoğaltır (kendi kendine çoğaltma için bir kopyaya ihtiyaç duyar.)

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

Döngü 2: )ilk ana döngü bloğunun kilidini açar ve bir sonraki döngüyü çalıştırmaya başlar.

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

Döngü 3: [50:]zincirde üretilen ilk basamağı temsil eder, 2henüz blokajı kaldırılmaz. Aşağıdaki ), sonunda ana döngünün geri kalanı onu geçtikten sonra gerçekleştirecektir. ~)~:~tek kullanımlık gecikmeli bir golf (takas ve kopya kullanarak) ~)~~. [[49]:~))~:~~]etkin değil. ~aşağıdaki ana döngü bloğunu [50:]rakam bloğundan geçiyor .

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

Döngü 4: )hala bekler ~)~üretir ~), ~takaslarını [[49]:~))~:~~]geçmiş [50:]sayı bloklarında.

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

Döngü 5: ~takasları )geçmiş [50:]sayı bloklarında.

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

Döngü 6: Birincisi )şimdi [50:]rakam bloğunun )kilidini kaldırır, bir sonraki ise alt programın kilidini kaldırır [[49]:~))~:~~].

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

Döngü 7: 50yazdırır 2, :sadece üretilen [49]sayı bloğunu çoğaltır, iki 1saniyelik bir çalışma yaratır . :~))~:~bir tek-çevrim gecikmesidir ~~))~:. ~kalan ana döngü bloğunu birinciden sonra değiştirir [49].

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

Döngü 8: ~~))bir devir gecikmesidir )~). o anda traversed geçmiş ~değiştirir .:[49]

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

Döngü 9: geçmişe ~gider . ana döngü bloğunu çoğaltır.)[49]:

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

Döngü 10: Birincisi az önce )geçen [49]rakam bloğunu bloke eder, ikincisi bir )sonrakini geçmek için ana döngüyü yeniden başlatır (yukarıda sıranın başında gösterilir).

x86, 41 37 35 33 28 bayt

Farklı "x86" yönergeleriyle uğraşırken çok eğlenmiştim, çünkü bu benim ilk "önemsiz" x86 cevabım. Aslında önce x86-64'ü öğrendim ve programımı 32-bit'e dönüştürerek birçok baytı kurtardım.

OEIS'den kullandığım algoritmanın değerleri bir diziye ittiğini ve x86 için uygun hale getirdiğini ve değerleri yığında sakladığını gösteriyor (MIPS'nin yığın yönergeleri olmadığını unutmayın).

Şu anda program, Ngiriş olarak değerleri alır ecxve adrese bir adres döndürür.ebp dizideki nth değerini temsil eden nth elemanının bulunduğu bir dizinin . Yığına geri döndüğümü ve fazladan değerleri hesaplamanın geçerli olduğunu kabul ediyorum (yine de dizinin ötesinde neyin çöp olduğunu düşünürüz).

Değişiklikler

• Her yineleme x = 2 - n%2ile hesaplama yaparak -4 bytexor

• Döngü yerine do-while kullanarak -2 bayt.

• Kullanarak 1, 2, 2 başlangıç ​​değerlerini iterek -2 bayt eax

• -5 bayt naçıkça depolamıyor ve döngü Nzamanları çalıştırarak

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

@Ceilingcat sayesinde -9 bayt

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

Çevrimiçi deneyin!

Dizinin süresiz değerlerini üretir (zorlamadan seçenek 3)

Perl 5 , 36 bayt

Klasik TPR (0,3) çözümünde hala önemsiz bir değişiklik:

Dan serisini çıktılar 0içinn

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

Çevrimiçi deneyin!

Javascript ES6 - 71 70 68 bayt

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

Neil sayesinde 1 bit kurtarıldı

Hatamı düzelttiği için Shaggy'ye , ayrıca 1 bit tasarruf ettiğim için tanklar .

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>

Elma , 89 bayt

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

KArgüman almayan ve Kolakoski dizisini sonsuz bir liste olarak döndüren bir işlev tanımlar . Çevrimiçi deneyin!

Bu yaklaşım, tamamen insanın Haskell'in cevabından ilham aldı . Benim asıl yaklaşım uzundu ve muhtemelen O (^ n 2) idi. : ^ P

Ungolfed

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

İade listesi ile başlar (1 2). Bundan sonra, geri kalanını üretmek için (içeriden dışarıya okuma):

• Tekrar (kolakoski)tekrar Kolakoski sıra listesini almak için arayın (tembel değerlendirme nedeniyle listenin henüz tam olarak oluşturulmamış olması önemli değildir)
• (cycle (list 1 2)) sonsuz bir liste oluşturur (1 2 1 2 1 2 ...)
• Fonksiyonu kullanarak iki sonsuz listeyi birlikte sıkıştırın repeat-val. Bu tekrar edecektir 1ya 2den cyclelisteden bir veya iki kez Kolakoski listesinde ilişkili değerine bağlı olarak. Sonuç:((1) (2 2) (1 1) ...)
• flatten bu liste (1 2 2 1 1 ...)
• Zaten ilk iki terimi aldık (concat (list 1 2), bu yüzden dropçoğaltmayı önlemek için oluşturulan listedeki ilk iki biziz .

Stax , 12 bayt

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

Koş ve hata ayıkla

Bu aynı programın ascii temsilidir.

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

X'in girdi olduğu x dizisini genişletir. Daha sonra 0 indeksli x ^inci elemanı çıkarır.

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

İşte sonsuz bir akış olarak çıktı üreten bonus 12 baytlık bir çözüm. Başlamak için Çalıştır'a basın.

R, 63 bayt veya 61 bayt

Uygulama 1: yazdırır n ^inci dizisinin terimi.

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

Uygulama 2: dizinin ilk n terimini yazdırır .

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

(Fark sadece son satırda.)

Evet, evet, çözümümün verimsiz olduğundan, gerçekten gerekenden daha fazla terim hesapladığından şikayet edebilirsiniz, ama yine de ...

Güncelleme: 9 byte tıraş için @ Giuseppe teşekkürler .

Shakespeare Programlama Dili, 575 bayt (ancak hatalı) veya 653 veya 623 bayt

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

En ateşli SPL kategorisinde bu, Jo King'in şu anki girişini (583 bayt) arızalı olması dışında yenecektir: Birincisi, TIO sürümünde (SPL web sitesini uygulayarak) çalışmaz - ancak Perl'de çalışır versiyon , belki de bu ciddi bir kusur değildir. İkincisi, ilk iki basamağı yazdırmıyor. Jo King'in çözümünde bu kusura izin vermiş olsaydık, bu kusurlu çözüm benim kusurlu çözümümü yenerek 553 bayt olurdu.

Çözümüm TIO'da iki nedenden ötürü başarısız oluyor: Açıldığında sıfıra dönen boş bir yığına güvenmeye çalışıyoruz; Kimse sahneden ayrılmasa da ilk sahneye "[Enter Ford and Puck]" ile girdik. Bunlar sadece Perl versiyonundaki uyarılar. Bu hataları düzeltmek ise ve ilk iki basamağı koymak, ben 653 bayt ulaşmak:

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

Çevrimiçi deneyin!

Perl uygulamasında tam diziyi 623 bayt kullanarak oluşturabilirim:

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

Ancak, bu çözümün diğer birçok çözümle karşılaştırıldığında hızlı olduğunu ve tüm listeyi saklamak yerine logaritmik miktarda bellek kullandığını belirtmek isterim . (Bu vazotun uzaktan bağlantılı olduğu Cv çözümüne benziyor.) Bu golf için bir fark yaratmıyor, ama bundan çok memnun kaldım. Diğer çözümün size birkaç bin basamak verebileceği Perl'de bir dakika içinde bir milyon rakam üretebilirsiniz (örneğin, sed ve wc rakamını almak için boru çekerseniz).

açıklama

Sırayla değişkenler dizisini depolarız: Puck yığını (aşağıdan yukarıya), Puck değeri, Ford'un değeri, Ford'un yığını (yukarıdan aşağıya). Uçlardaki sıfır değerlerin dışında (soldaki sıfır, belki boş bir yığın açmasıyla birlikte), her bir değer, gelecek neslin başka bir çocuğa sahip olması gerekiyorsa, bu neslin yanında üretilen hanedir. Dizide N sıfır olmayan değerlere sahip olduğumuzda, N'inci nesile kadar olan ve dahil tüm çocukları bir tür derinlemesine ilk ağaç geçişinde oluştururuz. Değerleri yalnızca N'inci nesilden basıyoruz. N'inci nesil tamamen üretildiğinde, kaydedilen değerler aslında 2 ila (N + 1) nesiller için başlangıç ​​değerleridir, bu yüzden sola 2 ekleriz ve yeniden başlarız, bu sefer (N + 1'i oluşturur. )-nesil.

Öyleyse, bir taslak: Sahne X: Buraya ulaştığımızda, bu yeni bir geçişin başlangıcı. Puck == 0. İsteğe bağlı olarak bu sıfırı Puck'ın yığınının üzerine itip Puck = 2 olarak ayarlıyoruz. Sahne L: Eğer Ford == 0 ise, baskı nesline ulaştık. Olmazsa, V. V.'ye geçin. Baskı için, Puck'taki değer 2 eklendiyse, 2'yi kaldırın ve iki kez yazdırın; değilse, bir kez yazdırın. Sahne M: Bu, Puck'ın değerini tekrar tekrar değiştirip dizilim boyunca geri döndüğümüz bir döngüdür. Sonuna ulaşana kadar tekrar ediyoruz (Puck == 0), bu durumda X'e gidersek, ya da başka bir çocuğa ihtiyaç duyan bir değere ulaşırız (Puck> 2), bu durumda fazladan 2'yi çıkarır ve V'de ilerler. V: İşte ileri gidiyoruz. Puck 2 veya 4 ise, yeni nesil geçerli ebeveynden iki çocuk içerecek, yani Ford + = 2. Sıralamada ileri doğru adım atın. Sonlandırmayı kontrol etmek için L konumuna gidin.

axo , 13 bayt

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

Çevrimiçi deneyin!

açıklama

Bu Wumpus cevabımda alternatif bir çözüm limanı olarak başladı :

2%)[=]&=[O00.

Bu 18 bayt ile sonuçlandı. Axo'nun çalışma biçimine daha fazla ayarlamak için yukarıda gördüğünüz 13 bayta kadar golf oynadım. Bu 13 baytlık sürüm daha sonra Wumpus'taki 11 bayta varan oranda düzelme sağladı, bu yüzden şimdi aslında bu sürüme daha yakın.

Wumpus olduğu gibi, yineleme ı , istifin alt tutan bir (i) -1 üst ilk elemanı tutan i çalıştırmak inci, ama çalışıyoruz 0 ve 1 baskı hariç boyunca.

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

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

süresiz yazdırır

Çevrimiçi deneyin!

Ayırıcı seçmenize ve yazdırılan öğe sayısını seçmenize izin veren aşırı yüklenmiş bir yazdırma işleviyle deneyin