5x5'lik bir alıcıda virüs var. Kontaminasyonunu nasıl yaydığını bildiğimizden, göreviniz kontaminasyonun son aşamasını çıkarmaktır.

Alıcı

İki boyutlu 5x5 dizisi olarak temsil edilecektir:

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

Burada 1virüsün zaten kontamine olduğu ve 0kontamine olmamış bir pozisyon anlamına gelir .

Virüs nasıl yayılır

1. Kontamine bir konum temiz olamaz.
2. Temiz bir konum sonraki aşamada ancak bitişik konumlarından en az ikisi (kuzey, doğu, güney ve batı hücreleri) kontamine olduğunda kontamine olacaktır.
3. Kontaminasyonun son aşaması, daha fazla temiz hücre kontamine edilemediğinde meydana gelir.

Örneklem

Yukarıda tarif edilen alıcının kontaminasyonun 1. aşaması olarak kullanıldığında, 2. aşama:

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

Kontaminasyonun 3. aşaması:

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

Kontaminasyonun 4. aşaması:

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

Ve 5. aşama (bu örnekte sonuncusu) şöyle olacaktır:

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

Meydan okuma

Kontaminasyonun bir aşaması girdi olarak verildiğinde, kontaminasyonun son aşamasını çıkarmalısınız.

Tam program veya işlev yazmanıza izin verilir. Girdiyi dizi / liste, ayrılmış sayılar veya hatta dize olarak alabilirsiniz. Dilinize en uygun yolu seçer.

Bayt cinsinden en kısa cevap kazanır!

Başka bir test vakası

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

Bu temelde bir hücresel otomat hakkında konuştuğum için sana veriyorum ..

Golly Quicklife kuralı, 10 bayt

01234/234V

Kuralı girin, ızgarayı Golly'ye yapıştırın, deseni çalıştırın. Ortaya çıkan desen çıktıdır.

Açıklama:

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

Veya tam bir RuleLoader kuralında ısrar ediyorsanız, 89 bayt:

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

Rulename X, önceki adımlarla aynı.

Python 2, 97 bayt

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

Çevrimiçi deneyin . Girdi, her satır yeni satırlarla ayrılmış olarak alıntılanmış bir dize olarak alınır. 980Uygun değildir ve bu programın uzunluğuna bir etkisi olduğundan 35 daha düşük bir çoklu ile ikame edilmiş olabilir, bir üst okuyucuya örnek olarak bağlanan en güvenli tespitini yazılmıştır.

Javascript (ES6), 91 89 87 bayt

Girdiyi bir sayı veya dize dizisi olarak kabul eden bir işlev olarak.

Neil'den -2 bayt (atamasını ydize dönüştürme ile birleştirir )

-2 bayt (değişken kaldırılıyor 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 bayt

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

Bu , dilin geçerli sürümünde (15.0.0) çalışır .

Çevrimiçi deneyin !

Giriş biçimi: Satırları noktalı virgülle ayrılmış 2B dizi. Böylece dört test durumu aşağıdaki girişlere sahiptir:

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

açıklama

Bu, hangi komşuların kirletici olarak sayıldığını tanımlayan aşağıdaki maske ile giriş dizisinin 2B dönüştürmesini tekrar tekrar gerçekleştirir:

0 1 0
1 0 1
0 1 0

Orijinal dizi ile aynı boyutta bir sonuç elde etmek için, önce sıfırlardan oluşan bir çerçeve ile doldurulur ve daha sonra evrişimin yalnızca "geçerli" kısmı korunur (yani kenar etkileri olmadan).

Evrişimin çıkışına 2 eşiği uygulanır ve sonuç orijinal girdiyle birlikte eleman bazında ORed olur.

Bu, nihai duruma ulaşıldığından emin olmak için yeterli sayıda yapılmalıdır. Bunu karşılayan basit bir kriter şudur: giriş dizisindeki giriş sayısı kadar (örneğin, test senaryolarında 25 kez) yinelenir.

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 bayt

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]

Olarak girin [[1,0,0,1,1][1,0,0,0,0]...].

Lua, 236 bayt

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)

Komut satırındaki girdiyi kabul eder ve yanıtı almak için Lua'nın dize manipülasyonunu kullanır.

Ungolfed:

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 bayt

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

Bunun yaptığı şudur: matrisi 7x7 olana genişletin, sonra argümanımızı (omega) ortalayın. Bu matristen, her biri farklı bir yönde (yukarı / aşağı / sola / sağa) kaydırılmış 4 "alt" matris oluşturun, bunları ekleyin (böylece komşuların sayısını alırız), çerçeveyi bırakın (bir 5x5 matris). Ya da "eski" olan bu yeni matris, işlemde herhangi bir hücre bırakmadığımızdan emin olmak için (yani kenarda). Ardından, ⍣≡sabit nokta değerine ulaşmak için kombinasyonu kullanın.

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

örnek (işlevin atandığı dikkate alındığında 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