Bir döngüsel etiket sistemi , iki sembollü bir alfabe (kullanacağım {0,1}), bu iki simgeden oluşan sonlu, boş bir döngüsel üretim listesinden ve ayrıca aşağıdakilerden oluşan sınırsız bir kelimeden oluşan küçük, Turing-complete hesaplama modelidir . bu iki sembol.

Her adımda:

• kelimedeki ilk öğe kaldırıldı
• o olsaydı 0şimdiki üretim atlanır
• Bu ise 1, mevcut üretim sonuna eklenir kelime .
• bir sonraki üretim aktif olur. Bu son üretimse, ilk prodüksiyona geri dönün.

Sözcük boş olduğunda sistem durur .

Bir örnek (Wikipedia'dan):

Productions: (010, 000, 1111)
Initial word: 11001

Generation  Production   Word (before)            Word (after)
   0           010           11001             →     1001010       
   1           000            1001010          →      001010000
   2           1111            001010000       →       01010000
   3           010              01010000       →        1010000
   4           000               1010000       →         010000000
   5           1111               010000000    →          10000000
   6           010                 10000000    →           0000000010
   7           000                  0000000010 →            000000010
   8           1111                  000000010 →             00000010
   9           010                    00000010 →              0000010

Göreviniz, kabul etmeyi seçerseniz, aşağıdakileri alan bir program veya işlev yazmaktır:

• yapımların bir listesi,
• ilk kelime ve
• bir nesil,

ve o nesilde sözcüğü yazdırır veya döndürür .

Örneğin,

cyclic_tag(
      prod=[[0,1,0],[0,0,0],[1,1,1,1]], 
      word=[1,1,0,0,1], 
      gen=4) => [1,0,1,0,0,0,0]

Uygulama ayrıntıları:

• Alfabe önemli değil. Sen kullanabilir 0ve 1, Trueve False, Tve NIL, Ave B, hatta 1ve 0, ya da her türlü başka sürece tutarlı olarak, ile gelebilir. Tüm giriş ve çıkışlar aynı alfabeyi kullanmalı 0ve ne için ve ne için kullandığınızı belirtmelisiniz 1.

• Kelimenin uzunluğu teorik olarak sınırsız olmalıdır. Yani, maksimum kelime uzunluğunu sabit kodlayamayabilirsiniz. Programınızı sonsuz miktarda belleğe sahip ideal bir bilgisayarda çalıştırırsam, programınız teorik olarak bu programı kullanabilmelidir. (Tercümanınızın / derleyicinin sınırlarını göz ardı edebilirsiniz.)

• Verilen sistem verilen jenerasyona ulaşılmadan durursa, boş sözcüğü döndürmeli veya yazdırmalısınız.

• Boş üretim var ve bunu halledebilmelisin. Tam bir program yazarsanız, G / Ç'nizin de programı kullanabilmesi gerekir.

Düzenleme : Başlangıçta nesil 0giriş kelimesinin kendisi ve nesil 1ilk adımın sonucu olması amaçlanmıştı. Yani, önceki sütunu geri vermenizi istemiştim. Ancak , bunu belirtmekte yeterince açık olmadığım için, her iki seçeneği de kabul edeceğim ; her nesil için değeri önceki veya sonraki sütuna döndürebilirsiniz . Bunu yapıyorsanız, sonraki sütunu izlediğinizi belirtmeniz gerekir . Ayrıca hangi sütunda seçtiğiniz konusunda tutarlı olmalısınız.

Bir hafta sonra en küçük kodu vereceğim (27.10.2014).

GolfScript (giriş biçimine ve kabul edilen çıkış biçimine bağlı olarak 17 ila 19 bayt)

18 bayt:

~.@*<{\1,or(@*+}/`

Formdaki girdiyi alır ve formdaki [1 1 0 0 1] [[0 1 0] [0 0 0] [1 1 1 1]] 4çıktıyı verir [1 0 1 0 0 0 0]. ( Çıktı kabul edilebilirse son olmadan 17 bayt` olabilir 1010000).

Çevrimiçi demo

19 bayt:

~.@*<{\0`or(1&@*+}/

Formda girdi alır "11001" ["010" "000" "1111"] 4.

Çevrimiçi demo

teşrih

~        # Evaluate input: stack: word productions gen
.@*<     # Produce a list of the right number of productions with suitable repetition
{        # For each of those productions:
  \      #   Bring the word to the top
  0`or   #   Ensure that we don't get an error if the word is empty
  (1&    #   Pop the first char from the word and evaluate it
  @*     #   Repeat the production that many times
  +      #   Concatenate 0 or 1 copies of the production to the rest of the word
}/       # Endforeach

Kredi Martin Büttner 'ın CJam çözümü tekrarı ve kesme tarafından yapımların listesi üretme fikri için.

Haskell, 55 53 51

(t:w)%p|t=w++p|0<1=w
x%_=x
e w=(!!).scanl(%)w.cycle

Bu kullanır Trueolarak 1ve Falsesıra 0. örnek çalıştırma:

*Main> let t=True ; f=False
*Main> e [t,f,t] [[f,f,f],[t,t,t]] 4
[False,False,False,False,False]

CJam, 31 30 28 27 24 18 bayt

{_@*<{\_0a?(@*+}/}

Bu, girdinin bu şekilde yığını üzerinde kalmasını bekleyen bir blok (bir işleve en yakın şey) tanımlar

[1 1 0 0 1] [[0 1 0] [0 0 0] [1 1 1 1]] 9

Benzer şekilde yığın üzerinde bir 0s ve 1s dizisi bırakacaktır .

Burada test edin. Girdiyi birinci satıra, kodu üçüncü satıra yapıştırın ve ~bloğu gerçekten değerlendirmek için a ekleyin . Örneğin

[1 1 0 0 1] [[0 1 0] [0 0 0] [1 1 1 1]] 9
{_@*<{\_0a?(@*+}/}~

Çıktı, girdi ile aynı forma sahip olmak zorunda değilse

Açıklama:

_@*<{\_0a?(@*+}/
_@               "Duplicate the generation and pull the productions to the top.";
  *<             "Repeat the productions N times and take the first N elements.";
    {         }/ "For each element in that list, run this block.";
     \           "Swap production and current word W.";
      _0a?       "W = (W != []) ? W : [0]. This is to ensure we can unshift an element.";
          (      "Unshift the first 0 or 1 from the word.";
           @     "Rotate the stack, pulling the production to the top.";
            *    "Repeat it 0 or 1 times.";
             +   "Append to the word.";

Kelimenin son durumu yığın üzerinde bırakılır.

Peter Taylor'a bunu tekrar yaptığım için teşekkürler.

Mathematica, 84 80 77 karakter

f[_,w_,_]=w;f[p_,{x_,y___},n_/;n>0]:=f[RotateLeft@p,Flatten@{y,p~Take~x},n-1]

Misal:

f[{{0, 1, 0}, {0, 0, 0}, {1, 1, 1, 1}}, {1, 1, 0, 0, 1}, 4]

{1, 0, 1, 0, 0, 0, 0}

Pyth 22

3 bağımsız değişkeni de ayrı girdi olarak gerektirir.

#Vvw=z+tz*@Q%NlQshz)zq

Gibi argümanlar alır:

11001
["010","000","1111"]
4

Açıklama:

                        : Implicit: z = input(); Q=eval(input())
#                       : Loop until an exception is thrown
 Vvw               )    : for N in range(eval(input()))
    =z                  : assign to z
      +tz               : the sum of the tail of z and
         *@Q%NlQ        : Q[N%len(Q)] times
                shz     : the numeric value of the first character in z
                    zq  : print z then throw exception

Python 2-61 67 91105124

c=lambda p,w,g:g*w and c(p[1:]+p[:1],w[1:]+w[0]*p[0],g-1)or w

Güzel Joe-Temel cevap. Boş üretim olduğunu varsayar [[]].

@Xnor sayesinde, sabah 2'de golf oynamanın kötü bir karar olduğunu belirtmek için.

Puanımın% 50'sine borçlu olduğum @xnor'a ek olarak teşekkür ederim.

Örneklem:

>>> c([[0,1,0],[0,0,0],[1,1,1,1]],[1,1,0,0,1],4)
[1, 0, 1, 0, 0, 0, 0]

Javascript ES6 - 88 bayt

f=(p,w,g,n)=>g?w.replace(/(.)(.*)/,(_,a,b)=>f(p,a*1?b+p[(n=n||0)%p.length]:b,g-1,n+1)):w

Tarayıcımda ortaya çıkan Fry'ın cevabına ürkütücü bir şekilde benziyor. (Kopyalama yok, ciddiyetle yemin ederim.)

Ben dize / regex yol gitti, ancak o dizi yol gitti görünüyordu.

Expanded:

f = (p,w,g,n) =>
    g ?
        w.replace( /(.)(.*)/, (_,a,b) =>
            f( p, a*1 ? b + p[(n=n||0)%p.length] : b, g-1, n+1 )
        )
    :
        w

Örnek Çıktı

f(['010','000','1111'],'11001',4)
"1010000"

Şimdi golf dillerinin gelip ikimize katliamını izleyin. : D