डॉट्स का पालन करें

Question

चुनौती

पात्रों के आयताकार ग्रिड को देखते हुए

ABCDE
FGHIJ
KLMNO
PQRST

और डॉट्स और रिक्त स्थान के समान आयामों के साथ एक ग्रिड

। । ।
  । । ।
  । ।  
  । । ।  

ऊपरी बाएँ कोने में शुरू ग्रिड के माध्यम से डॉट्स का पालन करके उत्पन्न स्ट्रिंग का उत्पादन। यह उदाहरण देगाABGLQRSNIJE

टिप्पणियाँ

• आप बहु-स्ट्रिंग के बजाय 2-सरणियों या अपनी भाषा में निकटतम विकल्प के रूप में इनपुट ग्रिड ले सकते हैं।
• आप रिक्त स्थान के बजाय अपनी भाषा के NULL मान का उपयोग कर सकते हैं। लेकिन आपको पथ को चिह्नित करने के लिए डॉट्स का उपयोग करना होगा।
• आपको रिक्त स्थान के साथ एक ही पंक्ति पर डॉट्स अलग करने की आवश्यकता नहीं है। मैंने उन्हें केवल पठनीयता के लिए जोड़ा।
• सबसे छोटे संभव ग्रिड का आकार 1x1 है।
• स्टार्ट और एंड डॉट में केवल एक पड़ोसी होगा। उनके बीच के बिंदुओं में हमेशा दो लंबवत या क्षैतिज पड़ोसी होंगे। यह गारंटी देता है कि रास्ता स्पष्ट नहीं है।
• रास्ता विकर्ण नहीं होगा।
• ग्रिड में वर्ण या तो सभी ऊपरी या निचले श्रेणी के वर्ण होंगे [a-z]जो आपके लिए सबसे सुविधाजनक हैं।
• रास्ता हमेशा ऊपरी बाएं कोने में शुरू होगा।

नियम

• कार्य या पूर्ण कार्यक्रम की अनुमति है।
• इनपुट / आउटपुट के लिए डिफ़ॉल्ट नियम ।
• मानक खामियां लागू होती हैं।
• यह कोड-गोल्फ है , इसलिए सबसे कम बाइट-काउंट जीतता है। टाईब्रेकर पहले जमा करना है।

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

ग्रिड # 1

ABCABCW
DEFGHUQ
XLUSDQZ
ASUKWXI
WUKOAIM
AIAIOUP

। ।          
  । । ।      
      ।      
। । । ।      
।            
।            
=> ABEFGSKUSAWA

। । । । । । ।
            ।
। । । ।
। । । ।
। ।
। । । । । । ।
=> ABCABCWQZIMPUOIAIAWAXLUUK

ग्रिड 2

पहले और दूसरे उदाहरण की दूसरी पंक्तियों में ट्रिपल रिक्त स्थान पर ध्यान दें।

एबी
सीडी

।  
   
=> ए

। ।
   
=> एबी

।  
। ।
=> एसीडी

ग्रिड # 3

ए

।
=> ए

हैप्पी कोडिंग!

Comments

क्या आप सुनिश्चित हैं कि ग्रिड # 1 के लिए दूसरा परीक्षण मामला सही है? मुझे लगता है कि आउटपुट होना चाहिए ABCABCUQXIUOIAIAWAXLUUK।

— तिजोरी

@vaultah संकेत के लिए थाक्स, इसे सही किया। ग्रिड में डॉट्स बाईं ओर दूर तक थे।

— डेन्कर

क्या हमें हर दूसरे वर्ण के साथ इनपुट को एक स्पेस के रूप में स्वीकार करने की आवश्यकता है, जैसा कि यहां है, या क्या यह केवल अक्षर और नईलाइन (और डॉट मैट्रिक्स में कोई अतिरिक्त स्थान नहीं) हो सकता है?

— msh210

@ msh210 जैसा कि चुनौती में कहा गया है, आप रिक्त स्थान के बजाय किसी प्रकार के NULL मान का उपयोग कर सकते हैं, निश्चित रूप से आप इनपुट को 2D सरणी के रूप में लेते हैं।

— डेन्कर

मेरा मतलब था, कुछ भी नहीं, एक अशक्त बाइट भी नहीं।

— msh210

Answer 1

एपीएल, 63 बाइट्स

{⍺[(⊂1 1){×≢⍵:⍺,(V/⍵)∇⍵/⍨~V←(+=⌊/)+/¨2*⍨⍺-⍵⋄⍺}1↓(,⍵='.')/,⍳⍴⍵]}

यह एक ऐसा फंक्शन है जो दो कैरेक्टर मैट्रिसेस लेता है (वे मैट्रिसेस होने चाहिए), कैरेक्टर ग्रिड उसके लेफ्ट तर्क के रूप में और डॉट्स ग्रिड उसके राइट लॉजिक के रूप में। डॉट्स का मैट्रिक्स वर्णों के मैट्रिक्स से छोटा हो सकता है।

स्पष्टीकरण:

• (,⍵='.')/,⍳⍴⍵: पंक्ति-स्तंभ क्रम में बिंदुओं की स्थिति प्राप्त करें
• 1↓: पहले वाले को छोड़ दो (यह जाना जाता है 1 1)
• (⊂1 1){... }: से शुरू होकर 1 1, निम्न फ़ंक्शन को चलाएं, जो पथ का अनुसरण करता है (इसका बाएं तर्क इसकी वर्तमान स्थिति है, इसका सही तर्क असमान स्थिति है)। यह हर बार सबसे नज़दीकी अनविसीड डॉट को चुनकर काम करता है। (यदि प्रश्न से मान्यताएं सही हैं, तो यह सही है)
  • ×≢⍵:: अगर अभी भी गैरकानूनी पद हैं:
    • +/¨2*⍨⍺-⍵: प्रत्येक स्थिति और वर्तमान स्थिति के बीच मैनहट्टन की दूरी का पता लगाएं
    • V←(+=⌊/): प्रत्येक स्थिति के लिए, देखें कि क्या इसकी दूरी सबसे छोटी दूरी के बराबर है, और इसे इसमें स्टोर करें V।
    • ⍵/⍨~: उन सभी पदों का चयन करें जिनके लिए यह मामला नहीं है, ये अगले दौरे के लिए क्षेत्र हैं
    • (V/⍵): स्थिति है जिसके लिए यह लगता है है के मामले में, यह अगले क्षेत्र हो जाएगा
    • ∇: इन नए तर्कों के साथ फ़ंक्शन को फिर से चलाएँ
    • ⍺,: परिणाम वर्तमान स्थिति है, बाकी सूची के लिए ऐसा करने के परिणाम के बाद
  • ⋄⍺: अन्यथा, बस वर्तमान स्थिति लौटाएं और बंद करें (यह अंतिम है)
• ⍺[... ]: प्रत्येक स्थिति के लिए, वर्ण ग्रिड में संबंधित तत्व का चयन करें।

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

      f←{⍺[(⊂1 1){×≢⍵:⍺,(V/⍵)∇⍵/⍨~V←(+=⌊/)+/¨2*⍨⍺-⍵⋄⍺}1↓(,⍵='.')/,⍳⍴⍵]}
      ⍝ example
      g0  ← 4 5⍴'ABCDEFGHIJKLMNOPQRST'
      d0  ← 4 5⍴'..  . . .. . .  ... '
      ⍝ test case 1
      g1  ← 6 7⍴'ABCACBWDEFGHUQXLUSDQZASUKWXIWUKOAIMAIAIOUP'
      d1a ← 6 7⍴'..      ...      .   ....   .      .      '
      d1b ← 6 7⍴'.......      ....   .. ..  ..     ........'
      ⍝ test case 2
      g2  ← 2 2⍴'ABCD'
      d2a ← 1 1⍴'.'
      d2b ← 1 2⍴'..'
      d2c ← 2 2⍴'. ..'
      ⍝ test case 3
      g3  ← 1 1⍴'A'
      d3  ← 1 1⍴'.'

      g0 f d0
ABGLQRSNIJE
      (⊂g1) f¨ d1a d1b
┌────────────┬─────────────────────────┐
│ABEFGSKUSAWA│ABCACBWQZIMPUOIAIAWAXLUUK│
└────────────┴─────────────────────────┘
      (⊂g2) f¨ d2a d2b d2c
┌─┬──┬───┐
│A│AB│ACD│
└─┴──┴───┘
      g3 f d3
A

Answer 2

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

c=>g=>c[l=~c.search`
`,i=p=0]+[...g].map(_=>i|!p?c[i=(d=n=>g[i-n-p?i-n:c]>" "&&(p=i)-n)(1)||d(-1)||d(l)||d(-l)]:"").join``

व्याख्या

ग्रिड को मल्टीलाइन स्ट्रिंग्स के रूप में लेता है।

एक सभ्य प्रयास की तरह लगता है लेकिन मैं समय से बाहर भाग गया जबकि गोल्फिंग तो यह शायद सुधार किया जा सकता है।

var solution =

c=>g=>
  c[                            // add the starting letter to the output
    l=~c.search`
`,                              // l = line length
    i=p=0                       // i = current index, p = previous index
  ]+
  [...g].map(_=>                // loop
    i|!p?                       // if we have not finished yet
      c[i=                      // find the next index and return it's letter
        (d=n=>                  // d = function to check for a dot at offset n
          g[
            i-n-p?i-n           // if i - n != p, get the character at index i - n
            :c                  // else get index "c" (will return undefined, not a dot)
          ]>" "                 // if the character is a dot
          &&(p=i)-n             // set p to i and return i - n
        )
        (1)||d(-1)||d(l)||d(-l) // search for the next adjacent dot
      ]
    :""                         // if we have finished, return no letter
  )
  .join``                       // output all the returned letters

<textarea id="Characters" rows="6" cols="30">ABCABCW
DEFGHUQ
XLUSDQZ
ASUKWXI
WUKOAIM
AIAIOUP</textarea>
<textarea id="Grid" rows="6" cols="30">.......
      .
...   .
. ..  .
.     .
.......</textarea><br />
<button onclick="result.textContent=solution(Characters.value)(Grid.value)">Go</button>
<pre id="result"></pre>

Answer 3

एपीएल (डायलॉग क्लासिक) , 43 बाइट्स

{⍺[11 9∘○¨{⍵∪⍺∩∊⍵+⊂0j1*⍳4}⍣≡∘⊃⍨0j1⊥¨⍸⍵=⊃⍵]}

इसे ऑनलाइन आज़माएं!