Жизнеподобные клеточные автоматы - это клеточные автоматы, которые похожи на игру жизни Конвея в том, что они действуют на (теоретически) бесконечно большой квадратной сетке, где каждая клетка имеет ровно 8 соседей и является одним из 2 состояний, а именно живым и мертвым ,

Тем не менее, эти версии, подобные «Лайк», принципиально отличаются друг от друга: правила оживления данной клетки и правила выживания данной клетки для следующего поколения.

Например, классическая Игра Жизни использует правило B3/S23, означающее, что для рождения новой требуется 3 живых клетки, а для выживания 2 или 3 живых соседа. Для этой задачи мы будем предполагать, что соседи не включают себя, поэтому каждая ячейка имеет ровно 8 соседей.

Ваша задача, учитывая исходную конфигурацию, правило рождения, правило выживания и положительное целое число (количество поколений, которое нужно запустить), имитировать Life-like автомат с использованием этих правил для числа поколений, указанных в кратчайшем из возможных кодов. , Начальной конфигурацией будет квадратная матрица / двумерный массив или многострочная строка, которую вы можете выбрать. Другие могут быть предоставлены в любом разумном формате и метод.

Например, если правило рождения было 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 Language (Mathematica) , 144 122 байта

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

Попробуйте онлайн!

Принимает участие:

• R[birth,survial]правила : список правил string. например.(['135','246'] )
• generations: int
• cконфигурация: квадратный 2D массив 1/0илиTrue/False

Возвращает 2d массив True/False