Để mô phỏng cuộc xâm lược của zombie, hãy bắt đầu với một lưới #và thể hiện bản đồ:

##   ##
###   #
## ##  
  # ###
#  ####

• # đại diện cho đất đai.
• đại diện cho nước.

Những thây ma bắt đầu tại một điểm trên bản đồ ...

##   ##
###   #
## %#  
  # ###
#  ####

... Và lan rộng. %biểu thị vùng đất bị nhiễm zombie.

Tuy nhiên, zombie không thể bơi . Họ có thể di chuyển trên đất liền giống như cách một vị vua di chuyển trong cờ vua - một hình vuông theo bất kỳ hướng chéo hoặc trực giao nào:

!!!
!%!
!!!

Khi kết thúc mô phỏng, một số vùng đất sẽ bị nhiễm zombie:

%%   ##
%%%   #
%% %%  
  % %%%
#  %%%%

Nhiệm vụ của bạn là mô phỏng cuộc xâm lược của thây ma. Viết chương trình (hoặc hàm) lấy đầu vào là một chuỗi biểu thị trạng thái ban đầu của lưới và hai số biểu thị tọa độ của zombie ban đầu. Chương trình sẽ xuất (hoặc trả lại) trạng thái cuối cùng của cuộc xâm lược.

Thông số kỹ thuật

• Chương trình của bạn có thể in một dòng mới tùy chọn.
• Bạn có thể giả sử đầu vào sẽ ở định dạng chính xác (được đệm bằng khoảng trắng), với một dòng mới tùy chọn.
• Bạn có thể cho rằng zombie ban đầu sẽ bắt đầu trên đất liền và sẽ không chết ngay lập tức.
• Đây là môn đánh gôn , vì vậy câu trả lời ngắn nhất (tính bằng byte) sẽ thắng.
• -100% tiền thưởng nếu mã của bạn cũng có thể giải quyết vấn đề Dừng cho các máy Turing tùy ý.
• Chương trình của bạn nên xử lý độ rộng bảng lên tới 50 ký tự.

APL (Dyalog) , 44 byte

{{c'%'[⌊⌿'%#'∊¨⍵(c←4⊃⍵)]}∘,⌺3 3⍣≡'%'@(⊂⍺)⊢⍵}

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

Giả định ⎕IO←0.

Đối số bên trái: hàng 0 được lập chỉ mục rcủa%, cột được lập chỉ mục 0 ccủa%: r c
Đối số bên phải: Ma trận ký tự

Kotlin, 283 218 byte

Lambda không tên (với chức năng lồng nhau, heh).

Chơi gôn

{i:String,x:Int,y:Int->val m=i.lines().map{it.toCharArray()};fun v(x:Int,y:Int){try{if(m[y][x]=='#'){m[y][x]='%';for(c in-1..1)for(d in-1..1)if(!(c==0&&d==0))v(x+c,y+d)}}catch(e:Exception){}};v(x, y);m.map(::println)}

Ung dung

fun zombies(input: String, startX: Int, startY: Int) {
    val m = input.lines().map(String::toCharArray)      // build game map
    fun invade(x: Int, y: Int) {                        // nested functions, woo!
        try {
            if (m[y][x] == '#') {                       // if land
                m[y][x] = '%'                           // mark as invaded
                for (dx in -1..1) {                      // generate neighbour tiles
                    for (dy in -1..1) {
                        if (!(dx == 0 && dy == 0)) {
                            invade(x + dx, y + dy)        // attempt to invade neighbours
                        }
                    }
                }
            }
        } catch(e: Exception) {}                        // catches ArrayIndexOutOfBounds
    }

    invade(startX, startY)                              // start the invasion
    m.map(::println)                                    // print final state
}

Đã lưu khá nhiều byte bằng cách chuyển sang một giải pháp đệ quy.

JavaScript (ES6), 144 byte

(s,x,y,l=s.search`\n`,g=s=>s==(s=s.replace(eval(`/(#|%)(.?[^]{${l-1}}.?)?(?!\\1)[#%]/`),`%$2%`))?s:g(s))=>g(s.slice(0,x+=y*l)+`%`+s.slice(x+1))

Trường hợp \nđại diện cho nhân vật dòng chữ mới. Có tọa độ 0 chỉ mục.

Befunge, 324 323 byte

&00p&10p20p~$v<p02+g02*!g02:+1$$$$<
 #<%>\"P"/8+p>1+:::~:0`!#v_:85+`!#^_2%\2%3*1+*\2/:"P"%\"P"/8+g+\2/:"P"
:+**73"="+g00*g02g010$$$$<v
02:\-<v/"P"\%"P":/2::_|#:$<:+1+g02\+g02:\-1+g02:\+1:\-1:\+1-g
\:20g^>g:30p\2%3*1+/4%1->#^_::2%6*2+30g+\2/:"P"%\"P"/p:20g-1-
0<v2\g+8/"P"\%"P":/2::<\_@#`0:-g
2^>%3*1+/4%1g,1+:20g%#^_1+55+,\

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

Giải trình

Việc thực hiện điều này trong Befunge hơi phức tạp một chút vì chúng tôi giới hạn ở 80x25 ký tự "bộ nhớ" phải được chia sẻ với chính mã nguồn. Mẹo để phù hợp với bản đồ 50x50 vào khu vực đó là làm phẳng bản đồ 2D thành một mảng 1D với hai vị trí bản đồ trên mỗi byte. Mảng 1D này sau đó được bọc lại thành một mảng 2D để nó có thể vừa với chiều rộng 80 ký tự của sân chơi Befunge.

Thuật toán lây nhiễm bắt đầu bằng cách chuyển đổi tọa độ ban đầu thành phần bù trong mảng 1D mà nó đẩy lên ngăn xếp. Vòng lặp chính lấy một giá trị từ ngăn xếp và tìm trạng thái bản đồ cho phần bù đó. Nếu đó là vùng đất chưa bị nhiễm bệnh, nó sẽ bị đánh dấu là bị nhiễm bệnh và tám điểm mới được đẩy lên ngăn xếp (đại diện cho vùng đất xung quanh vị trí hiện tại). Quá trình này tiếp tục cho đến khi ngăn xếp trống rỗng.

Để tránh phải kiểm tra ngoài giá trị phạm vi, bản đồ được lưu trữ với đường viền nước một ký tự xung quanh tất cả các cạnh.

Pip , 59 byte

{(ac+b+b*Ya@?n):'%L2*#aa:RVaR.`#(.?.?.{`.y-1.`})?%`'%.@>_a}

Một hàm lấy một chuỗi nhiều dòng, hàng của zombie ban đầu (0-index) và cột của zombie ban đầu (0-index). Hãy thử trực tuyến!

Làm sao?

Vì Pip có lập chỉ mục theo chu kỳ (thường là một điều tốt, nhưng không tốt cho vấn đề này vì chúng tôi không muốn các cạnh bản đồ được bọc lại), tôi đã tìm giải pháp thay thế regex.

Ya@?ntìm chỉ mục của dòng mới đầu tiên (tức là chiều rộng của lưới) và kéo nó vào y.

(ac+b+b*Ya@?n):'%sau khi thực hiện các thao tác trên, tính toán (width + 1) * row + col, tức là c+b+b*yvà đặt ký tự ở chỉ mục đó thành %.

L2*#acác vòng lặp 2*len(a), cung cấp cho chúng ta đủ số lần lặp để lấp đầy lũ để lan truyền đầy đủ và đảm bảo số lần lặp là chẵn (điều đó quan trọng).

.`#(.?.?.{`.y-1.`})?%`xây dựng một biểu thức chính khớp với một dấu #theo sau bởi a %, với 0, width-1, width hoặc width + 1 ký tự ở giữa. (Phần .đầu tạo ra .dòng regex khớp với dòng mới.) Regex này khớp với bất kỳ cấu hình nào sau đây:

#  
 % 

 # 
 % 

  #
 % 

#% 

aR ... '%.@>_thay thế các trận đấu của regex này bằng nhân vật được bổ sung %cho .tất cả trừ nhân vật đầu tiên @>của trận đấu _; trong ngắn hạn, thay thế #bằng %.

a:RV ...đảo ngược điều đó và gán nó trở lại a. Chúng tôi đảo ngược vì regex chỉ khớp # trước % trong chuỗi chứ không phải sau; nhưng khi chuỗi được đảo ngược, sau trở thành trước và chúng ta có thể khớp nó ở lần lặp tiếp theo. Đây cũng là lý do tại sao số lần lặp phải là số chẵn.

Sau khi vòng lặp hoàn thành, chúng ta chỉ cần trả về giá trị đã sửa đổi của a.

TSQL, 267 byte

Chơi gôn

USE master
DECLARE @ varchar(max)=
'##   ##
###   #
## %#  
  # ###
#  ####'

WHILE @@rowcount>0WITH C as(SELECT x+1i,substring(@,x+1,1)v,x/z r,x%z c
FROM spt_values CROSS APPLY(SELECT number x,charindex(char(10),@)z)z
WHERE type='P'and x<len(@))SELECT @=stuff(@,d.i,1,'%')FROM C,C D
WHERE'#%'=d.v+c.v and abs(c.r-d.r)<2and abs(c.c-d.c)<2PRINT @

Ung dung:

USE master-- the script needs to be executed on the default master database
DECLARE @ varchar(max)=
'##   ##
###   #
## %#  
  # ###
#  ####'

WHILE @@rowcount>0
WITH C as
(
  SELECT x+1i,substring(@,x+1,1)v,x/z r,x%z c
  FROM
    spt_values
  CROSS APPLY(SELECT number x,charindex(char(10),@)z)z
  WHERE type='P'and x<len(@)
)
SELECT @=stuff(@,d.i,1,'%')FROM C,C D
WHERE'#%'=d.v+c.v and abs(c.r-d.r)<2and abs(c.c-d.c)<2

PRINT @

Dùng thử

PHP, 209 189 188 183 byte

có thể chơi được

for($w=strpos($s=($a=$argv)[1],10),$s[$a[2]*++$w+$a[3]]="%";$t<$s;)for($t=$s,$i=0;""<$c=$s[$i++];)if($c>"$")for($y=-2;++$y<2;)for($x=3;$x--;)$s[$p=$i+$y*$w-$x]>"!"?$s[$p]="%":0;echo$s;

Chạy với php -r '<code>' '<grid>' <y> <x>

J, 152 byte

Không chơi golf giỏi lắm, tôi chắc chắn có cách để loại bỏ những cấu trúc điều khiển cuối cùng đó.

f=:4 :0
c=.(' '"_)`({~&<y)@.((*./y<$x)*.*./y>:0 0)x if.c='#' do.x=.'%'(<y)}x[i=.0 while.i<9 do.i=.>:i[x=.x f y+i<:@(|~,<.@%)3 end.end.x
)
g=:>@cutLF@[f]

Thực hiện một thuật toán lấp đầy lũ. Hàm g định dạng đầu vào thành một mảng ký tự trước khi áp dụng f.

Lưu ý rằng tọa độ hơi kỳ lạ:

0, 0

là góc trên cùng bên trái. Tăng tọa độ đầu tiên:

1, 0

Di chuyển vị trí xuống theo hướng y.

Khác với tọa độ là bình thường.

Thí dụ:

    land =: 0 : 0    NB. Define a multi-line string
##   ##
###   #
## ##  
  # ###
#  ####
)

    ] l =. >@cutLF land    NB. Cut 'land' on new lines, and form into an array. Assign to 'l'
##   ##
###   #
## ##  
  # ###
#  ####
    NB. Looks the same, but it isn't.

    '%' (<2 3)} l    NB. 'Infect' the land at 2, 3
##   ##
###   #
## %#  
  # ###
#  ####

    l f 2 3    NB. Flood fill on l (already formatted), starting at 2 3
%%   ##
%%%   #
%% %%  
  % %%%
#  %%%%

    land g 2 3    NB. Flood fill on land, formats for us.
%%   ##
%%%   #
%% %%  
  % %%%
#  %%%%