Menerapkan game of life dalam 3D

17

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 .

code-golf  game-of-life 
— Jens Render
sumber
1
Tag kode-golf yang tersirat dari pernyataan Anda menemukan implementasi tersingkat . Silakan periksa apakah itu yang Anda inginkan. Anda juga harus memberikan beberapa rincian tentang cara memasukkan, berapa banyak siklus, animasi ya / tidak, ... karena sangat penting bagi golf kode untuk memiliki spesifikasi yang kuat.
— Howard
@ Bagaimana saya menambahkan beberapa spesifikasi lagi, dan ya, lupa kode-golf tag;) terima kasih untuk itu.
— Jens Renders
@PeterTaylor Ya persis 5, saya akan mengeditnya.
— Jens Render
Saya akan menambahkan spesifik tentang format output (misalnya setiap sel harus dipisahkan oleh spasi seperti pada contoh Anda, satu baris baru antara setiap lapisan grid dari output, sel-sel hidup dan mati harus diwakili oleh karakter yang berbeda, dan itu harus karakter yang terlihat .) Juga, ingatlah bahwa jika dibingkai sebagai kode-golf, Anda tidak akan mendapatkan simulasi grafis.
— Jonathan Van Matre
Apakah Anda benar-benar bermaksud untuk melarang semua celah yang dibahas dalam meta thread tersebut, atau hanya mereka yang memenuhi kriteria persetujuan (dis) (skor +5, setidaknya dua kali lebih banyak upvote daripada downvotes)? Karena saya yakin saya benar - benar bisa memikirkan beberapa "celah" yang cukup menarik untuk didiskusikan ... ;-)
— Ilmari Karonen

Jawaban:

14

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:

masukkan deskripsi gambar di sini

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

masukkan deskripsi gambar di sini

Omong-omong, ini mengasumsikan kondisi batas periodik.

— Martin Ender
sumber
Apakah mereka benar-benar memasuki kondisi keseimbangan, atau hanya animasi yang berhenti? Jika yang pertama, Anda memberi saya beberapa ide yang rapi ...
— Kroltan
1
@ Kroltan Sudah lama, tapi saya cukup yakin mereka mencapai keseimbangan.
— Martin Ender
1
Terima kasih banyak. Irisan ekuilibrium individu terlihat sangat ruang-peta-y untuk mengatakan, permainan seperti kasar.
— Kroltan
12

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
— Tobia
sumber
+1 Jawaban yang sangat bagus! dan memang, batas tidak ditentukan sehingga membungkus diperbolehkan.
— Jens Render
9

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.

— algoritme hiu
sumber
Kutukan J dan |.kata kerjanya yang busuk !! Kerja bagus.
— Tobia
Dengan menggunakan situs kami, Anda mengakui telah membaca dan memahami Kebijakan Cookie dan Kebijakan Privasi kami.
Licensed under cc by-sa 3.0 with attribution required.