生活与疲劳的游戏

10

Stewie的《生命与疲劳游戏》与更著名的Conway的《生命游戏》非常相似。

Stewie的“生命与疲劳游戏”（GoLF）的宇宙是一个由正方形单元组成的无限二维正交网格，每个网格都处于三种可能的状态之一，即活着，死亡或疲倦。每个单元都与其八个相邻的单元进行交互，这八个单元是水平，垂直或对角线相邻的单元。在每个时间步上，都会发生以下转换：

  • 任何具有少于两个活邻居的活细胞都会死亡，好像是由于人口不足造成的。
  • 任何有两个或三个活邻居的活细胞都可以存活到下一代。
  • 任何具有三个以上活邻居的活细胞都会死亡，就好像人口过多一样。
  • 具有正好三个活邻居的任何死细胞都将变成活细胞，就像通过繁殖一样。
  • 连续存活了两个世代的任何细胞都会死亡，好像是由于疲劳而死亡。直到下一代，它才能重生
  • 输入网格边界之外的任何像元都将消失，就像从悬崖上掉下来一样。

挑战：

您面临的挑战是获取一个代表GoLF初始状态的n×m尺寸的网格和一个整数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 
— 斯蒂夫·格里芬
source
你或许应该澄清的是过渡项目5为应用1--4前应用“在同一时间”为项目1--4，也就是说，它是基于状态
— 路易斯Mendo
2
“ 细胞，其中的每一个是在两种可能的状态，活的或死的一个 ”看起来给出通过使每个小区，所述后疲劳规则只能在一个标准的有限自动机中表达的故意不正当定义有三种状态（死的，新活着，连续两代都活着）
— 彼得·泰勒
1
如果有人愿意，我对此有一个愚蠢的规则。
— CalculatorFeline
6
玩GoD，是吗？
— 亚当

Answers:

3

MATL，34 30 25字节

由于@CalculatorFeline的建议，删除了5个字节！

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
— 路易斯·门多
source
1
您能3Y6详细解释一下吗？另外，如果内核的中间元素是.5，则可以使用just检查CGOL 2<value<4。可能有帮助。
— CalculatorFeline
@CalculatorFeline这是一个很好的建议，谢谢！它导致节省了5个字节，使用了两次掩码，然后对其进行了测试5<=value<=7。至于3Y6，这只是预定义的文字。还有1Y6，这是4街区
— 路易斯Mendo
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。在p代后打印新网格。

请注意，这使用了新的⌺（Stencil）原语，它不包含在Classic字符集中，因此是一个较短的版本和一个较少字节的版本。

后续说明...

— 亚当
source
APL的显示格式很好：-)
— Luis Mendo
@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），按空格键前进。

— 猫科动物
source
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;
}
— 塞巴斯蒂安·马奇克（Sebastian Matschke）
source
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.