Gli automi cellulari simili alla vita sono automi cellulari simili al Gioco della vita di Conway, in quanto operano su una griglia quadrata (teoricamente) infinitamente grande, in cui ogni cellula ha esattamente 8 vicini ed è uno dei 2 stati, ovvero vivo e morto .

Tuttavia, queste versioni simil-simili sono diverse in modo cruciale: le regole per una determinata cellula prendono vita e le regole per una determinata cellula sopravvivono alla generazione successiva.

Ad esempio, il classico Game of Life usa la regola B3/S23, il che significa che ci vogliono 3 cellule vive per farne nascere una nuova e 2 o 3 vicini viventi per sopravvivere. Per questa sfida, supponiamo che i vicini non si includano, quindi ogni cella ha esattamente 8 vicini.

Il tuo compito è, data una configurazione iniziale, una regola di nascita, una regola di sopravvivenza e un numero intero positivo (il numero di generazioni da eseguire), simulare l'automa Life-like usando quelle regole per il numero di generazioni indicato nel codice più breve possibile . La configurazione iniziale sarà una matrice quadrata / matrice bidimensionale o una stringa multilinea, è possibile scegliere. Gli altri possono essere forniti in qualsiasi formato e metodo ragionevoli.

Ad esempio, se la regola della nascita era 12345678(qualsiasi vicino vivente), la regola della sopravvivenza era 2357e la configurazione iniziale era

0 0 0 0 0
0 0 0 0 0
0 0 1 0 0
0 0 0 0 0
0 0 0 0 0

le prossime due generazioni sarebbero

Generation 1:           Generation 2:

0 0 0 0 0               1 1 1 1 1
0 1 1 1 0               1 1 0 1 1
0 1 0 1 0               1 0 1 0 1
0 1 1 1 0               1 1 0 1 1
0 0 0 0 0               1 1 1 1 1

Se il numero di generazioni fornite fosse 10, l'output sarebbe qualcosa sulla falsariga di

0 1 1 1 0
1 1 1 1 1
1 1 1 1 1
1 1 1 1 1
0 1 1 1 0

Non è necessario gestire i cambiamenti che avvengono al di fuori dei limiti forniti dalla matrice di input, tuttavia, tutte le celle esterne alla matrice iniziano a essere morte. Pertanto, la matrice di input può essere di qualsiasi dimensione, fino al valore massimo che la tua lingua può supportare. Non è necessario produrre la scheda tra generazioni.

Questo è un codice-golf, quindi vince il codice più corto.

Casi test

Questi usano la B/Snotazione per indicare le regole utilizzate

B2/S2, generations = 100, Configurazione:

1 1 1 1 1 1 1 1
0 0 0 0 0 0 0 0
1 1 1 1 1 1 1 1
0 0 0 0 0 0 0 0
1 1 1 1 1 1 1 1
0 0 0 0 0 0 0 0
1 1 1 1 1 1 1 1
0 0 0 0 0 0 0 0

Produzione:

0 0 0 0 0 0 0 0
0 1 0 0 0 0 1 0
1 0 0 0 0 0 0 1
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0

B1357/S2468, generations = 12, Configurazione:

1 0 1 0 1 0
0 1 1 0 1 0
1 0 0 0 0 0
0 0 0 0 0 1
1 1 1 1 1 0
0 1 1 0 0 1

Produzione:

0 1 0 0 0 0
0 1 1 1 1 0
0 1 0 1 1 0
1 1 1 0 0 0
0 0 1 1 1 0
0 1 1 0 0 0

Se hai bisogno di generare più casi di test, puoi usare questo fantastico simulatore. Assicurati di limitare le dimensioni della scheda

MATL , 24 23 byte

xx:"tt3Y6Z+1Gm<8M2Gmb*+

Gli input sono:

• Matrice con regola di nascita
• Matrice con regola di sopravvivenza
• Numero di generazioni
• Matrice con configurazione iniziale della cella, usando ;come separatore di riga.

Provalo online! Oppure vedi i casi di test: 1 , 2 .

Per qualche byte in più puoi vedere l' evoluzione nell'arte ASCII .

Spiegazione

xx      % Take two inputs implicitly: birth and survival rules. Delete them
        % (but they get copied into clipboard G)
:"      % Take third input implicitly: number of generations. Loop that many times
  tt    %   Duplicate twice. This implicitly takes the initial cell configuration
        %   as input the first time. In subsequent iterations it uses the cell 
        %   configuration from the previous iteration
  3Y6   %   Push Moore neighbourhood: [1 1 1; 1 0 1; 1 1 1]
  Z+    %   2D convolution, maintaining size
  1G    %   Push first input from clipboard G: birth rule
  m     %   Ismember: gives true for cells that fulfill the birth rule
  <     %   Less than (element-wise): a cell is born if it fulfills the birth rule
        %   *and* was dead
  8M    %   Push result of convolution again, from clipboard M
  2G    %   Push second input from clipboard G: survival rule
  m     %   Ismember: gives true for cells that fulfill the survival rule
  b     %   Bubble up the starting cell configuration
  *     %   Multiply (element-wise): a cell survives if it fulfills the survival
        %   rule *and* was alive
  +     %   Add: a cell is alive if it has been born or has survived, and those
        %   are exclusive cases. This produces the new cell configuration
        % Implicit end loop. Implicit display

Wolfram Language (Mathematica) , 144 122 byte

CellularAutomaton[{Tr[2^#&/@Flatten@MapIndexed[2#+2-#2[[1]]&,{#2,#3},{2}]],{2,{{2,2,2},{2,1,2},{2,2,2}}},{1,1}},#,{{#4}}]&

Provalo online!

Esempio di utilizzo:

%[RandomInteger[1, {10, 10}], {2, 3}, {3}, 5]

utilizza una griglia casuale 10x10 come inizio, sopravvive con 2 o 3 vicini, nascite con 3 vicini, risultato della trama in 5 iterazioni.

R , 256 byte

function(x,B,S,r){y=cbind(0,rbind(0,x,0),0)
n=dim(y)[1]
z=c(1,n)
f=function(h){w=-1:1
b=h%%n+1
a=(h-b+1)/n+1
'if'(a%in%z|b%in%z,0,sum(x[w+b,w+a])-x[b,a])}
while(r){x=y
for(i in 1:n^2){u=f(i-1)
y[i]=u%in%B
y[i]=(y[i]&!x[i])|(x[i]&(u%in%S))}
r=r-1}
y[-z,-z]}

Provalo online!

Purtroppo, questo non sembra così golfato come speravo.

Input : una matrice R e i parametri della sfida. Output : la matrice dopo R generazioni.

L'algoritmo riempie la matrice di zeri per gestire i confini. Quindi, iterativamente: 1 °) applica la regola della Nascita e 2 °) uccide le cellule preesistenti che non hanno superato la regola di Sopravvivenza. L'imbottitura viene rimossa al ritorno.

Python 2 , 156 149 146 byte

lambda R,g,c:g and f(R,g-1,[[`sum(sum(l[y+y/~y:y+2])for l in c[x+x/~x:x+2])-c[x][y]`in R[c[x][y]]for y,_ in e(c)]for x,_ in e(c)])or c
e=enumerate

Provalo online!

Accetta input:

• Rules: [birth,survial]regole come elenco di string. ad es. ( ['135','246'])
• generations: int
• configuration: matrice 2D quadrata di 1/0oTrue/False

Restituisce la matrice 2d di True/False