Stavo giocando con un automa cellulare e ne ho trovato uno che aveva un comportamento interessante. Ecco come funziona:

Legge una stringa binaria da sinistra a destra, se incontra un 1seguito da 2altri valori aggiungerà 0a al risultato e continuerà a leggere. Se rileva un 0(o sono rimasti meno di 3 valori), aggiungerà il valore corrente e un 1e continuerà a leggere. Alla fine della stringa, verrà aggiunto un singolo 1al risultato.

Ecco un esempio elaborato di una generazione

01011111
^

In primo luogo incontriamo un 0così aggiungiamo 01al nostro risultato

01011111
 ^
01

Ora incontriamo un 1così aggiungiamo uno zero e saltiamo i prossimi due valori

01011111
    ^
010

1Ne incontriamo un altro, quindi facciamo lo stesso

01011111
       ^
0100

Ora abbiamo un altro 1spazio, ma non abbastanza per saltare, quindi aggiungiamo la cella corrente e un 1(in questo caso 11)

01011111
        ^
010011

Siamo alla fine, quindi aggiungiamo un singolo 1e terminiamo questa generazione

01011111
        ^
0100111

Compito

Dato input in qualsiasi formato ragionevole è necessario creare una funzione o un programma che calcola una generazione dell'automa.

Questa è una domanda di code-golf, quindi le risposte verranno classificate in byte, con un numero inferiore di byte migliori.

Implementazione di esempio

Ecco un'implementazione di esempio in Haskell (definisce una funzione d, ma il programma stampa le iterazioni indefinitamente):

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

Provalo online!

V , 26 22 21 byte

Grazie a @CowsQuack per 4 byte combinando regex! E @ ØrjanJohansen per un altro byte con alcune combinazioni di regex.

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

Provalo online!

Usa la sostituzione più volte e aggiunge un 1 alla fine. Niente di troppo elegante. Ho una versione che rimappa 1e 0in modalità insert per ottenere l'effetto desiderato, ma è un po 'più lunga.

(Versione sostitutiva multipla: provala online! )

JavaScript (ES6), 56 byte

Accetta input come una matrice di caratteri. Restituisce una stringa o il numero 1se viene fornito un array vuoto.

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

dimostrazione

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

Versione animata

Esempi di ingressi stabili: 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 byte

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]

Provalo online!

Python 2 , 89 byte

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]

Provalo online!

-4 byte grazie a Rod
-6 byte grazie a ovs
-1 byte grazie a micsthepick

Swift 3 , 147 byte

-1 grazie 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])}

Ungolfed, restituendo il valore anziché stampare:

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 byte

Sia l'input che l'output sono elenchi (grazie 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]

Provalo online!

Alcuni casi

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

Sia l'input che l'output sono stringhe (soluzione iniziale)

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'

Provalo online!

Alcuni casi

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

Spiegazione È semplicemente il golf di un metodo ricorsivo.

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

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

Provalo online!

Scala , 131 + 29 = 160 byte

Questo è all'interno di una funzione che prende la stringa acome parametro e restituisce l'output come stringa.

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"

Devo import util.control.Breaks._, quindi ho bisogno di aggiungere quei 28 byte più un avanzamento riga finale.

Provalo online!

C # (.NET Core) , 108 byte

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

Provalo online!

Input preso come stringa e una stringa viene restituita come output.