Игра жизни и усталости

10

Игра жизни и усталости Стьюи очень похожа на более известную игру жизни Конвея .

Вселенная Игры жизни и усталости Стьюи (GoLF) представляет собой бесконечную двумерную ортогональную сетку квадратных ячеек, каждая из которых находится в одном из трех возможных состояний: живое, мертвое или уставшее. Каждая ячейка взаимодействует со своими восемью соседями, которые являются соседями по горизонтали, вертикали или диагонали. На каждом шаге по времени происходят следующие переходы:

  • Любая живая клетка с менее чем двумя живыми соседями умирает, как если бы она была вызвана недостаточным населением.
  • Любая живая клетка с двумя или тремя живыми соседями живет для следующего поколения.
  • Любая живая клетка с более чем тремя живыми соседями умирает, как если бы она была перенаселена.
  • Любая мертвая клетка с ровно тремя живыми соседями становится живой клеткой, как будто путем размножения.
  • Любая клетка, которая была жива два поколения подряд, умирает, как будто от усталости. Он не может снова пробудиться к жизни до следующего поколения
  • Любая ячейка, которая находится за границей входной сетки, мертва, как если бы она упала со скалы.

Вызов:

Ваша задача состоит в том, чтобы взять сетку измерений n-by-m, представляющую начальное состояние GoLF, и целое число p , и вывести состояние игры через p поколений.

Правила:

  • Форматы ввода и вывода являются необязательными, но сетки ввода / вывода должны иметь одинаковое представление
  • Вы можете выбрать любые печатные символы для представления живых и мертвых клеток (я буду использовать 1для живых клеток и 0для мертвых клеток).
  • Вы можете выбрать, если у вас есть 0 или 1-индексированный. В примерах p=1означает состояние после одного шага.
  • Самый короткий код на каждом языке выигрывает
  • Встроенная функция для сотовой автоматизации допускается

Тестовые случаи:

В примерах я включил только входную сетку во входную, а не p . Я предоставил выходные данные для различных p- значений. Вы должны выводить только сетку, которая идет с заданным входом p .

Input:
0   0   0   0   0
0   0   1   0   0
0   0   1   0   0
0   0   1   0   0
0   0   0   0   0

--- Output ---
p = 1
0   0   0   0   0
0   0   0   0   0
0   1   1   1   0
0   0   0   0   0
0   0   0   0   0

p = 2
0   0   0   0   0
0   0   1   0   0
0   0   0   0   0
0   0   1   0   0
0   0   0   0   0

p = 3 -> All dead
---

Input:
0   1   0   0   0   0
0   0   1   0   0   0
1   1   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

--- Output ---
p = 1
0   0   0   0   0   0
1   0   1   0   0   0
0   1   1   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

p = 2
0   0   0   0   0   0
0   0   0   0   0   0
1   0   0   0   0   0
0   1   1   0   0   0
0   0   0   0   0   0
0   0   0   0   0   0
0   0   0   0   0   0

p = 3
0   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   0   0   0   0
0   0   0   0   0   0
0   0   0   0   0   0

p = 4 -> All dead
Input
0   1   1   0   1   1   0
1   1   0   1   1   1   1
0   1   0   0   0   1   0
0   0   0   1   1   0   1
1   0   0   1   0   1   1
0   0   1   1   0   1   1
1   1   0   0   0   0   1

--- Output ---
p = 1
1   1   1   0   0   0   1
1   0   0   1   0   0   1
1   1   0   0   0   0   0
0   0   1   1   0   0   1
0   0   0   0   0   0   0
1   0   1   1   0   0   0
0   1   1   0   0   1   1

p = 2
1   0   0   0   0   0   0
0   0   0   0   0   0   0
1   0   0   1   0   0   0
0   1   1   0   0   0   0
0   1   0   0   0   0   0
0   0   0   0   0   0   0
0   0   1   1   0   0   0   

p = 3
0   0   0   0   0   0   0
0   0   0   0   0   0   0
0   1   1   0   0   0   0
1   1   0   0   0   0   0
0   1   1   0   0   0   0
0   0   1   0   0   0   0
0   0   0   0   0   0   0

p = 4
0   0   0   0   0   0   0
0   0   0   0   0   0   0
1   1   1   0   0   0   0
1   0   0   0   0   0   0
1   0   1   0   0   0   0
0   1   1   0   0   0   0
0   0   0   0   0   0   0

p = 5
0   0   0   0   0   0   0
0   1   0   0   0   0   0
1   0   0   0   0   0   0
0   0   1   0   0   0   0
1   0   0   0   0   0   0
0   1   0   0   0   0   0
0   0   0   0   0   0   0

p = 6
0   0   0   0   0   0   0
0   0   0   0   0   0   0
0   1   0   0   0   0   0
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

p = 7
0   0   0   0   0   0   0
0   0   0   0   0   0   0
0   0   0   0   0   0   0
1   1   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

p = 8
0   0   0   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
0   1   0   0   0   0   0
0   0   0   0   0   0   0
0   0   0   0   0   0   0

p = 9 -> All dead

Да, я знаю, что все начальные семена не закончатся тем, что все клетки будут мертвыми.

code-golf grid matrix cellular-automata game-of-life Стьюи Гриффин
источник
Возможно, вам следует уточнить, что элемент перехода 5 применяется «одновременно» с элементами 1–4, то есть он основан на состоянии до применения 1--4
Луис Мендо
2
« Ячейки, каждая из которых находится в одном из двух возможных состояний, живые или мертвые », кажутся преднамеренно извращенным определением, учитывая, что позднее правило усталости может быть выражено только в стандартном конечном автомате, если каждая ячейка имеет три состояния (мертвая, новая). жив, жив в течение двух поколений подряд)
Питер Тейлор
1
У меня есть правило Голли, если кто-то этого хочет.
CalculatorFeline
6
Играем в GoD, а?
Адам

Ответы:

3

MATL , 34 30 25 байтов

5 байтов удалено благодаря предложению @CalculatorFeline !

0ii:"wy*~wt3Y6QZ+5:7mb*]&

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

Входы - это матрица и число. Матрица используется в ;качестве разделителя строк. Матрицы для трех тестовых случаев вводятся как

[0 0 0 0 0; 0 0 1 0 0; 0 0 1 0 0; 0 0 1 0 0;0 0 0 0 0]
[0 1 0 0 0 0; 0 0 1 0 0 0; 1 1 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 1 1 0 1 1 0; 1 1 0 1 1 1 1; 0 1 0 0 0 1 0; 0 0 0 1 1 0 1; 1 0 0 1 0 1 1; 0 0 1 1 0 1 1; 1 1 0 0 0 0 1]

объяснение

0     % Push 0. This represents the generation previous to the input one. Actually
      % This should be an array of zeros, but thanks to broadcasting it is
      % equivalent (and saves bytes)
i     % Input: array with starting generation
i     % Input: number of iterations, p.
      % STACK (bottom to top): 0, array with initial generation, p
:"    % Do the following p times
      %   STACK: previous gen, current gen
  wy  %   Swap, duplicate from below
      %   STACK: current gen, previous gen, current gen
  *~  %   Multiply element-wise, negate. This creates a mask of cells that do not 
      %   die of fatigue (they were 0 in the current or in the previous generation)
      %   STACK: current gen, fatigue mask
  wt  %   Swap, duplicate
      %   STACK: Fatigue mask, current gen, current gen
  3Y6 %   Push predefined literal: 8-neighbourhood: [1 1 1; 1 0 1; 1 1 1]
      %   STACK: Fatigue mask, current gen, current gen, 8-neighbourhood
  Q   %   Add 1 element-wise. This gives [2 2 2; 2 1 2; 2 2 2], which will be
      %   used as convolution kernel. Active cells with 2 neighbours will give 5;
      %   inactive cells with 3 neighbours will give 6; and active cells with 3
      %   neighbours will give 7
      %   STACK: Fatigue mask, current gen, current gen, convolution kernel
  Z+  %   2D convolution, keeping size
      %   STACK: Fatigue mask, current gen, convolution result
  5:7 %   Push array [5 6 7]
  m   %   Ismember, element-wise. Cells that give true will survive, unless fatigued
      %   STACK: Fatigue mask, current gen, cells that can survive
  b   %   Bubble up
      %   STACK: Current gen, cells that can survive, fatigue mask
  *   %   Multiply element-wise. This tells which cells survive considering fatigue.
      %   The result is the new generation
      %   STACK: "Current" gen which now becomes old, "new" gen which now becomes
      %   current
]     % End 
&     % Specify that implicit display will show only top of the stack
Луис Мендо
источник
1
Можете ли вы объяснить 3Y6более подробно? Также, если средний элемент ядра был .5, вы можете проверить CGOL с помощью just 2<value<4. Может помочь.
CalculatorFeline
@CalculatorFeline Это очень хорошее предложение, спасибо! Это привело к экономии 5 байт, удвоению маски и последующему тестированию 5<=value<=7. Что касается 3Y6, это просто предопределенный литерал. Там также 1Y6, который является 4-окрестности
Луис Мендо
1
Да. Это действительно сработало. Ухоженная.
CalculatorFeline
3

APL (Dyalog Classic 16.0) , 59 байт

⌊{((3∊⌊{⍵,⍵-c}+/,⍵)∧.1>1|c)×(.1×c)+1⌈c←2 2⌷⍵}⎕U233A 3 3⍣⎕⊢⎕

Попробуйте онлайн! (эмулируется на Classic 15.0)

APL (Dyalog Unicode 16.0) , 85 байт

⌊{((3∊⌊{⍵,⍵-c}+/,⍵)∧.1>1|c)×(.1×c)+1⌈c←2 2⌷⍵}⌺3 3⍣⎕⊢⎕

Попробуйте онлайн! (эмулируется в Unicode 15.0)

Запрашивает сетку, а затем для р . Печатает новую сетку через p поколений.

Обратите внимание, что здесь используется новый ⌺(Stencil) примитив, который не включен в набор символов Classic, следовательно, более короткая версия и версия с меньшим количеством байтов.

Объяснение, чтобы следовать ...

Адам
источник
Формат отображения APL хороший :-)
Луис Мендо
@LuisMendo На самом деле, это не «APL», а интерпретатор, если он хочет вывести, выполняет обратный вызов этой функции APL . Затем функция анализирует то, что мы хотим вывести, и соответствующим образом модифицирует. Объяснение для displayфункции здесь .
Адам
3

Golly RuleLoader, 295 байт

@RULE Y
@TABLE
n_states:3
neighborhood:Moore
symmetries:permute
var z={1,2}
var y=z
var x=z
var w=z
var u=z
var a={0,z}
var b=a
var c=a
var d=a 
var e=a
var f=a
var g=a 
var h=a
0,z,y,x,0,0,0,0,0,1
z,a,0,0,0,0,0,0,0,0
z,y,x,w,u,a,b,c,d,0
2,a,b,c,d,e,f,g,h,0
1,a,b,c,d,e,f,g,h,2
@COLORS
2 255 0 0

Входная сетка должна быть вставлена, границы находятся в руленном имени (например, 5* 3есть Y:P5,3), нажмите пробел для продвижения.

CalculatorFeline
источник
2

Java 8, 333 байта

int[][]G(int p,int[][]s){for(int h=s.length,w=s[0].length,y,x,n,a,b,t[][]=new int[h][w],i=0;i++<2*p;)for(y=0;y<h;++y)for(x=0;x<w;++x)if(i%2>0){for(n=0,a=y-2;++a<y+2;)for(b=x-2;++b<x+2;)n+=a>=0&a<h&b>=0&b<w&(a!=y|b!=x)&&s[a][b]>0?1:0;t[y][x]=s[y][x]<1?n==3?1:0:n<2|n>3|s[y][x]>1?0:2;}else s[y][x]=i==2*p&t[y][x]>1?1:t[y][x];return s;}

Объяснение:

int[][]G(int p,int[][]s){
    for(int h=s.length,w=s[0].length,y,x,n,a,b,t[][]=new int[h][w],       //height, width, vars, temp array
            i=0;i++<2*p;)                                                 //for 2*generations: 1. calculate in temporary t, 2. copying to s
        for(y=0;y<h;++y)                                                  //for each row
            for(x=0;x<w;++x)                                              //for each column
                if(i%2>0){                                                //1. calculate
                    for(n=0,a=y-2;++a<y+2;)                               //n = number of alive cells around [y][x]. row above, at and below y
                        for(b=y-2;++b<y+2;)                               //column left, at and right of x
                            n+=a>=0&a<h&b>=0&b<w&(a!=y|b!=x)&&s[a][b]>0?1:0;    //if within bounds and not the cell itself, add 1 if alive.
                    t[y][x]=s[y][x]<1?n==3?1:0:n<2|n>3|s[y][x]>1?0:2;     //save next state in temporary, depending on rules. alive cells become 2.
                }
                else                                                      //2. copy temporary t to s
                    s[y][x]=i==2*p&t[y][x]>1?1:t[y][x];                   //if last generation, replace 2 by 1
    return s;
}
Себастьян Мачке
источник