Wewnątrz odbiornika 5 x 5 znajduje się wirus. Ponieważ wiemy, w jaki sposób rozprzestrzenia się zanieczyszczenie, Twoim zadaniem jest wyjście z ostatniego etapu zanieczyszczenia.

Odbiorca

Będzie reprezentowany jako dwuwymiarowa tablica 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

Gdzie 1oznacza pozycję, w której wirus został już zanieczyszczony, i 0pozycję niezanieczyszczoną.

Jak rozprzestrzenia się wirus

1. Zanieczyszczona pozycja nie może być czysta.
2. Czysta pozycja zostanie zanieczyszczona w następnym etapie tylko wtedy, gdy co najmniej dwie jej sąsiednie pozycje (komórki północna, wschodnia, południowa i zachodnia) zostaną zanieczyszczone.
3. Ostatni etap zanieczyszczenia ma miejsce, gdy nie można już zanieczyścić czystych komórek.

Próba

Wykorzystując jako etap 1 zanieczyszczenia opisanego powyżej odbiorcę, etap 2 będzie:

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

Etap 3 zanieczyszczenia będzie:

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

Etap 4 zanieczyszczenia będzie:

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

A etap 5 (w tym przykładzie ostatni) będzie:

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

Wyzwanie

Biorąc pod uwagę jeden stopień zanieczyszczenia, należy podać ostatni stopień zanieczyszczenia.

Możesz napisać pełny program lub funkcję. Możesz wziąć dane wejściowe jako tablicę / listę, jako oddzielne liczby, a nawet jako ciąg znaków. Wybiera najlepszy sposób, który pasuje do twojego języka.

Najkrótsza odpowiedź w bajtach wygrywa!

Kolejne przypadki testowe

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

Ponieważ w zasadzie chodzi o automat komórkowy, daję ci ...

Reguła Golly Quicklife, 10 bajtów

01234/234V

Wprowadź regułę, wklej siatkę do Golly, uruchom wzór. Powstały wzór jest wynikiem.

Wyjaśnienie:

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

Lub jeśli nalegasz na pełną regułę RuleLoader, 89 bajtów:

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

Nazwa reguły to X, takie same kroki jak poprzednio.

Python 2, 97 bajtów

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

Wypróbuj online . Dane wejściowe są traktowane jako ciąg cytowany, a każdy wiersz jest oddzielony znakiem nowej linii. Nie 980jest optymalna i można ją zastąpić mniejszą wielokrotnością 35. Ponieważ nie ma to wpływu na długość tego programu, pozostawiłem ustalenie najniższej bezpiecznej górnej granicy jako ćwiczenie dla czytelnika.

JavaScript (ES6), 91 89 87 bajtów

Jako funkcja, która przyjmuje dane wejściowe jako tablicę liczb lub ciągów znaków.

-2 bajty od Neila (łączenie przypisania yz konwersją ciągów)

-2 bajty (usuwanie zmiennej 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 bajty

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

Działa to w bieżącej wersji (15.0.0) języka.

Wypróbuj online !

Format wejściowy to: tablica 2D z wierszami oddzielonymi średnikami. Zatem cztery przypadki testowe mają następujące dane wejściowe:

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

Wyjaśnienie

Powoduje to wielokrotne splatanie 2D tablicy wejściowej za pomocą następującej maski, która określa, którzy sąsiedzi liczą się jako zanieczyszczający:

0 1 0
1 0 1
0 1 0

Aby uzyskać wynik o takim samym rozmiarze jak pierwotna tablica, jest ona najpierw wypełniana ramką zer, a następnie zachowywana jest tylko „ważna” część splotu (tzn. Bez efektów krawędzi).

Próg 2 jest stosowany do wyjścia splotu, a wynik jest elementarny ORed z oryginalnym wejściem.

Tę czynność należy wykonać wystarczającą liczbę razy, aby zapewnić osiągnięcie ostatecznego stanu. Proste kryterium, które to spełnia: iteruj tyle razy, ile jest wpisów w tablicy wejściowej (czyli 25 razy w przypadkach testowych).

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 bajtów

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]

Wprowadź jako [[1,0,0,1,1][1,0,0,0,0]...].

Lua, 236 bajtów

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)

Akceptuje dane wejściowe z wiersza poleceń i używa manipulacji ciągiem Lua, aby uzyskać odpowiedź.

Nie golfowany:

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 bajtów

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

To polega na: rozszerz macierz do macierzy 7x7, a następnie wyśrodkuj nasz argument (omega). Z tej macierzy wygeneruj 4 macierze „potomne”, każda przesunięta w innym kierunku (góra / dół / lewo / prawo), dodaj je razem (aby uzyskać liczbę sąsiadów), upuść ramkę (aby wrócić do Matryca 5x5). Lub ta nowa matryca ze „starą”, aby upewnić się, że nie upuściliśmy żadnych komórek w procesie (tj. Na krawędzi). Następnie użyj ⍣≡kombinacji, aby uzyskać stałą wartość punktu.

{⍵∨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

przykład (biorąc pod uwagę, że funkcja została przypisana 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