Trong một bước ngoặt trong việc tìm kim trong đống cỏ khô, bạn cần tìm ra đống cỏ liền kề lớn nhất chứa chính xác một kim . Lưu ý rằng bạn không thể kết nối các ô trên các đường chéo, chỉ trái / phải / lên / xuống.

Đầu vào

Một mảng (hoặc một số dòng đầu vào của người dùng, lựa chọn của bạn) 'N'(kim) và '#'(hay) ký tự. Đầu vào chỉ chứa hai ký tự đó và phải chứa ít nhất một ký tự. Ví dụ:

N#N#N
#NN##
###N#
N##N#

Đầu ra

Kích thước của đống cỏ khô hợp lệ lớn nhất có thể. Ví dụ của chúng tôi, chúng tôi sẽ xuất 11 (có 11 mảnh cỏ khô và một kim).

   # 
#  ##
###N#
 ## #

Đây là mã golf , vì vậy mã ngắn nhất sẽ thắng. Hạn chế kẽ hở tiêu chuẩn áp dụng.

Các trường hợp thử nghiệm

Nhập vào bên trái, haystack tối đa có thể ở bên phải

Trường hợp 1: 4

N##    ##
NN#     #
#NN     N
#N#     #

Trường hợp 2: 7

###   ###
N#N    # 
NNN    N 
###   ###

Trường hợp 3: 10

N###N    ### 
#N#N#   #N#  
#N#N#   # #  
N###N    ###

Trường hợp 4: 10

N#N#N        
#N#N#   # # #
##N##   ##N##
#N#N#   # # #
N#N#N        

Trường hợp 5: 1

NN#NN        
NNNNN         
#NNN#   #N    
NN#NN        

JavaScript (ES6), 152 byte

s=>[...s].map((n,i)=>n>'M'&&(a=[...s],a[i]=r=1,a.map(_=>a.map((c,j)=>c=='#'&&a[j+1]|a[j-1]|a[j+l]|a[j-l]?a[j]=++r:0)),o=r>o?r:o),o=0,l=~s.search`
`)|o-1

Giải trình

Đối với mỗi kim trong đầu vào, đặt kim thành một phần của đống cỏ khô (được biểu thị bằng cách đặt nó thành một số khác không) và liên tục kiểm tra các ô hay. Nếu cỏ khô chứa một phần liền kề của đống cỏ khô, cũng đặt nó là một phần của đống cỏ khô và tăng kích thước của đống cỏ khô. Kết quả đầu ra cao nhất.

var solution =

s=>
  [...s].map((n,i)=>n>'M'&&(          // for each needle in s at index i
      a=[...s],                       // a = array of each character in s
      a[i]=1,                         // set the starting needle to 1 (haystack)
      r=0,                            // r = haystack size starting from this needle
      a.map(_=>                       // loop to ensure the complete haystack is found
        a.map((c,j)=>                 // for each cell c at index j
          c=='#'&&                    // if the current cell is hay
          a[j+1]|a[j-1]|a[j+l]|a[j-l] // and any adjacent cells are part of the haystack
          ?a[j]=++r:0                 // add the current cell to the haystack, increment r
        )
      ),
      o=r>o?r:o                       // o = max of o and r
    ),
    o=0,                              // o = final output, initialise to 0
    l=~s.search`
`                                     // l = line length of s
  )
  |o                                  // return o

<textarea id="input" rows="6" cols="40">N#N#N
#N#N#
##N##
#N#N#
N#N#N</textarea><br />
<button onclick="result.textContent=solution(input.value)">Go</button>
<pre id="result"></pre>

Ruby, 207

->a{d=->b{0...b.size}
f=c=s=->y,x{(d[a]===y&&d[a[0]]===x&&!f[y][x]&&a[y][x]==c)?(c,f[y][x]=?#,1
1+s[y,x-1]+s[y,x+1]+s[y-1,x]+s[y+1,x]):0}
d[a].map{|y|d[y].map{|x|f,c=a.map{|b|b.map{p}},?N
s[y,x]}.max}.max-1}

Đây là một hàm ẩn danh nhận đầu vào dưới dạng một mảng các mảng. Sử dụng:

f=->a{......}

f["
N##
NN#
#NN
#N#
".strip.split.map(&:chars)] # => 4

Proc có tên sđệ quy tìm kích thước của đống cỏ khô bằng kim ở tọa độ cụ thể và được gọi trên mỗi kim trong đống cỏ khô.