一个循环标签系统是由两个符号的字母（我将使用一个微小的，图灵完备的计算模型{0,1}的），一个有限的，非空的循环列表的制作是由这两个符号，以及无限的词也包括那两个符号。

在每一步：

• 单词中的第一个元素被删除
• 如果是0当前产量，则跳过
• 如果是1当前产生式，则附加在该词的末尾。
• 下一生产活动。如果这是最后一个作品，请返回第一个。

当单词变为空时，系统停止。

一个例子（来自维基百科）：

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

您的任务（如果选择接受）是编写一个程序或函数，该程序或函数需要：

• 产品清单，
• 最初的单词，以及
• 一代人

并在该世代打印或返回单词。

例如，

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]

实施细节：

• 字母无所谓。只要您保持一致，就可以使用0和1，True和False，T和NIL，A和B，甚至1和0或可能想到的其他方法。所有输入和输出必须使用相同的字母，并且您必须指出要使用的内容0和要使用的内容1。

• 从理论上讲，单词的长度必须不受限制。也就是说，您可能没有对最大字长进行硬编码。如果我在具有无限内存的理想计算机上运行您的程序，则您的程序理论上必须能够使用它。（您可以忽略翻译/编译器的限制。）

• 如果给定系统在达到给定代数之前暂停，则必须返回或打印空字。

• 空产品存在，并且您必须能够处理它。如果编写完整的程序，则您的I / O也必须能够处理它。

编辑：我原本打算将生成0作为输入词本身，并将生成1作为第一步的结果。即，我原本打算让您返回前一栏。但是，由于我还不太清楚说明这一点，因此我将接受两种选择。对于每一代，您都可以在before或after列中返回该值。如果要这样做，则必须声明您正在遵循after列。您还必须在选择的哪一列中保持一致。

从现在开始（2014年10月27日），我将授予最小的代码。

GolfScript（17至19个字节，取决于输入格式和可接受的输出格式）

18个字节：

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

以表格形式输入，并以表格形式[1 1 0 0 1] [[0 1 0] [0 0 0] [1 1 1 1]] 4输出[1 0 1 0 0 0 0]。（如果可以接受，则可以是17个字节，没有最后一个字节）。`1010000

在线演示

19个字节：

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

以形式输入"11001" ["010" "000" "1111"] 4。

在线演示

解剖

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

感谢马丁布特内尔的CJam解决方案，用于产生重复和截断制作的列表的想法。

Haskell，55 53 51

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

这使用Trueas 1和Falseas 0。示例运行：

*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字节

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

这定义了一个块（最接近函数的块），该块期望输入像这样驻留在堆栈上

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

它将类似地留下0s和1在堆栈上 s。

在这里测试。将输入内容粘贴到第一行，将代码粘贴到第三行，然后附加a ~以实际评估该块。例如

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

如果输出不必具有与输入相同的形式

说明：

_@*<{\_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.";

单词的最终状态留在堆栈上。

感谢Peter Taylor让我重新审视此问题。

Mathematica，84 80 77个字符

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

例：

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

{1，0，1，0，0，0，0}

粘稠度 22

需要所有3个参数作为单独的输入。

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

接受如下参数：

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

说明：

                        : 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

蟒蛇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

漂亮的乔-基本答案。假设生产为空[[]]。

感谢@xnor，指出凌晨2点打高尔夫球是一个糟糕的决定。

还要感谢@xnor，我似乎欠了我50％的成绩。

样品：

>>> 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字节

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

看起来与刚出现在我浏览器中的弗莱的答案非常相似。（请勿复制，我郑重宣誓。）

但是，看起来好像他走了阵列路线，而我走了字符串/正则表达式路线。

展开：

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

样本输出

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

现在，观看高尔夫语言并屠杀我们俩。：D