Estaba jugando con un autómata celular y encontré uno que tenía un comportamiento interesante. Así es como funciona:

Lee una cadena binaria de izquierda a derecha, si encuentra un 1seguido por 2otros valores, agregará un 0al resultado y continuará leyendo. Si encuentra a 0(o quedan menos de 3 valores) agregará el valor actual y a 1y continuará leyendo. Al final de la cadena, agregará un solo 1al resultado.

Aquí hay un ejemplo resuelto de una generación

01011111
^

Primero nos encontramos con un, 0así que agregamos 01nuestro resultado

01011111
 ^
01

Ahora nos encontramos con un, 1así que agregamos un cero y omitimos los siguientes dos valores

01011111
    ^
010

Nos encontramos con otro, 1así que hacemos lo mismo.

01011111
       ^
0100

Ahora tenemos otro 1espacio pero no suficiente para saltar, así que agregamos la celda actual y un 1(en este caso 11)

01011111
        ^
010011

Estamos al final, así que agregamos un single 1y terminamos esta generación

01011111
        ^
0100111

Tarea

Dada la entrada en cualquier formato razonable, debe crear una función o programa que calcule una generación del autómata.

Esta es una pregunta de código de golf , por lo que las respuestas se puntuarán en bytes, con menos bytes mejor.

Implementación de muestra

Aquí hay una implementación de muestra en Haskell (define una función d, pero el programa imprime una iteración indefinidamente):

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

Pruébalo en línea!

V , 26 22 21 bytes

¡Gracias a @CowsQuack por 4 bytes combinando expresiones regulares! Y @ ØrjanJohansen para otro byte con algunas combinaciones de expresiones regulares.

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

Pruébalo en línea!

Utiliza sustituto varias veces y agrega un 1 al final. Nada muy elegante. Tengo una versión que se reasigna 1y 0en modo de inserción para obtener el efecto deseado, pero es bastante más largo.

(Versión de reemplazo múltiple: ¡ Pruébelo en línea! )

JavaScript (ES6), 56 bytes

Toma entrada como una matriz de caracteres. Devuelve una cadena o el número 1si se le da una matriz vacía.

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

Manifestación

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']))

Versión animada

Ejemplos de entradas estables: 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 bytes

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]

Pruébalo en línea!

Python 2 , 89 bytes

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]

Pruébalo en línea!

-4 bytes gracias a Rod
-6 bytes gracias a ovs
-1 byte gracias a micsthepick

Swift 3 , 147 bytes

-1 gracias a @ 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])}

Sin golf, devolviendo el valor en lugar de imprimir:

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 bytes

Tanto la entrada como la salida son listas (gracias a Erik the Outgolfer)

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]

Pruébalo en línea!

Algunos casos

[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 , 85 bytes

Tanto la entrada como la salida son cadenas (solución inicial)

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'

Pruébalo en línea!

Algunos casos

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

Explicación Es simplemente un golf de un método recursivo.

Perl 5 , 62 + 2 ( -F) = 64 bytes

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

Pruébalo en línea!

Scala , 131 + 29 = 160 bytes

Esto está dentro de una función que toma la cadena acomo parámetro y devuelve la salida como una cadena.

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"

Tengo que hacerlo import util.control.Breaks._, así que necesito agregar esos 28 bytes más un avance de línea final.

Pruébalo en línea!

C # (.NET Core) , 108 bytes

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

Pruébalo en línea!

La entrada se toma como una cadena y una cadena se devuelve como salida.