Samanlıkta iğne bulma konusundaki bir bükülmede, tam olarak bir iğne içeren en büyük bitişik samanlığı bulmanız gerekir . Hücreleri yalnızca sol / sağ / yukarı / aşağı diyagonallere bağlayamayacağınızı unutmayın.

Giriş

'N'(İğneler) ve '#'(saman) karakterlerden oluşan bir dizi (veya birkaç kullanıcı giriş satırı, seçiminiz) . Giriş yalnızca bu iki karakteri içerir ve her birinden en az birini içermelidir. Örneğin:

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

Çıktı

Mümkün olan en büyük geçerli samanlığın boyutu. Örneğimiz için 11 çıktısı vereceğiz (11 parça saman ve bir iğne var).

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

Bu kod golf , bu yüzden en kısa kod kazanır. Standart boşluk deliği kısıtlamaları geçerlidir.

Test Durumları

Solda giriş, sağda olası maksimum samanlık

Durum 1: 4

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

Durum 2: 7

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

Durum 3: 10

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

Durum 4: 10

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

Olay 5: 1

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

JavaScript (ES6), 152 bayt

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

açıklama

Girişteki her iğne için, iğneyi samanlığın bir kısmına (sıfır olmayan bir sayıya ayarlanarak temsil edilir) ayarlar ve sürekli olarak saman hücrelerini kontrol eder. Saman, saman yığınının bitişik bir parçasını içeriyorsa, samanlığın bir parçasını da ayarlar ve saman yığınının boyutunu artırır. En yüksek sonucu verir.

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>

Yakut, 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}

Bu, girdiyi diziler dizisi olarak alan anonim bir işlevdir. Kullanımı:

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

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

İsimli proc sözyineli olarak belirli koordinatlarda iğne ile samanlık boyutunu bulur ve samanlıkta her iğne üzerinde çağrılır.