Wenn Sie eine Nadel im Heuhaufen finden, müssen Sie den größten zusammenhängenden Heuhaufen finden, der genau eine Nadel enthält . Beachten Sie, dass Sie keine diagonalen Zellen verbinden können, sondern nur links / rechts / oben / unten.

Eingang

Ein Array (oder eine Anzahl von Benutzereingabezeilen, Ihre Auswahl) von 'N'(Nadeln) und '#'(Heu) Zeichen. Die Eingabe enthält nur diese beiden Zeichen und muss jeweils mindestens eines enthalten. Beispielsweise:

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

Ausgabe

Die Größe des größtmöglichen gültigen Heuhaufens. In unserem Beispiel würden wir 11 ausgeben (es gibt 11 Heustücke und eine Nadel).

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

Das ist Code-Golf , also gewinnt der kürzeste Code. Es gelten die üblichen Lückenbeschränkungen.

Testfälle

Eingabe links, maximaler Heuhaufen rechts möglich

Fall 1: 4

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

Fall 2: 7

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

Fall 3: 10

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

Fall 4: 10

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

Fall 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

Erläuterung

Setzt die Nadel für jede Nadel in der Eingabe auf einen Teil des Heuhaufens (dargestellt durch Setzen einer Zahl ungleich Null) und überprüft fortlaufend die Heuzellen. Wenn Heu einen benachbarten Teil des Heuhaufens enthält, wird dieser ebenfalls in den Heuhaufen eingefügt und die Größe des Heuhaufens erhöht. Gibt das höchste Ergebnis aus.

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>

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

Dies ist eine anonyme Funktion, die die Eingabe als Array von Arrays aufnimmt. Verwendung:

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

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

Der genannte Proc ermittelt srekursiv die Größe des Heuhaufens mit Nadel an bestimmten Koordinaten und wird an jeder Nadel im Heuhaufen aufgerufen.