Всередині реципієнта є вірус 5х5. Оскільки ми знаємо, як вона поширює своє забруднення, ваша місія полягає у виведенні останньої стадії забруднення.

Одержувач

Він буде представлений у вигляді двовимірного масиву 5x5:

0 0 0 0 1
0 0 0 0 1
0 0 0 1 1
0 0 1 1 1
0 1 1 1 1

Де 1означає місце, де вірус вже забруднений, а 0місце не забруднене.

Як вірус поширюється

1. Забруднене місце не може бути чистим.
2. Чисте положення буде забруднене на наступній стадії лише у тому випадку, якщо принаймні два його сусідніх положення (клітини північної, східної, південної та західної) забруднені.
3. Остання стадія зараження настає, коли більше чистих клітин не можна забруднювати.

Зразок

Використовуючи як стадію 1 забруднення реципієнта, описаного вище, стадія 2 буде:

0 0 0 0 1
0 0 0 1 1
0 0 1 1 1
0 1 1 1 1
0 1 1 1 1

Стадія 3 забруднення буде:

0 0 0 1 1
0 0 1 1 1
0 1 1 1 1
0 1 1 1 1
0 1 1 1 1

Етап 4 забруднення буде:

0 0 1 1 1
0 1 1 1 1
0 1 1 1 1
0 1 1 1 1
0 1 1 1 1

І етап 5 (у цьому прикладі останній) буде:

0 1 1 1 1
0 1 1 1 1
0 1 1 1 1
0 1 1 1 1
0 1 1 1 1

Виклик

Враховуючи одну стадію забруднення, слід вивести останню стадію забруднення.

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

Найкоротша відповідь у байтах виграє!

Ще один тестовий випадок

Input:
1 1 0 0 1
0 0 0 0 0
0 1 0 0 1
0 0 0 0 0
1 0 0 0 1

Output:
1 1 0 0 1
1 1 0 0 1
1 1 0 0 1
1 1 0 0 1
1 1 0 0 1

Input:
1 0 0 0 0
0 1 0 0 0
0 0 1 0 0
0 0 0 1 0
0 0 0 0 1

Output:
1 1 1 1 1
1 1 1 1 1
1 1 1 1 1
1 1 1 1 1
1 1 1 1 1

Input:
1 0 0 1 0
0 0 1 0 1
0 0 0 0 0
1 0 0 0 0
0 0 1 0 0

Output:
1 1 1 1 1
1 1 1 1 1
1 1 1 1 1
1 1 1 1 1
1 1 1 1 1

Input:
0 1 0 0 0
0 0 0 0 1
0 0 1 0 0
1 0 0 0 0
0 0 0 1 0

Output:
0 1 0 0 0
0 0 0 0 1
0 0 1 0 0
1 0 0 0 0
0 0 0 1 0

Оскільки це в основному говорить про стільниковий автомат, я даю вам ..

Правило Golly Quicklife, 10 байт

01234/234V

Введіть правило, вставте сітку в Golly, запустіть шаблон. Отримана картина - вихід.

Пояснення:

01234 Survive on any number of neighbors
     /234 Born on >2 neighbors
         V Only directly adjacent neighbors count

Або якщо ви наполягаєте на повному правилі RuleLoader, 89 байт:

@RULE X
@TABLE
n_states:2
neighborhood:vonNeumann
symmetries:permute
011001
011101
011111

Ім’я правила - X, ті ж дії, що і раніше.

Python 2, 97 байт

s=' '*6+input()
exec"s=s[1:]+('1'+s)[sum(s[i]<'1'for i in[-6,-1,1,6])>2or'/'>s];"*980
print s[6:]

Спробуйте в Інтернеті . Введення приймається як котирується рядок, кожен рядок розділений новими рядками. Це 980не є оптимальним і його можна замінити нижчим кратним 35. Оскільки це не впливає на тривалість цієї програми, я визначив нижню безпечну верхню межу як вправу для читача.

Javascript (ES6), 91 89 87 байт

Як функція, яка приймає введення як масив чисел або рядків.

-2 байти від Neil (поєднання призначення yз перетворенням рядків)

-2 байти (видалення змінної j)

f=x=>(y=x.map((z,i)=>~(i%5&&x[i-1])+~(i%5<4&x[i+1])+~x[i-5]+~x[i+5]<-5|z))+[]==x?y:f(y)

<!-- Snippet demo with array <-> string conversion for convenience -->
<textarea id="input" cols="10" rows="5">0 0 0 0 1
0 0 0 0 1
0 0 0 1 1
0 0 1 1 1
0 1 1 1 1</textarea>
<button id="submit">Run</button>
<pre id="output"></pre>
<script>
strToArray=x=>x.match(/\d/g)
arrayToStr=x=>([]+x).replace(/(.),(.),(.),(.),(.),*/g, '$1 $2 $3 $4 $5\n')
submit.onclick=_=>output.innerHTML=arrayToStr(f(strToArray(input.value)))
</script>

MATL , 22 байти

tn:"t5Bt!=~2X53$Y+1>Y|

Це працює в поточній версії (15.0.0) мови.

Спробуйте в Інтернеті !

Формат введення: 2D масив із рядками, розділеними крапками з комою. Отже, чотири тестові справи мають наступні входи:

[0 0 0 0 1; 0 0 0 0 1; 0 0 0 1 1; 0 0 1 1 1; 0 1 1 1 1]

[1 1 0 0 1; 0 0 0 0 0; 0 1 0 0 1; 0 0 0 0 0; 1 0 0 0 1]

[1 0 0 0 0; 0 1 0 0 0; 0 0 1 0 0; 0 0 0 1 0; 0 0 0 0 1]

[1 0 0 1 0; 0 0 1 0 1; 0 0 0 0 0; 1 0 0 0 0; 0 0 1 0 0]

Пояснення

Це неодноразово виконує 2D згортку вхідного масиву з наступною маскою, яка визначає, які сусіди вважають забруднюючими:

0 1 0
1 0 1
0 1 0

Для отримання результату такого ж розміру, що і вихідний масив, його спочатку обкладають кадром нулів, а потім зберігається лише "дійсна" частина згортки (тобто без крайових ефектів).

До виходу згортки застосовується поріг 2, і результат визначається елементами ORE з оригінальним входом.

Це необхідно зробити достатньо разів, щоб забезпечити досягнення остаточного стану. Простий критерій, який відповідає цьому, є: повторіть стільки ж разів, скільки кількість записів у вхідному масиві (тобто 25 разів у тестових випадках).

t          % get input 2D array implicitly. Duplicate
n:"        % repeat as many times as elements in the input array
  t        %   duplicate array
  5B       %   number 5 in binary: row vector [1 0 1] 
  t!       %   duplicate and transpose into column
  =~       %   compare for inequality with broadcast. Gives desired mask
  2X53$Y+  %   2D convolution. Output has same size as input 
  1>       %   true for elements equal or greater than 2
  Y|       %   element-wise OR with previous copy of the array
           % end loop. Implicitly display

TI-BASIC, 151 байт

Prompt [A]
[A]→[B]
Lbl 0
[B]→[A]
For(Y,1,5
For(X,1,5
DelVar ADelVar BDelVar CDelVar D
If Y>1:[A](Y-1,X→A
If Y<5:[A](Y+1,X→B
If X>1:[A](Y,X-1→C
If X<5:[A](Y,X+1→D
max(A+B+C+D≥2,[A](Y,X→[B](Y,X
End
End
If [A]≠[B]:Goto 0
[B]

Вхід як [[1,0,0,1,1][1,0,0,0,0]...].

Луа, 236 байт

s=arg[1]u=s.sub while p~=s do p=s s=s:gsub("(%d)()",function(d,p)t=0 t=t+((p-2)%6>0 and u(s,p-2,p-2)or 0)t=t+(p-7>0 and u(s,p-7,p-7)or 0)t=t+(p+5<30 and u(s,p+5,p+5)or 0)t=t+(p%6>0 and u(s,p,p)or 0)return t>1 and 1 or d end)end print(s)

Приймає введення в командному рядку та використовує рядкові маніпуляції Луа, щоб отримати відповідь.

Безголівки:

s=arg[1]
u=s.sub
while p~=s do
    p=s
    s=s:gsub("(%d)()", function(d, p)
                 t=0
                 t=t+((p-2)%6>0 and u(s,p-2,p-2)or 0)
                 t=t+(p-7>0 and u(s,p-7,p-7)or 0)
                 t=t+(p+5<30 and u(s,p+5,p+5)or 0)
                 t=t+(p%6>0 and u(s,p,p)or 0)
                 return t>1 and 1 or d
    end)
end
print(s)

APL, 76 72 70 байт

{⍵∨1<¯1 ¯1↓1 1↓↑+/(1 0)(¯1 0)(0 ¯1)(0 1){⍺[1]⊖⍺[2]⌽⍵}¨⊂¯1⊖¯1⌽7 7↑⍵}⍣≡

Це робиться так: розгорніть матрицю до розміру 7x7, а потім відцентруйте наш аргумент (омега). З цієї матриці створіть 4 "дочірніх" матриці, кожна зміщена в іншому напрямку (вгору / вниз / вліво / вправо), додайте їх разом (так ми отримаємо кількість сусідів), опустіть кадр (щоб повернутися до 5x5 матриця). Або ця нова матриця зі "старою", щоб переконатися, що ми не скинули жодних комірок у процесі (тобто на краю). Потім використовуйте ⍣≡комбінацію, щоб дістатись до фіксованого значення.

{⍵∨1<¯1 ¯1↓1 1↓↑+/(1 0)(¯1 0)(0 ¯1)(0 1){⍺[1]⊖⍺[2]⌽⍵}¨⊂¯1⊖¯1⌽7 7↑⍵}⍣≡
                                                             7 7↑⍵    ⍝ Expand the matrix
                                                       ¯1⊖¯1⌽         ⍝ Center the original matrix
                  (1 0)(¯1 0)(0 ¯1)(0 1){⍺[1]⊖⍺[2]⌽⍵}¨⊂               ⍝ Construct 4 child matrices, each offset from the original one by the values on the left of {}
                +/                                                    ⍝ Sum each matrix into one giant matrix
               ↑                                                      ⍝ Mix
     ¯1 ¯1↓1 1↓                                                       ⍝ Transform the 7x7 matrix back to a 5x5 matrix
   1<                                                                 ⍝ Check which elements are smaller than 1
 ⍵∨                                                                   ⍝ "Or" this matrix and the generated matrix
{                                                                 }⍣≡ ⍝ Find the fixpoint

приклад (враховуючи, що функція була призначена contaminate ):

          stage ⍝ the base matrix
0 0 0 0 1
0 0 0 0 1
0 0 0 1 1
0 0 1 1 1
0 1 1 1 1
      contaminate stage ⍝ apply the function
0 1 1 1 1
0 1 1 1 1
0 1 1 1 1
0 1 1 1 1
0 1 1 1 1