Pour trouver une aiguille dans une botte de foin, vous devez trouver la plus grande botte de foin contiguë contenant exactement une aiguille . Notez que vous ne pouvez pas connecter des cellules sur des diagonales, uniquement gauche / droite / haut / bas.

Contribution

Un tableau (ou un certain nombre de lignes de saisie utilisateur, votre choix) de 'N'(aiguilles) et '#'(foin) caractères. L'entrée ne contient que ces deux caractères et doit contenir au moins un de chacun. Par exemple:

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

Production

La taille de la plus grande meule de foin valide possible. Pour notre exemple, nous produirions 11 (il y a 11 morceaux de foin et une aiguille).

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

C'est le code-golf , donc le code le plus court l'emporte. Des restrictions d'échappatoire standard s'appliquent.

Cas de test

Entrée à gauche, possible meule de foin maximale à droite

Cas 1: 4

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

Cas 2: 7

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

Cas 3:10

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

Cas 4:10

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

Cas 5: 1

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

JavaScript (ES6), 152 octets

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

Explication

Pour chaque aiguille en entrée, règle l'aiguille sur une partie de la botte de foin (représentée en la définissant sur un nombre non nul) et vérifie en continu les cellules de foin. Si le foin contient une partie adjacente de la pile de foin, la place également dans la meule de foin et augmente la taille de la pile de foin. Génère le résultat le plus élevé.

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>

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

Il s'agit d'une fonction anonyme qui prend en entrée un tableau de tableaux. Usage:

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

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

Le proc nommé s trouve récursivement la taille de la botte de foin avec une aiguille à des coordonnées spécifiques et est appelé sur chaque aiguille de la botte de foin.