सुइयों में हिस्टैक का पता लगाएं

Question

एक हेस्टैक में एक सुई खोजने पर एक मोड़ में, आपको सबसे बड़ा सन्निहित हिस्टैक ढूंढने की आवश्यकता है जिसमें बिल्कुल एक सुई होती है । ध्यान दें कि आप कोशिकाओं को विकर्णों पर नहीं जोड़ सकते, केवल बाएँ / दाएँ / ऊपर / नीचे।

इनपुट

सरणी (या उपयोगकर्ता इनपुट लाइनों की एक संख्या, आपकी पिक) 'N'(सुइयों) और '#'(घास) वर्ण। इनपुट में केवल वे दो वर्ण हैं, और उनमें से प्रत्येक में कम से कम एक होना चाहिए। उदाहरण के लिए:

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

उत्पादन

सबसे बड़ा संभव वैध आकार का आकार। हमारे उदाहरण के लिए, हम 11 उत्पादन करेंगे (घास के 11 टुकड़े हैं, और एक सुई हैं)।

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

यह कोड-गोल्फ है , इसलिए सबसे छोटा कोड जीतता है। मानक ढील प्रतिबंध लागू होते हैं।

परीक्षण के मामलों

बाईं ओर इनपुट, दाईं ओर संभव अधिकतम बाधा

केस 1: 4

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

केस 2: 7

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

केस 3: 10

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

केस 4: 10

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

केस 5: 1

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

Answer 1

जावास्क्रिप्ट (ईएस 6), 152 बाइट्स

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

व्याख्या

इनपुट में प्रत्येक सुई के लिए, सुई को हाइस्टैक के एक हिस्से में सेट करता है (इसे गैर-शून्य नंबर पर सेट करके प्रतिनिधित्व किया जाता है) और लगातार हाइ कोशिकाओं की जांच करता है। यदि घास में घास के ढेर का एक समीपस्थ हिस्सा होता है, तो यह घास के हिस्से को भी सेट करता है और घास के ढेर के आकार को बढ़ाता है। उच्चतम परिणाम देता है।

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>

Answer 2

रूबी, 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}

यह एक अनाम फ़ंक्शन है जो इनपुट में सरणियों के एक सरणी के रूप में लेता है। उपयोग:

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

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

sपुनरावर्ती नाम की खरीद विशेष निर्देशांक पर सुई के साथ हाइस्टैक के आकार का पता लगाती है और इसे हाइस्टैक में प्रत्येक सुई पर कहा जाता है।