एक ग्रिड पर अस्पष्ट स्थान

Question

आपके पास चार दूरी सेंसर के साथ थोड़ा सा रोबोट है। यह एक कमरे के लेआउट को जानता है, लेकिन इसमें ग्रिड ओरिएंटेशन पर लॉक करने में सक्षम होने के अलावा अन्य अभिविन्यास की कोई भावना नहीं है। आप यह पता लगाना चाहते हैं कि रोबोट रीडिंग पर आधारित कहां है, लेकिन यह सीमित सेंसर के कारण अस्पष्ट हो सकता है।

चुनौती का स्पष्टीकरण

आपको एक कमरे का लेआउट और चार घड़ी की दूरी की रीडिंग दी जाएगी, जो आपके और एक दीवार के बीच की कोशिकाओं की संख्या देगा। कमरे के बीच में दीवारें हो सकती हैं और ग्रिड के किनारे भी दीवारें हैं। रोबोट को एक दीवार के ऊपर नहीं रखा जा सकता है।

आपका उद्देश्य कमरे के भीतर उन सभी स्थानों को सूचीबद्ध करना है जिनमें रोबोट हो सकता है जो दिए गए रीडिंग देगा। ध्यान रखें कि रोबोट में अभिविन्यास का कोई मतलब नहीं है (ग्रिड पर 90 डिग्री कोण पर बंद होने के अलावा- यानी रोबोट कभी भी तिरछे या कुछ अन्य तिरछा कोण से उन्मुख नहीं होगा), इसलिए [1, 2, 3,] का पढ़ना 4], उदाहरण के लिए, [3, 4, 1, 2] को पढ़ने के समान है।

उदाहरण

इन उदाहरणों के लिए, सेल-निर्देशांक शीर्ष-बाएँ सेल से 0-अनुक्रमित (x, y) जोड़े के रूप में दिया जाएगा। एक वर्ग कोष्ठक सूची में दक्षिणावर्त क्रम में रीडिंग दी जाएगी। खाली कक्ष का प्रतिनिधित्व करने के लिए लेआउट दीवारों और अन्य पात्रों (आमतौर पर डॉट्स) के लिए पाउंड संकेतों का उपयोग करेंगे।

मामला एक

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

• [१, ०, २, ३] ==> (१, ०), (३, १)
• [0, 0, 3, 3] ==> (0, 0), (3, 0), (0, 3), (3, 3)
• [२, १, १, ०] ==> (०, २), (२, १)
• [१, १, २, २] ==> (१, १)

केस 2

# a . # a .
a # . . # a
. . # . . #
# . . # . .
a # . . # a
. a # . a #

• [०, ०, १, १] ==> ग्रिड पर प्रत्येक स्थिति जो एक बिंदु है
• [१, ०, ०, ०] ==> सभी ग्रिड पर हैं

केस 3

.

• [0, 0, 0, 0] ==> (0, 0)

केस 4

. # #
. . .

• [१, २, ०, ०] ==> (०, १)
• [0, 1, 2, 0] ==> (0, 1)
• [0, 0, 1, 0] ==> (0, 0)
• [१, ०, १, ०] ==> (१, १)
• [०, १, ०, १] ==> (१, १)

केस 5

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

• [२, १, १, ०] ==> (०, २), (२, १)
• [०, २, २, १] ==> (१, १)
• [१, ०, २, २] ==> (१, १)
• [0, 3, 0, 0] ==> (0, 0)
• [१, ०, १, १] ==> (१, २)

अन्य नियम

• इनपुट किसी भी सुविधाजनक प्रारूप में हो सकता है। इनपुट दीवारों और स्थानों का एक ग्रिड है और दक्षिणावर्त क्रम में चार दूरियों की सूची है।
• आउटपुट या तो सभी कोशिकाओं की एक सूची हो सकती है जो रीडिंग को संतुष्ट करती है या ग्रिड के एक संशोधित संस्करण को दिखाती है कि कौन से सेल रीडिंग को संतुष्ट करते हैं। आउटपुट का सटीक प्रारूप तब तक मायने नहीं रखता है जब तक यह उचित और सुसंगत हो। मान्य आउटपुट स्वरूप शामिल हैं, लेकिन इन तक सीमित नहीं हैं :
  • प्रत्येक सेल के लिए एक लाइन प्रिंट करना एक ऑर्डर की गई जोड़ी के रूप में समन्वयित होता है
  • साथ ग्रिड मुद्रण ., #और !अंतरिक्ष, दीवारों, और संभावित स्थानों, क्रमशः के लिए।
  • आदेशित जोड़े की सूची लौटाते हुए
  • अनुक्रमणिका की सूची लौटाता है
  • रिक्त स्थान, दीवारों और संभावित स्थानों के लिए विभिन्न मूल्यों का उपयोग करके सूचियों की सूची लौटाएं
  • रीडिंग होने वाली कोशिकाओं का प्रतिनिधित्व करने के लिए 1s का उपयोग करके 0s और 1s के एक मैट्रिक्स को वापस / प्रिंट करें। (दीवारों को शामिल करना आवश्यक नहीं है)
  • एक बार फिर, यह सूची संपूर्ण नहीं है, इसलिए अन्य अभ्यावेदन तब तक मान्य हैं जब तक वे सुसंगत हैं और ग्रिड या सूची में हर संभव मान्य स्थान दिखाते हैं। यदि आप अनिश्चित हैं, तो एक टिप्पणी छोड़ दें और मुझे स्पष्ट करने में खुशी होगी।
• आप मान सकते हैं कि रीडिंग ग्रिड पर कम से कम एक स्थान से मेल खाती है।
• आप मान सकते हैं कि इनपुट ग्रिड आकार में कम से कम 1x1 है और इसमें कम से कम एक खाली जगह है।
• आप मान सकते हैं कि इनपुट ग्रिड प्रत्येक आयाम में 256 कोशिकाओं से बड़ा नहीं है।
• आप मान सकते हैं कि इनपुट ग्रिड हमेशा एक सही आयत है और दांतेदार नहीं है।
• यदि आपके प्रोग्राम में अमान्य इनपुट के लिए सेन आउटपुट देने के लिए कोई जुर्माना या बोनस नहीं है।
• यह कोड गोल्फ है, इसलिए सबसे छोटा कोड जीतता है।

Comments

के लिए testcases Case 5काफी सही नहीं लगते हैं। मैं (0,2),(2,1), (1,3), (1,3), और nothing।

— TFeld

@TFeld धन्यवाद फिक्स्ड।

— बीफस्टर

@ अर्नुलड मुझे उचित लगता है। मैं इसे पहले से मौजूद गैर-संपूर्ण सूची में जोड़ दूंगा।

— बीफस्टर

Answer 1

जावास्क्रिप्ट (ईएस 6),  130 128 126  125 बाइट्स

$(m)(l)$$m$$0$$1$$l$

$1$

m=>l=>m.map((r,y)=>r.map((v,x)=>v&!!([...'3210321'].map(d=>(g=X=>(m[Y+=~-d%2]||0)[X+=(d-2)%2]?1+g(X):0)(x,Y=y))+g).match(l)))

इसे ऑनलाइन आज़माएं! (पठनीयता के लिए पोस्ट-प्रोसेसेड आउटपुट के साथ)

टिप्पणी की गई

m => l =>                         // m[] = layout matrix; l[] = list of distances
  m.map((r, y) =>                 // for each row r[] at position y in m[]:
    r.map((v, x) =>               //   for each cell v at position x in r[];
      v &&                        //     yield 0 if v = 0
      !!(                         //     otherwise, test whether we can find l[] within a
        [...'3210321']            //     list containing twice the results of the sensors
        .map(d =>                 //       for each direction d:
          (g = X => (             //         g = recursive function taking X
              m[Y += ~-d % 2]     //         add dy[d] to Y
              || 0                //         use a dummy object if we're out of the board
            )[X += (d - 2) % 2] ? //         add dx[d] to X; if (m[Y] || 0)[X] is equal to 1:
              1 +                 //           add 1 to the final result
              g(X)                //           and do a recursive call
            :                     //         else:
              0                   //           yield 0 and stop recursion
          )(x, Y = y)             //         initial call to g with X = x and Y = y
        )                         //       end of map() over directions
        + g                       //       coerce the result to a comma-separated string,
                                  //       followed by harmless garbage
      ).match(l)                  //     test whether l[] can be found in this string
                                  //     (l[] is implicitly coerced to a string as well)
    )                             //   end of map() over r[]
  )                               // end of map() over m[]

Answer 2

पायथन 2 , 234 202 200 191 बाइट्स

lambda m,a:[(i,j)for j,l in e(m)for i,c in e(l)if('#'<c)*[(''.join(L)[::-1]+'#').find('#')for L in l[:i],zip(*m)[i][:j],l[:i:-1],zip(*m)[i][:j:-1]]in[a[q:]+a[:q]for q in 0,1,2,3]]
e=enumerate

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

Answer 3

चारकोल , 42 बाइट्स

ＰθＦθ¿⁼¶ι⸿¿№Ｅ⁴Ｅ⁴⊖⌕⁺⪫ＫＤ⊕⌈η✳§⟦→↓←↑⟧⁺κμω#¦#η!ι

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। चारकोल किसी कारण के लिए आउटपुट में कुछ पैडिंग जोड़ रहा है; मुझे लगता है कि यह चारकोल में एक बग है। स्पष्टीकरण:

Ｐθ

कर्सर को स्थानांतरित किए बिना मानचित्र प्रिंट करें।

Ｆθ

नक्शे में प्रत्येक वर्ण पर लूप।

¿⁼¶ι⸿

यदि यह एक नई रेखा है तो कर्सर को अगली पंक्ति के प्रारंभ में ले जाएं।

⊖⌕⁺⪫ＫＤ⊕⌈η✳§⟦→↓←↑⟧⁺κμω#¦#

दिशा में दीवार से दूरी का पता लगाएं k+m।

¿№Ｅ⁴Ｅ⁴...η!ι

सभी चार प्रारंभिक दिशाओं पर लूप करें k, सभी चार दक्षिणावर्त दिशाओं में झांकें m, और यदि परिणाम में दूसरा इनपुट शामिल है, तो !अन्यथा वर्तमान चरित्र प्रिंट करें।