Ubah aturan hidup

15

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

caird coinheringaahing
sumber
Apakah simulasi itu toroidal?
Erik the Outgolfer
@EriktheOutgolfer no, karena matriksnya (secara teoritis) tidak terbatas dalam ukuran
caird coinheringaahing
Juga, dapatkah kita mengasumsikan matriks yang diberikan adalah persegi?
Erik the Outgolfer
2
@EriktheOutgolfer "grid persegi tak terhingga besar"
caird coinheringaahing
Tapi itu tidak mengatakan Anda dapat berasumsi bahwa ... akan mengedit.
Erik the Outgolfer

Jawaban:

9

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
Luis Mendo
sumber
Bisakah Anda menyimpan byte dengan mengubah urutan input? The xxpada awal tampaknya boros sedikit dengan saya ...
Erik yang Outgolfer
@EriktheOutgolfer Saya tidak mengerti caranya. Saya perlu menghapus dua yang pertama untuk kemudian menggunakannya kembali beberapa kali (satu per iterasi), dan input lainnya sudah tersirat sekarang
Luis Mendo
Oh begitu "menghapus" input menambahkannya ke semacam daftar input?
Erik the Outgolfer
@EriktheOutgolfer Ya. Input MATL bersifat interaktif, artinya program tidak mengetahui sebelumnya berapa banyak input yang ada. Di sini, menghapus dari tumpukan kosong menyebabkan input secara implisit diambil. Setelah diambil, setiap input akan disalin ke clipboard G, dan mereka dapat diambil nanti.
Luis Mendo
3

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.

Kelly Lowder
sumber
Sayang sekali, builtin hanya satu dimensi (koreksi saya jika saya salah)
Zacharý
Saya menggunakan "CellularAutomaton" bawaan dengan aturan totalistik 9 tetangga. Sebagian besar kode mengubah input survival / kelahiran menjadi nomor aturan.
Kelly Lowder
1

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.

NofP
sumber
jumlah byte yang bagus!
Giuseppe
Saya berhasil mendapatkan 217 byte, tetapi jika kami dapat menemukan satu golf lagi, kami bisa mendapatkannya 216yang setidaknya merupakan kubus ...
Giuseppe
1

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

TFeld
sumber