लूप्स और लूप्स और लूप्स

Question

चुनौती

एक ऐसा फ़ंक्शन बनाएं जो ASCII आर्ट का इनपुट देते समय (एक पथ को निर्देशित करता है जो अंततः लूप हो सकता है), लूप की लंबाई (यदि एक है) और "पूंछ" की लंबाई को लूप में से एक में लीड करता है। नीचे प्रपत्र।

---

इनपुट

आपका इनपुट एक फ़ंक्शन को पास होना चाहिए। नीचे एक सरल इनपुट का एक उदाहरण है।

# --> # --> #
      ^     |
      |     |
      |     v
      # <-- #

आप इस तरह के उपरोक्त ब्लॉकों की कल्पना कर सकते हैं

"पूंछ" एक आइटम है, जबकि लूप चार लंबा है।

एक और कठिन एक:

            # --> # --> #
            ^           |
            |           |
            |           v
      # --> # <-- #     # --> #
      ^           ^           |
      |           |           |
      |           |           v
# --> #           # <-- # <-- #

---

उत्पादन

आपको STDOUT या अपनी भाषा के निकटतम विकल्प के माध्यम से आउटपुट करना होगा।

आपके दो आउटपुट पूर्णांक पूंछ की लंबाई और लूप की लंबाई होनी चाहिए। यह आउटपुट दो रूपों में हो सकता है।

1. एक अंतरिक्ष-सीमांकित स्ट्रिंग: "2 10"
2. पूर्णांक की एक सरणी: [2, 10]

---

नियम

• हर ब्लॉक, या #, केवल एक ही रास्ता खुद से दूर होगा ।

• हर तीर दो लाइन खंडों और एक सिर है।

• शुरुआती ब्लॉक हमेशा सबसे बाएं कॉलम में होगा।

• इनपुट कभी लूप नहीं होगा।

---

उदाहरण

# --> # --> # --> #
^     ^           |
|     |           |
|     |           v
#     # <-- # <-- #

यह एक पूंछ की लंबाई 2 और पाश की लंबाई 6 है। नीचे, पूंछ और लूप को अलग किया जाता है।

पूंछ

# -->
^
|
|
#

लूप

# --> # --> #
^           |
|           |
|           v
# <-- # <-- #

सही outputs हैं [2, 6]और "2 6"।

यदि इनपुट केवल एक पूंछ है , तो लूप की लंबाई शून्य है।

# --> # --> # --> #
                  |
                  |
                  v
        <-- # <-- #

उपरोक्त इनपुट के लिए सही आउटपुट हैं [6, 0]और"6 0"

Comments

@orlp मुझे लगता है कि आप इनपुट और आउटपुट को भ्रमित कर रहे हैं।

— Sanchises

क्या इनपुट में रास्ते के अतिरिक्त डिस्कनेक्ट टुकड़े हो सकते हैं?

— 21

मुझे लगता है कि इंट्रो भ्रामक है। यह मुझे लगता है कि समस्या कार्यक्रम विश्लेषण के बारे में होगी, जबकि यह ASCII कला में पथ-खोज के बारे में है।

— xnor

मैंने इंट्रो हटा दिया है। यह थोड़ा भ्रामक / भ्रामक था। @xnor

— Zach गेट्स

संबंधित: तीर कहाँ इंगित कर रहा है?

— mınxomaτ

Answer 1

जावास्क्रिप्ट (ईएस 6), 221 229

एक पैरामीटर के रूप में इनपुट के साथ एक फ़ंक्शन, पॉपअप विंडो (अलर्ट) के माध्यम से एक स्ट्रिंग के रूप में आउटपुट।

बार-बार इनपुट स्कैन करें:
प्रत्येक चरण पर

• पूंछ के अंत को हटा दें
• शेष '#' की गिनती करें

जब हटाने के लिए अधिक पूंछ नहीं होती है, तो अब तक के चरणों की संख्या पूंछ के आकार और शेष '# की संख्या लूप का आकार है।

बैकटिक्स के अंदर के सभी नए समाचार महत्वपूर्ण और गिने जाते हैं

फ़ायरफ़ॉक्स के साथ नीचे स्निपेट का परीक्षण करें (क्रोम नहीं, क्योंकि यह समर्थन नहीं करता है ...)

F=s=>{s=`


${s}


`.split`
`.map(r=>[...r]);for(t=0,f=1;f;)s.map((r,y)=>r.map((c,x)=>c=='#'&&((r[x+2]+r[x-2]+s[y-1][x]+s[y+1][x]).match`[v<>^]`?++l:t+=(f=r[x-4]=r[x+4]=s[y-3][x]=s[y+3][x]=r[x]=1))),f=l=0);alert(t+' '+l)}

// Less golfed
U=s=>{
  s=`\n\n\n${s}\n\n\n`.split`\n`.map(r=>[...r])
  t=0
  do {
    f=l=0
    s.forEach((r,y) => {
      r.forEach((c,x) => {
        if (c == '#')
        {
          if (!(r[x+2] == '<' || r[x-2] == '>' || s[y-1][x] == 'v' || s[y+1][x] == '^'))
            t+=(f=r[x-4]=r[x+4]=s[y-3][x]=s[y+3][x]=r[x]=1)
          else
            ++l
        }
      })
    })
  } while(f)
  alert(t+' '+l)
}  

//Test

// Redefine console.log
alert=(...x)=>O.innerHTML+=x+'\n'

test=[`
# --> # --> #
      ^     |
      |     |
      |     v
      # <-- #`
,`
            # --> # --> #
            ^           |
            |           |
            |           v
      # --> # <-- #     # --> #
      ^           ^           |
      |           |           |
      |           |           v
# --> #           # <-- # <-- #`
,`
# --> # --> # --> #
^     ^           |
|     |           |
|     |           v
#     # <-- # <-- #`      
]

test.forEach(t=>(alert(t),F(t)))

<pre id=O></pre>

Comments

... प्रसार ऑपरेटर सही है? आप इसे इस तरह से नाम देना चाहते हैं क्योंकि यह अन्य सिंटैक्स द्वारा अन्य भाषाओं (जैसे ग्रूवी) में मौजूद है (*: ग्रूवी के लिए सूची)। वैसे भी अच्छा समाधान!

— हारून

+1 मैं सोच रहा था कि 'ऐसा करने के लिए एक स्मार्ट तरीका होना चाहिए', इस समाधान के साथ आया, केवल इस उत्तर को नीचे स्क्रॉल करने के लिए।

— सेंचुरी

Answer 2

रूबी, 287 278 बाइट्स

->i{n={}
g=->x{n[x]||=[0,p]}
t=y=0
i.lines{|l|x=0
l.chars{|c|x+=1
'><'[c]&&(r=c.ord-61;s,d=[y,x-4*r],[y,x+2*r])
'^v'[c]&&(r=c<?_?1:-1;s,d=[y+r*3,x],[y-r,x])
s&&(g[s][1]=g[d])[0]+=1}
y+=1}
c,*_,s=n.values.sort_by{|v|v[0]}
l=n.size
s[0]>1?((t+=1;c=c[1])while c!=s):t=l-=1
[t,l-t]}

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

यह नोड्स का हैश (शब्दकोश) बनाता है। प्रत्येक नोड के लिए, आने वाले कनेक्शन की संख्या और (संभवतः नल) अगले नोड को संग्रहीत किया जाता है।

आखिरकार:

• यदि 2 आवक कनेक्शन (जिसका अर्थ लूप नहीं है) के साथ कोई नोड नहीं है, तो पूंछ के लिए 0 और लूप के लिए मौजूदा नोड की संख्या वापस करें।
• अन्यथा, अगले आने वाले कनेक्शनों (प्रारंभ) के साथ नोड से पुनरावृति शुरू करें -> ...-> अगले जब तक कि 2 आने वाले कनेक्शन (लूप स्टार्ट) के साथ नोड तक नहीं पहुंच जाता है। उपयुक्त गणनाएँ लौटाएँ।

कोड का पठनीय संस्करण यहां उपलब्ध है ।

Answer 3

रूबी, 276

->s{a=k=w=s.index(r='
')*2+2
s=r*w+s+r*w
(s.size).times{|i|s[i,2]=='
#'&&(s[3+j=i+1]+s[j+w]+s[j-w]).strip.size<2&&(a=[j]
d=0
loop{("|-|-"[d])+?#=~/#{s[k=j+[-w,3,w,-3][d]]}/?(a.include?(k)&&break;a<<(j=k);d-=1):d=(d+1)%4}
)}
u=a.size
v=a.index(k)
t=(u-v)/4*2
print u/2-t," ",t}