类似于生命的细胞自动机是类似于Conway的“生命游戏”的细胞自动机，因为它们在（理论上）无限大的正方形网格上运行，其中每个单元正好有8个邻居，并且是2个状态之一，即存活和死亡。

但是，这些类似Like的版本在关键方面有所不同：给定单元存活的规则以及给定单元存活到下一代的规则。

例如，经典的“生命游戏”使用规则B3/S23，这意味着需要3个活细胞才能生出一个新细胞，而2或3个活着的邻居才能存活。对于此挑战，我们将假设邻居不包括自身，因此每个单元恰好具有8个邻居。

给定一个初始配置，一个出生规则，一个生存规则和一个正整数（要运行的世代数），您的任务就是使用这些规则模拟生命似的自动机，以尽可能短的代码给出世代数。您可以选择初始配置为方矩阵/ 2维数组或多行字符串。其他可以以任何合理的格式和方法给出。

例如，如果出生规则是12345678（任何居住的邻居），则生存规则是2357，并且初始配置是

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

接下来的两代人

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

如果给定的世代数为10，则输出将类似于

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

您不必处理在输入矩阵给定范围之外发生的更改，但是，矩阵外部的所有像元都会开始失效。因此，输入矩阵可以是任何大小，最大为您的语言可以支持的最大值。您无需在各代之间输出电路板。

这是一个代码高尔夫球，因此最短的代码获胜。

测试用例

这些使用B/S符号表示使用的规则

B2/S2，generations = 100，配置：

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

输出：

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，配置：

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

输出：

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

如果您需要生成更多的测试用例，则可以使用这个出色的模拟器。请确保限制板子尺寸

MATL，24 23字节

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

输入为：

• 具有出生规则的数组
• 具有生存规则的数组
• 世代数
• 具有初始单元格配置的矩阵，;用作行分隔符。

在线尝试！或者看到测试用例： 1， 2。

再花几个字节，您就可以看到ASCII艺术的演变。

说明

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语言（Mathematica），144122字节

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}}]&

在线尝试！

用法示例：

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

使用10x10随机网格作为起点，可以在2个或3个邻居中存活，在3个邻居中出生，以5次迭代绘制结果。

R，256字节

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

在线尝试！

可悲的是，这看起来并不像我希望的那样打高尔夫球。

输入：R矩阵和质询参数。输出：R代后的矩阵。

该算法用零填充矩阵以处理边界。然后，迭代地进行：1）应用出生规则，2）杀死未通过生存规则的现有细胞。返回时将删除填充。

Python 2中，156个 149 146字节

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

在线尝试！

接受输入：

• Rules：[birth,survial]作为列表的规则string。例如（['135','246']）
• g能量： int
• c配置：1/0或的方形2D数组True/False

返回2D数组 True/False