Tantangannya adalah menemukan implementasi game kehidupan terpendek dalam 3D ( contoh ). Inilah aturannya:

Sel (dalam hal ini, kubus) dengan hanya 1 atau kurang tetangga mati, seolah-olah karena kesepian.
Jika tepatnya 5 sel mengelilingi sel kosong, mereka berkembang biak dan mengisinya.
Jika sel memiliki 8 tetangga atau lebih, ia mati karena kepadatan yang berlebihan.

Buat setidaknya 10x10x10, di mana layer-layer tersebut dihasilkan secara individual seperti ini:

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

Tentu saja, simulasi grafik 3D juga diterima
. Posisi awal dapat di-hardcode tetapi harus berfungsi jika diubah ke posisi awal mana pun. Itu harus dapat menghitung jumlah generasi berapa pun, dan pengguna harus dapat secara manual meminta generasi berikutnya.

Kode terpendek dalam karakter menang!

Saya membuat implementasi ini sendiri untuk ukuran (cube) berapa pun: http://jensrenders.site88.net/life3D.htm Anda dapat menggunakan ini untuk menguji, dan Anda dapat mendasarkan kode Anda pada milik saya, meskipun saya tidak berkomentar .

Mathematica - 120 byte

g=CellularAutomaton[{(l=Flatten@#;c=l[[14]];n=Total@Drop[l,{14}];Which[n<2||n>7,0,n==5||c==1,1,0<1,0])&,{},{1,1,1}},##]&

Tentu saja bukan penantang untuk menang, tapi itu bukan maksud saya. Juga, ini mungkin bisa diturunkan secara signifikan dengan hanya mencari tahu nomor aturan. Saya hanya benar-benar ingin menulis visualisasi (walaupun saya sebenarnya yakin sudah ada banyak di luar sana). Jadi begini):

animateGol3d[size_, i_, n_] := 
  ListAnimate[
    Graphics3D[
      Cuboid /@ Position[#, 1], 
      PlotRange -> {{0, size}, {0, size}, {0, size}} + 1
    ] & /@ g[i, n]
  ];

Dan setelah bereksperimen dengan banyak kondisi awal, saya mendapatkan hal-hal seperti berikut:

Dan di sini adalah satu dengan ukuran kotak 20x20x20. Ini membutuhkan beberapa detik untuk mensimulasikan dan membuat:

Omong-omong, ini mengasumsikan kondisi batas periodik.

APL, 46

Butuh beberapa waktu, tetapi saya turun menjadi 46 karakter:

{(5=m)∨⍵∧3>|5.5-m←⊃+/,i∘.⌽i∘.⊖(i←2-⍳3)⌽[2]¨⊂⍵}

Ini adalah fungsi yang mengambil matriks 3D boolean dari berbagai ukuran dan menghitung generasi berikutnya, sesuai dengan aturan yang diberikan. Kondisi batas tidak ditentukan, jadi saya memilih untuk membungkus sisi lain, seperti di ruang toroidal.

Penjelasan

{                           ⊂⍵}   Take the argument matrix and enclose it in a scalar
               (i←2-⍳3)           Prepare an array with values -1 0 1 and call it i
                       ⌽[2]¨      Shift the matrix along the 2nd dim. by each of -1 0 1
           i∘.⊖                   Then for each result do the same along the 1st dimension
       i∘.⌽                       And for each result again along the 3rd dimension
 m←⊃+/,                           Sum element-wise all 27 shifted matrices and call it m

Hasil antara madalah matriks dengan bentuk yang sama dengan matriks asli, yang menghitung untuk setiap elemen berapa banyak sel yang hidup di lingkungan 3 × 3 × 3, termasuk dirinya sendiri. Kemudian:

           |5.5-m   For each element (x) in m, take its distance from 5.5
       ⍵∧3>         If that distance is <3 (which means 3≤x≤8) and the original cell was 1,
 (5=m)∨             or if the element of m is 5, then the next generation cell will be 1.

Contoh

Tentukan matriks acak 4 × 4 × 4 dengan sekitar 1/3 sel = 1 dan hitung generasi ke-1 dan ke-2. Bagian ⊂[2 3]depan hanyalah trik untuk mencetak pesawat secara horizontal, bukan vertikal:

      ⊂[2 3] m←1=?4 4 4⍴3
 1 0 0 0  1 0 1 0  1 0 1 0  0 0 0 1 
 1 1 0 0  0 0 0 0  0 0 0 1  1 0 1 0 
 0 0 0 0  0 1 0 0  0 0 0 0  0 0 1 0 
 1 1 0 0  0 0 0 1  1 0 0 1  0 0 1 0 
      ⊂[2 3] {(5=m)∨⍵∧3>|5.5-m←⊃+/,i∘.⌽i∘.⊖(i←2-⍳3)⌽[2]¨⊂⍵} m
 0 0 0 0  0 0 1 0  1 0 1 0  0 0 0 0 
 1 0 0 0  0 0 1 0  0 0 0 0  1 0 1 0 
 0 0 0 0  0 1 0 0  0 0 0 0  0 0 1 0 
 1 1 0 0  0 0 0 0  1 0 0 0  0 0 1 0 
      ⊂[2 3] {(5=m)∨⍵∧3>|5.5-m←⊃+/,i∘.⌽i∘.⊖(i←2-⍳3)⌽[2]¨⊂⍵}⍣2⊢ m
 0 0 1 0  1 0 1 0  1 0 1 0  0 0 0 0 
 1 0 1 0  0 0 1 1  0 0 0 0  1 0 1 0 
 1 0 0 0  1 1 0 0  0 0 1 0  1 0 1 0 
 1 1 1 0  1 0 0 1  1 0 1 0  0 0 1 0 

J - 42 char

Kami mengasumsikan papan toroidal (membungkus) dalam ketiga dimensi. Tampilan otomatis hasil J tampaknya mengikuti spesifikasi output, digunakan 1untuk sel hidup dan 0mati. Kode ini berfungsi di papan dengan lebar, panjang, dan tinggi berapa pun (bisa 10x10x10, 4x5x6, dan sebagainya).

(((1&<*<&8)@-*]+.5=-)~[:+/(,{3#<i:1)|.&><)

Penjelasan berikut:

• ,{3#<i:1 - Subekspresi daftar offset untuk sel dan semua tetangganya.
  • <i:1 - Daftar bilangan bulat antara 1 dan -1 inklusif.
  • ,{3#- Buat tiga salinan dari daftar ( 3#), dan ambil produk Cartesian ( ,{).
• (,{3#<i:1)|.&><- Untuk setiap set offset 3D, geser larik. Dengan biaya 3 karakter, Anda dapat mengubah |.&>untuk |.!.0&>untuk tidak memiliki wrap-around.
• [:+/ - Jumlahkan semua papan yang digeser menjadi satu.
• ((1&<*<&8)@-*]+.5=-)~- Kata kerja terluar yang panjang adalah pengait sehingga menerima papan di kiri dan kanan, dan sisi di sebelah kanan kami telah bergeser dan menjumlahkan. The ~swap sekitar ini untuk kata kerja batin.
  • 5=- - 1 di setiap sel bahwa jumlah papan bergeser minus papan asli (yaitu jumlah tetangga) sama dengan 5, dan 0 pada semua yang lain.
  • ]+. - Logis ATAU di atas dengan papan asli.
  • (1&<*<&8) - 1 jika jumlahnya dibandingkan antara 1 dan 8 eksklusif, 0 sebaliknya.
  • (1&<*<&8)@-* - Bandingkan (seperti di atas) tetangga menghitung, dan kalikan (yaitu logis DAN ketika domain hanya 1 atau 0) hasil logis ATAU dengan ini.

Penggunaan seperti halnya APL, cukup terapkan fungsi ke papan awal untuk setiap langkah. J memiliki operator daya fungsional ^:untuk membuatnya mudah.

   life =: (((1&<*<&8)@-*]+.5=-)~[:+/(,{3#<i:1)|.&><)  NB. for convenience
   board =: 1 = ?. 4 4 4 $ 4  NB. "random" 4x4x4 board with approx 1/4 ones
   <"2 board  NB. we box each 2D plane for easier viewing
+-------+-------+-------+-------+
|0 0 0 0|1 1 0 0|0 1 0 0|0 0 1 0|
|0 1 0 0|0 0 0 0|0 0 0 1|1 0 0 0|
|0 0 0 0|0 0 1 0|0 1 0 0|0 0 0 1|
|1 1 0 0|1 0 0 0|0 0 0 1|0 1 1 0|
+-------+-------+-------+-------+
   <"2 life board
+-------+-------+-------+-------+
|0 0 0 0|0 1 0 1|0 1 0 0|0 0 1 0|
|1 1 1 1|0 0 0 0|0 0 0 1|1 1 0 0|
|0 0 0 0|0 0 1 1|0 1 0 0|0 0 0 1|
|1 0 0 0|1 0 0 1|0 0 0 1|0 1 1 1|
+-------+-------+-------+-------+
   <"2 life^:2 board  NB. two steps
+-------+-------+-------+-------+
|0 0 0 0|0 1 0 0|0 1 0 0|0 0 0 0|
|0 1 0 0|0 0 0 0|0 0 0 1|0 1 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 1 1 1|
+-------+-------+-------+-------+
   <"2 life^:3 board  NB. etc
+-------+-------+-------+-------+
|0 1 0 0|1 1 1 0|0 1 0 0|0 1 0 0|
|0 1 0 0|1 0 1 0|1 0 1 0|1 1 1 0|
|1 0 0 0|0 0 0 0|0 1 0 0|0 1 0 0|
|0 0 1 0|0 0 0 0|0 1 0 0|0 1 1 0|
+-------+-------+-------+-------+

Saya katakan "acak" karena ?.primitif memberikan hasil acak yang dapat direproduksi dengan menggunakan benih tetap setiap waktu. ?adalah RNG sejati.