我在玩蜂窝自动机，发现其中的一种有趣的行为。运作方式如下：

它从左到右读取一个二进制字符串，如果遇到一个1后跟2其他值的二进制字符串，它将0在结果后面追加一个并继续读取。如果遇到a 0（或剩余少于3个值），它将附加当前值和a 1并继续读取。在字符串的末尾，它将1在结果后附加一个。

这是一代人的例子

01011111
^

我们首先遇到a，0因此我们将其追加01到结果中

01011111
 ^
01

现在我们遇到一个，1所以我们附加一个零并跳过接下来的两个值

01011111
    ^
010

我们遇到另一个，1所以我们也一样

01011111
       ^
0100

现在，我们还有另一个1但没有足够的空间可以跳转，因此我们附加了当前单元格和一个1（在这种情况下11）

01011111
        ^
010011

我们已经结束了，所以我们追加一个1并终止这一代

01011111
        ^
0100111

任务

给定任何合理格式的输入，您必须创建一个计算一代自动机的函数或程序。

这是一个代码问题，因此答案将以字节计分，而字节越少越好。

实施范例

这是Haskell中的示例实现（定义了一个函数d，但是程序无限期地打印迭代）：

d('1':_:_:x) = "0" ++ d x
d(a:x) = a:'1':d x
d x = "1"
r x = x:map d(r x)

在线尝试！

V，26 22 21字节

感谢@CowsQuack通过结合正则表达式获得4个字节！然后@ØrjanJohansen使用一些正则表达式组合来获取另一个字节。

Ó1../3
Ó./&1
Ó31/0
A1

在线尝试！

多次使用替代项，并在末尾附加1。没什么好看的。我有一个可以重新映射1并0处于插入模式的版本，以获得所需的效果，但是要长很多。

（多个替换版本：在线试用！）

JavaScript（ES6），56个字节

将输入作为字符数组。返回字符串，1如果为空数组，则返回数字。

f=([v,...a])=>v?(+v&&a[1]?a.splice(0,2)&&'0':v+1)+f(a):1

演示版

f=([v,...a])=>v?(+v&&a[1]?a.splice(0,2)&&'0':v+1)+f(a):1

console.log(f([...'01011111']))
console.log(f([...'10']))

动画版

稳定输入的示例：0101，010011111

f=([v,...a])=>v?(+v&&a[1]?a.splice(0,2)&&'0':v+1)+f(a):1

s = '1';
setInterval(_=>o.innerHTML=s=''+f([...s]), 200)

<input oninput="s=this.value" value="1" />
<pre id=o style="font-size:32px"></pre>

Python 2，88字节

I,r=input(),[]
while I:a=I[0]and len(I)>2;b=a<1;r+=[I[0]]*b+[+b];I=I[a*2+1:]
print r+[1]

在线尝试！

Python 2，89个字节

x=input()
y=0
k=[]
while x[y:]:v=1-x[y]*(y<len(x)-2);k+=[x[y]]*v+[v];y+=3-2*v
print k+[1]

在线尝试！

-4字节归功于Rod
-6字节归功于ovs
-1字节归功于micsthepick

迅捷3 3，147个字节

-1感谢@ Mr.Xcoder

func g(i:[Int]){var r=[Int]();var s=ArraySlice(i);while let e=s.popFirst(){if 0<e&&2<s.count{r+=[0];s=s.dropFirst(2)}else{r+=[e,1]}};print(r+[1])}

取消高尔夫，返回值而不是打印：

func iterate(state: [Int]) -> [Int] {
    var result = [Int]()

    var inputSlice = ArraySlice(state)

    while let element = inputSlice.popFirst() {
        if 0 < element && 2 < inputSlice.count { 
            result += [0]
            inputSlice = inputSlice.dropFirst(2)
        }
        else {
            result += [element, 1]
        }

        //debugPrint(result.map(String.init).joined(separator: ""))
    }

    return result + [1]
}

Python 2，81个字节

输入和输出都是列表（感谢Outgolfer的Erik）

def f(Z):return Z and((1>Z[0]or 3>len(Z))and[Z[0],1]+f(Z[1:])or[0]+f(Z[3:]))or[1]

在线尝试！

一些案例

[0,1,0,1,1,1,1,1] --> [0,1,0,0,1,1,1]
[0] ----------------> [0,1,1]
[1] ----------------> [1,1,1]
[] -----------------> [1]
[0,1] --------------> [0,1,1,1,1]
[1,0] --------------> [1,1,0,1,1]

Python 2 2，85个字节

输入和输出都是字符串（初始解决方案）

def f(Z):return Z and(('0'==Z[0]or 3>len(Z))and Z[0]+'1'+f(Z[1:])or'0'+f(Z[3:]))or'1'

在线尝试！

一些案例

'01011111'--> 0100111
'0'---------> 011
'1'---------> 111
''----------> 1
'01'--------> 01111
'10'--------> 11011

解说这是simplily递归方法的一个高尔夫球场。

Perl 5，62 + 2（-F）= 64字节

$r.=$F[$i]&&$i+2<@F&&($i+=2)?0:"$F[$i]1";++$i<@F&&redo;say$r.1

在线尝试！

Scala，131 + 29 = 160字节

这是在函数内部，该函数将字符串a作为参数并将输出作为字符串返回。

var s=""
var k=0
for(c<-0 to a.length-1)breakable{if(k>0){k-=1
break}
if(a(c)==49&c<a.length-3){s+="0"
k+=2}else s+=a(c)+"1"}
s+"1"

我确实必须import util.control.Breaks._这样做，因此我需要添加这28个字节以及尾随的换行符。

在线尝试！

C＃（.NET Core），108字节

n=>{var t="";for(int i=0,b=n.Length;i<b;){if(n[i]>'0'&i+2<b){t+="0";i+=3;}else t+=n[i++]+"1";}return t+"1";}

在线尝试！

输入作为字符串，返回字符串作为输出。