Có một virus bên trong một người nhận 5x5. Như chúng ta biết làm thế nào nó truyền bá sự ô nhiễm của nó, nhiệm vụ của bạn là đưa ra giai đoạn cuối của sự ô nhiễm.

Người nhận

Nó sẽ được biểu diễn dưới dạng một mảng hai chiều của 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

Nơi 1có nghĩa là một vị trí nơi virus đã bị ô nhiễm và 0một vị trí không bị ô nhiễm.

Virus lây lan như thế nào

1. Một vị trí bị ô nhiễm không thể sạch sẽ.
2. Một vị trí sạch sẽ bị ô nhiễm trong giai đoạn tiếp theo chỉ khi ít nhất hai vị trí liền kề của nó (các tế bào bắc, đông, nam và tây) bị ô nhiễm.
3. Giai đoạn cuối cùng của sự ô nhiễm xảy ra khi không còn tế bào sạch nào có thể bị ô nhiễm.

Mẫu vật

Sử dụng như giai đoạn 1 của sự nhiễm bẩn mà người nhận đã mô tả ở trên, giai đoạn 2 sẽ là:

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

Giai đoạn 3 của sự ô nhiễm sẽ là:

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

Giai đoạn 4 của sự ô nhiễm sẽ là:

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

Và giai đoạn 5 (trong ví dụ này, phần cuối cùng) sẽ là:

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

Thử thách

Được đưa ra làm đầu vào của một giai đoạn ô nhiễm, bạn nên đưa ra giai đoạn ô nhiễm cuối cùng.

Bạn được phép viết chương trình đầy đủ hoặc một chức năng. Bạn có thể lấy đầu vào dưới dạng mảng / danh sách, dưới dạng các số riêng biệt hoặc thậm chí dưới dạng chuỗi. Chọn cách tốt nhất phù hợp với ngôn ngữ của bạn.

Câu trả lời ngắn nhất bằng byte thắng!

Một trường hợp thử nghiệm khác

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

Vì điều này về cơ bản là nói về một thiết bị tự động di động mà tôi cung cấp cho bạn ..

Quy tắc Golly Quicklife, 10 byte

01234/234V

Nhập quy tắc, dán lưới vào Golly, chạy mẫu. Mẫu kết quả là đầu ra.

Giải trình:

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

Hoặc nếu bạn nhấn mạnh vào quy tắc RuleLoader đầy đủ, 89 byte:

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

Rulename là X, các bước tương tự như trước đây.

Python 2, 97 byte

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

Hãy thử trực tuyến . Đầu vào được lấy dưới dạng một chuỗi trích dẫn với mỗi hàng được giới hạn bởi các dòng mới. Điều 980này không tối ưu và có thể được thay thế bằng bội số thấp hơn 35. Vì nó không ảnh hưởng đến độ dài của chương trình này, tôi đã để lại quyết định về giới hạn an toàn trên thấp nhất như một bài tập cho người đọc.

Javascript (ES6), 91 89 87 byte

Là một hàm chấp nhận đầu vào dưới dạng một mảng các số hoặc chuỗi.

-2 byte từ Neil (kết hợp gán yvới chuyển đổi chuỗi)

-2 byte (loại bỏ biến 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 byte

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

Điều này hoạt động trong phiên bản hiện tại (15.0.0) của ngôn ngữ.

Hãy thử trực tuyến !

Định dạng đầu vào là: mảng 2D với các hàng được phân tách bằng dấu chấm phẩy. Vì vậy, bốn trường hợp thử nghiệm có các đầu vào sau:

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

Giải trình

Điều này liên tục thực hiện tích chập 2D của mảng đầu vào với mặt nạ sau, xác định hàng xóm nào được coi là gây ô nhiễm:

0 1 0
1 0 1
0 1 0

Để có được kết quả có cùng kích thước với mảng ban đầu, trước tiên, nó được đệm bằng một khung số không và sau đó chỉ giữ phần "hợp lệ" của tích chập (nghĩa là không có hiệu ứng cạnh).

Ngưỡng 2 được áp dụng cho đầu ra của tích chập và kết quả là phần tử ORed khôn ngoan với đầu vào ban đầu.

Điều này phải được thực hiện đủ số lần để đảm bảo đạt được trạng thái cuối cùng. Một tiêu chí đơn giản đáp ứng điều này là: lặp lại nhiều lần số lượng mục trong mảng đầu vào (nghĩa là 25 lần trong các trường hợp thử nghiệm).

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 byte

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]

Đầu vào như [[1,0,0,1,1][1,0,0,0,0]...].

Lua, 236 byte

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)

Chấp nhận đầu vào trên dòng lệnh và sử dụng thao tác chuỗi của Lua để có câu trả lời.

Ung dung:

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 byte

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

Điều này làm là: mở rộng ma trận thành 7x7, sau đó tập trung vào đối số của chúng tôi (omega). Từ ma trận này, tạo ra 4 ma trận "con", mỗi ma trận dịch chuyển theo một hướng khác nhau (lên / xuống / trái / phải), cộng chúng lại với nhau (để chúng ta có được số lượng lân cận), thả khung hình (để quay lại Ma trận 5x5). Hoặc ma trận mới này với ma trận "cũ", để đảm bảo chúng tôi đã không bỏ bất kỳ ô nào trong quy trình (tức là ở rìa). Sau đó, sử dụng ⍣≡kết hợp để đến giá trị điểm cố định.

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

ví dụ (xem xét chức năng đã được gán cho 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