Trò chơi Cuộc sống và Sự mệt mỏi của Stewie khá giống với Trò chơi Cuộc sống của Conway nổi tiếng hơn .

Vũ trụ của Trò chơi Cuộc sống và Mệt mỏi của Stewie (GoLF) là một mạng lưới trực giao hai chiều vô hạn của các ô vuông, mỗi ô nằm trong một trong ba trạng thái có thể, sống, chết hoặc mệt mỏi. Mỗi ô tương tác với tám lân cận của nó, đó là các ô nằm ngang, dọc hoặc chéo theo đường chéo. Tại mỗi bước trong thời gian, các chuyển đổi sau đây xảy ra:

• Bất kỳ tế bào sống nào có ít hơn hai người hàng xóm sống đều chết, như thể gây ra bởi sự thiếu dân số.
• Bất kỳ tế bào sống nào có hai hoặc ba người hàng xóm sống đều sống ở thế hệ tiếp theo.
• Bất kỳ tế bào sống nào có nhiều hơn ba người hàng xóm sống đều chết, như thể do dân số quá mức.
• Bất kỳ tế bào chết nào có chính xác ba hàng xóm sống đều trở thành một tế bào sống, như thể được sinh sản.
• Bất kỳ tế bào nào còn sống trong hai thế hệ liên tiếp đều chết, như thể mệt mỏi. Nó không thể sống lại cho đến thế hệ tiếp theo
• Bất kỳ ô nào nằm ngoài ranh giới của lưới đầu vào đều chết, như thể nó rơi ra khỏi một vách đá.

Thử thách:

Thử thách của bạn là lấy một lưới các kích thước n-by-m đại diện cho trạng thái ban đầu của GoLF và một số nguyên p và đưa ra trạng thái của Trò chơi sau các thế hệ p .

Quy tắc:

• Các định dạng đầu vào và đầu ra là tùy chọn, nhưng các lưới đầu vào / đầu ra phải có cùng biểu diễn
• Bạn có thể chọn bất kỳ ký hiệu có thể in nào để thể hiện các ô sống và chết (Tôi sẽ sử dụng 1cho các ô sống và 0cho các ô chết).
• Bạn có thể chọn nếu bạn có 0 hoặc 1 chỉ mục. Trong các ví dụ, p=1có nghĩa là trạng thái sau một bước.
• Mã ngắn nhất trong mỗi ngôn ngữ sẽ thắng
• Chức năng tích hợp cho tự động hóa tế bào được cho phép

Các trường hợp thử nghiệm:

Trong các ví dụ, tôi chỉ bao gồm lưới đầu vào trong đầu vào, không phải p . Tôi đã cung cấp đầu ra cho các giá trị p khác nhau . Bạn sẽ chỉ xuất lưới đi kèm với đầu vào p đã cho .

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

_{Có, tôi biết rằng tất cả các hạt giống ban đầu sẽ không kết thúc trong tất cả các tế bào bị chết.}

MATL , 34 30 25 byte

5 byte bị xóa nhờ một đề xuất của @CalculatorFeline !

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

Hãy thử trực tuyến!

Đầu vào là một ma trận và một số. Ma trận sử dụng ;như dấu phân cách hàng. Ma trận cho ba trường hợp thử nghiệm được nhập dưới dạng

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

Giải trình

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

APL (Dyalog Classic 16.0) , 59 byte

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

Hãy thử trực tuyến! (mô phỏng trên Classic 15.0)

APL (Dyalog Unicode 16.0) , 85 byte

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

Hãy thử trực tuyến! (được mô phỏng trên Unicode 15.0)

Nhắc cho lưới và sau đó cho p . In lưới mới sau p thế hệ.

Lưu ý rằng điều này sử dụng nguyên hàm mới ⌺(stent) không được bao gồm trong bộ ký tự Cổ điển, do đó phiên bản ngắn hơn và phiên bản ít byte hơn.

Giải thích để theo dõi

Golly RuleLoader, 295 byte

@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

Lưới đầu vào phải được dán vào, các ranh giới nằm trong tên rulename (ví dụ 5* 3là Y:P5,3), nhấn phím cách để tiến lên.

Java 8, 333 byte

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

Giải trình:

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