環状タグシステムは、 2シンボルアルファベットからなる小さな、チューリング完全な計算モデル（私は使用しますである{0,1}）、有限の空ではない環状リストプロダクションそれら二つのシンボルで構成され、無限語もから成りますこれらの2つのシンボル。

各ステップで：

• 単語の最初の要素が削除されます
• 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列に値を返すことができます。あなたがそうしている場合、あなたは後の列をフォローしていることを述べなければなりません。また、どの列を選択するかについても一貫性が必要です。

今から1週間で最小のコード（10/27/2014）を授与します。

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

功績マーティンBüttnerのCJamソリューション繰り返しと切り捨てによって制作のリストを生成するというアイデアについて。

ハスケル、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?(@*+}/}

これはブロック（functioNに最も近いもの）を定義します。このブロックは、入力が次のようにスタックに常駐することを想定しています。

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

同様に、0sと1sの配列をスタックに残します。

ここでテストしてください。入力を1行目に貼り付け、3行目にコードを貼り付け、~ブロックを実際に評価するために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}

Pyth 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

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

プリティジョー-基本的な答え。空のプロダクションがであると仮定します[[]]。

@xnorに感謝します。午前2時にゴルフをするのは悪い決断だと指摘してくれました。

私のスコアの50％を借りている@xnorにも感謝します。

サンプル：

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

私のブラウザにポップアップ表示されたFryの答えに不気味に似ています。（コピーはできません。厳soleに誓います。）

ただし、文字列/正規表現のルートに行っている間に、彼は配列ルートに行ったように見えます。

拡張：

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