Game Kehidupan dan Kelelahan

10

Permainan Kehidupan dan Kelelahan Stewie sangat mirip dengan Permainan Kehidupan Conway yang lebih terkenal .

Alam semesta dari Permainan Kehidupan dan Kelelahan Stewie (GoLF) adalah jaringan ortogonal dua dimensi yang tak terbatas dari sel-sel kuadrat, yang masing-masingnya ada di salah satu dari tiga kemungkinan keadaan, hidup, mati atau lelah. Setiap sel berinteraksi dengan delapan tetangganya, yaitu sel-sel yang berdekatan secara horizontal, vertikal, atau diagonal. Pada setiap langkah waktu, transisi berikut terjadi:

  • Setiap sel hidup dengan kurang dari dua tetangga hidup mati, seolah-olah disebabkan oleh kurang populasi.
  • Setiap sel hidup dengan dua atau tiga tetangga yang hidup hidup sampai generasi berikutnya.
  • Setiap sel hidup dengan lebih dari tiga tetangga hidup mati, seolah-olah karena kelebihan populasi.
  • Setiap sel mati dengan tepat tiga tetangga hidup menjadi sel hidup, seolah-olah dengan reproduksi.
  • Setiap sel yang telah hidup selama dua generasi berturut-turut mati, seolah-olah kelelahan. Ia tidak dapat hidup kembali sampai generasi berikutnya
  • Setiap sel yang berada di luar batas grid input sudah mati, seolah-olah jatuh dari tebing.

Tantangan:

Tantangan Anda adalah mengambil kisi dimensi n-by-m yang mewakili keadaan awal GoLF, dan bilangan bulat p , serta menampilkan status Gim setelah generasi p .

Aturan:

  • Format input dan output adalah opsional, tetapi grid input / output harus memiliki representasi yang sama
  • Anda dapat memilih simbol yang dapat dicetak untuk mewakili sel hidup dan mati (saya akan gunakan 1untuk sel hidup dan 0sel mati).
  • Anda dapat memilih apakah Anda memiliki indeks 0 atau 1. Dalam contoh, p=1berarti negara setelah satu langkah.
  • Kode terpendek di setiap bahasa menang
  • Fungsi bawaan untuk otomatisasi seluler diizinkan

Kasus uji:

Dalam contoh, saya hanya memasukkan kisi input pada input, bukan p . Saya telah memberikan output untuk berbagai nilai- p . Anda hanya akan menampilkan grid yang masuk dengan input yang diberikan hal .

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

Ya, saya sadar bahwa semua benih awal tidak akan berakhir di semua sel mati.

code-golf grid matrix cellular-automata game-of-life Stewie Griffin
sumber
Anda mungkin harus mengklarifikasi bahwa item transisi 5 diterapkan "pada saat yang sama" sebagai item 1--4, yaitu, didasarkan pada negara sebelum menerapkan 1--4
Luis Mendo
2
" sel, yang masing-masingnya dalam satu dari dua kemungkinan keadaan, hidup atau mati " tampaknya seperti definisi yang sengaja disalahgunakan mengingat bahwa aturan keletihan nanti hanya dapat diekspresikan dalam otomat hingga standar dengan membuat setiap sel memiliki tiga keadaan (mati, baru hidup, hidup selama dua generasi berturut-turut)
Peter Taylor
1
Saya memiliki aturan Golly untuk ini jika ada yang menginginkannya.
CalculatorFeline
6
Memainkan GoD, eh?
Adám

Jawaban:

3

MATL , 34 30 25 byte

5 byte dihapus berkat saran dari @CalculatorFeline !

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

Cobalah online!

Input adalah matriks dan angka. Matriks digunakan ;sebagai pemisah baris. Matriks untuk tiga kasus uji dimasukkan sebagai

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

Penjelasan

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
Luis Mendo
sumber
1
Bisakah Anda menjelaskan 3Y6lebih detail? Juga, jika elemen tengah dari kernel adalah .5, Anda bisa memeriksa CGOL dengan adil 2<value<4. Mungkin membantu.
CalculatorFeline
@ CalculatorFeline Itu saran yang sangat bagus, terima kasih! Ini menyebabkan penghematan 5 byte, menggunakan topeng dua kali dan kemudian menguji itu 5<=value<=7. Adapun 3Y6, itu hanya literal yang telah ditetapkan. Ada juga 1Y6, yang merupakan lingkungan 4
Luis Mendo
1
Hah. Itu benar-benar berhasil. Rapi.
CalculatorFeline
3

APL (Dyalog Classic 16.0) , 59 byte

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

Cobalah online! (ditiru pada Classic 15.0)

APL (Dyalog Unicode 16.0) , 85 byte

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

Cobalah online! (ditiru pada Unicode 15.0)

Anjuran untuk kisi dan kemudian untuk hal . Mencetak kisi baru setelah generasi p .

Perhatikan bahwa ini menggunakan ⌺primitif (Stensil) baru yang tidak termasuk dalam rangkaian karakter Klasik, karenanya versi yang lebih pendek dan versi yang kurang-byte.

Penjelasan untuk mengikuti ...

Adm
sumber
Format tampilan APL bagus :-)
Luis Mendo
@LuisMendo Sebenarnya, ini bukan "APL" tetapi penerjemah melakukan panggilan balik ke fungsi APL ini saat ingin menghasilkan. Fungsi kemudian menganalisis apa yang ingin kita hasilkan dan memodifikasinya. Penjelasan untuk displayfungsinya ada di sini .
Adám
3

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

Kotak input harus ditempelkan, batas-batasnya ada dalam nama aturan (misalnya 5* 3adalah Y:P5,3), tekan spasi untuk maju.

CalculatorFeline
sumber
2

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

Penjelasan:

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
sumber