लेबल मृत समाप्त होता है

Question

एक ASCII कला "सड़क" के इनपुट को देखते हुए, सभी मृत सिरों के साथ सड़क को लेबल किया गया।

यह एक सड़क है:

########.....######..#..###
#......#######....#..#..#.#
#.##......#...#####..#..###
#..#####..#....#..#######.#
#......#...#####.....##...#
#..###.#...#...###...#..###
##########.#..#..##..#.##.#
..#......#.######.#..#.#.#.
..#......#.#..#.#.#..#.#.#.
..######.###..##..#########

यह पत्र के साथ लेबल किए गए मृत सिरों वाली सड़क है X:

########.....######..X..###
#......#######....#..X..#.#
#.XX......X...X####..X..###
#..XXXXX..X....#..#######.#
#......X...#####.....##...#
#..###.X...#...###...#..###
##########.#..X..##..#.##.X
..X......#.#XXXXX.#..#.#.X.
..X......#.#..X.X.#..#.#.X.
..XXXXXX.###..XX..######XXX

एक मृत अंत किसी भी सड़क टाइल के रूप में परिभाषित किया गया है कि सीमाओं n अन्य रोड टाइल, कम से कम n-1 जिनमें से विचार कर रहे हैं मृत समाप्त होता है इस नियम से पहले से ही। "बॉर्डरिंग" चार कार्डिनल दिशाओं में है, इसलिए तिरछे बॉर्डर वाले टाइल्स की गिनती नहीं होती है।

इस नियम को बार-बार लागू किया जाता है, क्योंकि नव निर्मित मृत सिरों को, स्वयं, अधिक मृत सिरों का निर्माण कर सकते हैं । यह भी ध्यान दें कि कोई भी रोड टाइल जो केवल एक अन्य रोड टाइल की सीमा तय करती है , नियम लागू होने के बाद पहली बार मृत अंत माना जाता है।

इनपुट और आउटपुट या तो एक एकल स्ट्रिंग हो सकता है (लाइनों के साथ किसी भी चरित्र है कि नहीं है के द्वारा अलग #या .या किसी सरणी / सूची / आदि)। यदि आपकी भाषा इसका समर्थन करती है, तो आप प्रत्येक पंक्ति को फ़ंक्शन तर्क होने के साथ इनपुट भी ले सकते हैं।

आप इनपुट के बारे में निम्नलिखित मान सकते हैं:

• हमेशा कम से कम एक "लूप" होगा-यह #वर्णों का एक समूह है, जिसे असीम रूप से पालन किया जा सकता है। (अन्यथा हर एक टाइल एक मृत अंत बन जाएगी।)

• इसका मतलब है कि इनपुट हमेशा 2 × 2 या बड़ा होगा, क्योंकि सबसे छोटा लूप है:

  ##
  ##
  

  (जो, संयोग से, बिना किसी बदलाव के आउटपुट होना चाहिए।)

• सभी #पात्र जुड़े रहेंगे। यही है, यदि आप किसी पर बाढ़ भराव करने के लिए थे, तो वे #सभी प्रभावित होंगे।

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

उपरोक्त उदाहरण और छोटे 2 × 2 ग्रिड का उपयोग परीक्षण मामलों के रूप में किया जा सकता है (इस चुनौती को कवर करने के लिए बहुत सारे किनारे मामले नहीं हैं)।

Answer 1

सीजेएम, 61 बाइट्स

q_N/{{0f+zW%}4*3ew:z3few::z{e__4=_@1>2%'#e=*"#"='X@?}f%}@,*N*

इसे यहाँ आज़माएँ ।

व्याख्या

Outline:

    q_N/               Read input lines
        {   }@,*       Perform some operation as many times as there are bytes
                N*     Join lines

Operation:

    {0f+zW%}4*         Box the maze with zeroes
    3ew:z3few::z       Mystical 4D array neighborhood magic.
                       (Think: a 2D array of little 3x3 neighborhood arrays.)

    {                        }f%    For each neighborhood, make a new char:
     e_                                 Flatten the neighborhood
       _4=_                             Get the center tile, C
           @1>2%                        Get the surrounding tiles
                '#e=                    Count surrounding roads, n
                    *                   Repeat char C n times
                     "#"=               Is it "#"? (i.e., C = '# and n = 1)
                         'X@?           Then this becomes an 'X, else keep C.

(मार्टिन ने दो बाइट्स बचाए, धन्यवाद!)

Comments

मैंने देखा है कि सबसे लंबे cjam जवाब में से एक है। =)

— DJMcMayhem 3

@DJMcGoathem Ummm ...

— मार्टिन

कर रहे हैं '#और "#"CJam में अलग है?

— ETHproductions

हां, वे हैं। "#"के बराबर है ['#]।

— लिन

Answer 2

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

r=>[...r].map(_=>r=r.replace(g=/#/g,(_,i)=>(r[i+1]+r[i-1]+r[i+l]+r[i-l]).match(g)[1]||"X"),l=~r.search`
`)&&r

1 बाइट @ edc65 की बदौलत बचा !

व्याख्या

समस्या के लिए बहुत सरल दृष्टिकोण। प्रत्येक के लिए खोजें #, और यदि इसके #आसपास 2 एस से कम हैं, तो इसे ए के साथ बदल देता है X। इस प्रक्रिया को कई बार दोहराता है जब तक कि यह गारंटी नहीं देता कि सभी मृत-छोरों को Xएस के साथ बदल दिया गया है ।

var solution =

r=>
  [...r].map(_=>                    // repeat r.length times to guarantee completeness
    r=r.replace(g=/#/g,(_,i)=>      // search for each # at index i, update r once done
      (r[i+1]+r[i-1]+r[i+l]+r[i-l]) // create a string of each character adjacent to i
      .match(g)                     // get an array of all # matches in the string
        [1]                         // if element 1 is set, return # (the match is a #)
        ||"X"                       // else if element 1 is undefined, return X
    ),
    l=~r.search`
`                                   // l = line length
  )
  &&r                               // return the updated r

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

Comments

सामान्य चाल जो मैं इस प्रकार के कार्य के लिए हमेशा उपयोग करता हूं। जैसे-जैसे आप l और -l दोनों का उपयोग करते हैं, वैसे-वैसे आप l=~r.searchइसकी गणना कर सकते हैं l=1+r.search। (बस बाइट बचाई गई)

— edc65

@ edc65 चतुर। धन्यवाद!

— user81655

Answer 3

पायथन (3.5) 362 331 329 314 बाइट्स

@Alissa को धन्यवाद। उसने मुझे ~ 33 बाइट जीतने में मदद की

d='.'
r=range
def f(s):
 t=[list(d+i+d)for i in s.split()]
 c=len(t[0])
 u=[[d]*c]
 t=u+t+u
 l=len(t)
 g=lambda h,x:t[h][x]=='#'
 for k in r(l*c):
  for h in r(1,l):
   for x in r(1,c):
    if g(h,x) and g(h+1,x)+g(h-1,x)+g(h,x+1)+g(h,x-1)<2:
     t[h][x]='X'
 print('\n'.join([''.join(i[1:-1])for i in t][1:-1]))

स्पष्टीकरण

d='.'
r=range

कार्य की परिभाषा

def f(s):

'की सीमा जोड़ें।' बोर्ड के दाएं और बाएं

 t=[list(d+i+d)for i in s.split()]
 c=len(t[0])
 u=[[d]*c]

'की सीमा जोड़ें।' ऊपर और नीचे

 t=u+t+u
 l=len(t)

'#' का परीक्षण करने के लिए लंबोदर समारोह

 g=lambda h,x:t[h][x]=='#'

इनपुट लंबाई पर पाश सुनिश्चित करें कि हम मृत सिरों को नहीं भूलते हैं

 for k in r(l*c):

कॉलम और लाइनों पर लूप

  for h in r(1,l):
   for x in r(1,c):

परीक्षण अगर हमारे पास और स्थिति पर '#' है

    if g(h,x) and g(h+1,x)+g(h-1,x)+g(h,x+1)+g(h,x-1)<2:

'#' को 'X' से बदलें

     t[h][x]='X'

''। और स्ट्रिंग में शामिल हों

 print('\n'.join([''.join(i[1:-1])for i in t][1:-1]))

प्रयोग

f("########.....######..#..###\n#......#######....#..#..#.#\n#.##......#...#####..#..###\n#..#####..#....#..#######.#\n#......#...#####.....##...#\n#..###.#...#...###...#..###\n##########.#..#..##..#.##.#\n..#......#.######.#..#.#.#.\n..#......#.#..#.#.#..#.#.#.\n..######.###..##..#########")

########.....######..X..###
#......#######....#..X..#.#
#.XX......X...X####..X..###
#..XXXXX..X....#..#######.#
#......X...#####.....##...#
#..###.X...#...###...#..###
##########.#..X..##..#.##.X
..X......#.#XXXXX.#..#.#.X.
..X......#.#..X.X.#..#.#.X.
..XXXXXX.###..XX..######XXX

Comments

1) का उपयोग split()करने के बजाय splitlines()। 2) t=['.'*(c+2)]+['.'+i+'.'for i in s]+['.'*(c+2)]छोटा है। और इसे और भी छोटा किया जा सकता है: d='.';t=[d*c]+t+[d*c];t=[d+i+d for i in t]3) आपको सभी सूची (ज़िप (....)) चीज़, उपयोग की आवश्यकता नहीं हैprint('\n'.join([''.join(i[1:-1])for i in t])

— Alissa

@ एलिसा आपकी मदद के लिए धन्यवाद, मैं बिंदु 1 के लिए आपकी युक्तियों का उपयोग करता हूं 1) और 3) लेकिन 2 के लिए) मैं सभी ब्रैकेट को नहीं हटा सकता, हमें चार की सूची की आवश्यकता है और स्ट्रिंग की सूची नहीं चाहिए क्योंकि 'str' object does not support item assignment। सूची की सूची मुझे t [h] [x] =

— Erwan

क्षमा करें, मैंने स्ट्रिंग अपरिवर्तनीयता के बारे में बात को याद किया। तुम भी सभी स्थिरांक स्थानांतरित कर सकते हैं ( r, gऔर dअपने कार्य से बाहर) (आप कुछ सारणीकरण बचाता है)। हो सकता है कि कुछ विभाजन के आसपास खेल रहे हों () मदद कर सकते हैं: t=[d+list(i)+d for i in s.split()]फिर लंबाई की गणना करें, फिर शुरुआत में अंत में डॉट-लाइनें जोड़ें, और फिर इन विस्तारित लंबाई के साथ काम करने के लिए अपने चक्रों को बदल दें। यकीन नहीं है कि यह कोड को छोटा कर देगा, लेकिन यह हो सकता है

— अलीसा 13

@ एलिसा मैं समारोह से बाहर नहीं जा सकता क्योंकि यह टी का उपयोग करता है मैं आपकी अन्य टिप्पणी का परीक्षण करूंगा

— एरवान