Otomat seluler yang menyerupai kehidupan adalah otomat seluler yang mirip dengan Conway's Game of Life, di mana mereka beroperasi pada kotak persegi (secara teoritis) tak terhingga besar, di mana setiap sel memiliki 8 tetangga yang tepat, dan merupakan salah satu dari 2 negara, yaitu hidup dan mati .

Namun, versi suka-suka ini berbeda dalam cara yang krusial: aturan untuk sel yang diberikan menjadi hidup dan aturan untuk sel yang diberikan untuk bertahan hidup ke generasi berikutnya.

Sebagai contoh, Game of Life klasik menggunakan aturan B3/S23, yang berarti bahwa dibutuhkan 3 sel hidup untuk melahirkan yang baru, dan 2 atau 3 tetangga yang hidup untuk bertahan hidup. Untuk tantangan ini, kami akan berasumsi bahwa tetangga tidak memasukkan dirinya sendiri, sehingga setiap sel memiliki 8 tetangga.

Tugas Anda adalah, diberikan konfigurasi awal, aturan kelahiran, aturan bertahan hidup dan bilangan bulat positif (jumlah generasi yang akan dijalankan), mensimulasikan robot mirip-kehidupan menggunakan aturan-aturan itu untuk jumlah generasi yang diberikan dalam kode sesingkat mungkin . Konfigurasi awal akan berupa matriks kuadrat / array 2 dimensi atau string multiline, Anda dapat memilih. Yang lain dapat diberikan dalam format dan metode apa pun yang masuk akal.

Misalnya, jika aturan kelahiran adalah 12345678(tetangga yang hidup), aturan survival adalah 2357dan konfigurasi awal adalah

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

dua generasi berikutnya akan menjadi

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

Jika jumlah generasi yang diberikan adalah 10, output akan menjadi sesuatu di sepanjang garis

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

Anda tidak harus menangani perubahan yang terjadi di luar batas yang diberikan oleh matriks input, namun, semua sel di luar matriks mulai mati. Oleh karena itu, matriks input dapat berukuran berapa saja, hingga nilai maksimum yang dapat didukung bahasa Anda. Anda tidak harus mengeluarkan papan antara generasi.

Ini adalah kode-golf sehingga kode terpendek menang.

Uji kasus

Ini menggunakan B/Snotasi untuk menunjukkan aturan yang digunakan

B2/S2,, generations = 100konfigurasi:

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

Keluaran:

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 = 12konfigurasi:

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

Keluaran:

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

Jika Anda perlu membuat lebih banyak kasus uji, Anda dapat menggunakan simulator yang luar biasa ini . Pastikan untuk membatasi ukuran papan

MATL , 24 23 byte

xx:"tt3Y6Z+1Gm<8M2Gmb*+

Inputnya adalah:

• Array dengan aturan kelahiran
• Array dengan aturan bertahan hidup
• Jumlah generasi
• Matriks dengan konfigurasi sel awal, menggunakan ;sebagai pemisah baris.

Cobalah online! Atau lihat test case: 1 , 2 .

Untuk beberapa byte lagi, Anda dapat melihat evolusi dalam seni ASCII .

Penjelasan

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

Bahasa Wolfram (Mathematica) , 144 122 byte

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}}]&

Cobalah online!

Contoh penggunaan:

%[RandomInteger[1, {10, 10}], {2, 3}, {3}, 5]

menggunakan grid acak 10x10 sebagai permulaan, bertahan dengan 2 atau 3 tetangga, kelahiran dengan 3 tetangga, hasil plot pada 5 iterasi.

R , 256 byte

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

Cobalah online!

Sayangnya, ini tidak terlihat seperti golf seperti yang saya harapkan.

Input : matriks R, dan parameter tantangan. Output : matriks setelah generasi R.

Algoritma ini melapisi matriks dengan angka nol untuk menangani batas. Kemudian, berulang: 1) ini menerapkan aturan Kelahiran dan 2) itu membunuh sel-sel yang sudah ada sebelumnya yang tidak melewati aturan Survival. Padding dihapus saat kembali.

Python 2 , 156 149 146 byte

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

Cobalah online!

Mengambil input:

• Rules: [birth,survial]aturan sebagai daftar string. mis. ( ['135','246'])
• generations: int
• configurasi: Array 2D persegi 1/0atauTrue/False

Mengembalikan array 2d dari True/False