Завдання полягає в тому, щоб знайти найкоротшу реалізацію гри життя в 3D ( приклад ). Це правила:

Клітини (в даному випадку кубики) з лише 1 або меншими сусідами гинуть, наче від самотності.
Якщо рівно 5 клітин оточує порожню клітинку, вони розводять і заповнюють її.
Якщо клітина має 8 або більше сусідів, вона гине від переповнення.

Зробіть її принаймні 10x10x10, де шари виводяться окремо так:

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

Звичайно, також приймається графічне 3D-моделювання
. Вихідне положення може бути жорстко кодованим, але воно повинно працювати, якщо його змінити на будь-яке вихідне положення. Він повинен бути в змозі обчислити будь-яку кількість поколінь, і користувач повинен мати можливість вручну запитувати наступне покоління.

Найкоротший код у символах виграє!

Я зробив власну реалізацію цього для будь-якого (куб) розміру: http://jensrenders.site88.net/life3D.htm Ви можете використовувати це для тестування, і ви можете базувати свій код на моєму, хоча я не коментував це .

Mathematica - 120 байт

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

Звичайно, не претендент на перемогу, але це не було моїм наміром. Крім того, це може бути значно полегшене, просто з'ясувавши номер правила. Я просто дуже хотів написати візуалізацію (хоча я насправді впевнений, що там вже є тонни). Тож ось ми йдемо):

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

І після експерименту з купою початкових умов я отримав такі речі:

А ось один із розміром сітки 20x20x20. На моделювання та рендерінг знадобилося кілька секунд:

До речі, це передбачає періодичні граничні умови.

APL, 46

Ми зайняли деякий час, але я знизив це до 46 знаків:

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

Це функція, яка приймає булеву 3D-матрицю будь-якого розміру і обчислює наступні покоління, згідно з заданими правилами. Прикордонні умови не були визначені, тому я вирішив обернутись іншою стороною, як у тороїдальному просторі.

Пояснення

{                           ⊂⍵}   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

Проміжним результатом mє матриця такої ж форми, що і вихідна матриця, яка підраховує для кожного елемента кількість клітин, що живуть у її околиці 3 × 3 × 3, включаючи саму себе. Потім:

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

Приклад

Визначте випадкову матрицю 4 × 4 × 4 з приблизно 1/3 комірок = 1 та обчисліть її 1 та 2 покоління. ⊂[2 3]На фронті це просто виверт , щоб надрукувати площині горизонтально , а не вертикально:

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

Ми припускаємо тороїдальну дошку (обгортання) у всіх трьох вимірах. Автоматичне відображення результатів J, як видається, відповідає виведенним специфікаціям, використовуючи 1живі клітини та 0мертві. Цей код працює на дошках будь-якої ширини, довжини та висоти (може бути 10x10x10, 4x5x6 тощо).

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

Пояснення випливає:

• ,{3#<i:1 - Субпресія списку компенсацій для комірки та всіх її сусідів.
  • <i:1 - Список цілих чисел від 1 до -1 включно.
  • ,{3#- Зробіть три примірники списку ( 3#) і візьміть декартовий продукт ( ,{).
• (,{3#<i:1)|.&><- Для кожного набору зсувів 3D змістіть масив. За вартістю 3 -х символів, ви можете змінити , |.&>щоб |.!.0&>не мати намотується навколо.
• [:+/ - Підсумуйте всі зміщені дошки разом.
• ((1&<*<&8)@-*]+.5=-)~- Довге зовнішнє дієслово було гачком, тому воно отримує дошку ліворуч і праворуч, а бічну сторону праворуч ми переміщували та підсумовували. У ~свопи це навколо для цього внутрішнього дієслова.
  • 5=- - 1 в кожній комірці, що сума зміщених дощок мінус початкової дошки (тобто кількість сусідів) дорівнює 5, а 0 у всіх інших.
  • ]+. - Логічне АБО вищезазначене з оригінальною дошкою.
  • (1&<*<&8) - 1, якщо число порівнюється між 1 і 8 виключно, 0 в іншому випадку.
  • (1&<*<&8)@-* - Порівняйте (як вище) кількість підрахунків сусідів і помножте (тобто логічно І, коли домену лише 1 або 0) логічний результат АБО на це результат.

Використання як у APL, просто застосуйте функцію до початкової дошки для кожного кроку. J має оператор ^:з функціональною потужністю, щоб зробити це легко.

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

Я кажу "випадково", тому що ?.примітив дає відтворювані випадкові результати, використовуючи фіксований насіння кожен раз. ?є справжньою RNG.