लंबाई की सूची, और उन लंबाई का प्रतिनिधित्व करने वाले एक स्ट्रिंग को देखते हुए, क्या वे मेल खाते हैं?


16

लंबाई की सूची का प्रतिनिधित्व करने वाले एक पैटर्न और उन लंबाई का प्रतिनिधित्व करने वाले एक स्ट्रिंग को देखते हुए, क्या वे मेल खाते हैं?

उन दिलचस्पी के लिए, इस की पुष्टि करने अगर एक पंक्ति या एक स्तंभ के लिए सवाल बराबर है Nonogram सही हो सकता है। हालाँकि, मैंने इन पहेली से अपरिचित लोगों के लिए सवाल को कम भ्रमित करने के लिए नॉनोग्राम से संबंधित सभी भाषा को छोड़ दिया है।

इनपुट

डेटा की दो लाइनें, एक नई रेखा से अलग हो जाती हैं।

  1. पहली पंक्ति पूर्णांक की अंतरिक्ष से अलग सूची होगी, उदाहरण:

    3 6 1 4 6
    

    यह रेखा पूर्णांक सूची के बराबर आकार के भरे हुए स्थानों के पैटर्न का वर्णन करती है , जिसे अज्ञात , सकारात्मक लंबाई के रिक्त स्थानों द्वारा अलग किया जाता है जो दूसरी पंक्ति से मेल खाना चाहिए। मिलान किए गए स्ट्रिंग की शुरुआत और अंत में खाली स्थान भी हो सकते हैं।

  2. दूसरी लाइन एक ऐसी लाइन होगी जो लाइन एक में पैटर्न से मेल खा सकती है या नहीं। यह पूरी तरह से होते हैं #, xऔर _। यह रेखा कम से कम पहली पंक्ति में पूर्णांकों के योग के रूप में कम से कम होने की गारंटी है , साथ ही अलग पूर्णांकों की संख्या, शून्य 1, और लंबी हो सकती है। तो इस मामले में दूसरी पंक्ति कम से कम , या 24 वर्ण लंबी होने की गारंटी है । यहाँ एक उदाहरण 24 वर्ण रेखा है जो पहली पंक्ति में पैटर्न से मेल खाता है:(3+6+1+4+6) + (5) - 1

    ###_######_#_####_######
    

प्रतीकों का अर्थ:

  • # यह एक भरे हुए बॉक्स का प्रतिनिधित्व करता है
  • x यह "खाली होने की गारंटी" के रूप में चिह्नित एक बॉक्स का प्रतिनिधित्व करता है
  • _ यह एक अज्ञात / अचिह्नित बॉक्स का प्रतिनिधित्व करता है।

लक्ष्य

विचार यह है:

  1. पुष्टि करें कि दूसरी पंक्ति एक वैध पंक्ति हो सकती है जो पहली पंक्ति के पैटर्न से मिलती है।
    • आपको एक अस्पष्ट त्रुटि संदेश प्रिंट करना होगा (आप इसे कैसे चुनते हैं यह आप पर निर्भर करता है; नीचे दिए गए उदाहरण लिखते हैं ERRORलेकिन इसमें उन 5 वर्णों की आवश्यकता नहीं है) यदि अज्ञात रिक्त स्थान को पहले से मिलान नहीं किया जा सकता है #या xपहले से मिलान नहीं किया जा सकता है लाइन।
  2. पूर्णांक के शून्य-अनुक्रमित सूचकांकों को प्रिंट करें, जिन्हें पूरी तरह से पंक्ति में रखा गया है, अंतरिक्ष सीमांकित। यदि अस्पष्टता है, तो सूचकांक को प्रिंट करें

उदाहरण:

Input:                    |  Output:    |  Reason:
--------------------------------------------------------------------------
3 6 1 4 6                 | 0 1 2 3 4   |  This is a complete string that 
###x######x#x####x######  |             |  matches perfectly.
--------------------------------------------------------------------------
1 2 1                     | 0 1 2       |  There is no ambiguity which filled cells 
#____xx___##__x_#         |             |  correspond to which parts of the pattern.
--------------------------------------------------------------------------
1 2 1                     |             |  I don't know whether the filled block is
____#___x                 |             |  part of the 1, 2, or 1, so output nothing.
--------------------------------------------------------------------------
1 2 1                     | ERROR       | The first unknown cell will create a block that
#_#x_#                    |             | matches either 1 1 or 3, but not 1 2.
--------------------------------------------------------------------------
1 2 1                     | 0 2         | Even though we know where all the filled cells
#____#                    |             | must be, only 0 and 2 are actually filled here.
--------------------------------------------------------------------------
1 1 1 1                   |             | There are so many possible ways to do fill this,
__#_______#____           |             | we don't know which indices are actually matched.
--------------------------------------------------------------------------
4 4                       |             | Again, we don't know WHICH 4 is matched here, 
______x####________       |             | so output nothing.
--------------------------------------------------------------------------
4 4                       | 0           | However, here, there's no room for a previous 4,
__x####________           |             | so the displayed 4 must be index 0.
--------------------------------------------------------------------------
3                         | ERROR       | We can't fit a 3 into a space before or after
__x__                     |             | the x, so this is impossible to match.
--------------------------------------------------------------------------
5 1 3                     | 0           | While we can match the 5, we don't know whether
x#####x____#____          |             | the single block matches the 1 or the 3.
--------------------------------------------------------------------------
3 2 3                     | 1           | The two has been completely placed,
____##x##____             |             | even though we don't know which it is.

नियम:

आप एक प्रोग्राम या फ़ंक्शन लिख सकते हैं , जो इनपुट को एक नईलाइन सीमांकित स्ट्रिंग के रूप में या एसटीडीआईएन (या निकटतम विकल्प) से प्राप्त करता है, और आउटपुट को अंतरिक्ष सीमांकित स्ट्रिंग के रूप में देता है या इसे STDOUT (या निकटतम विकल्प) पर मुद्रित करता है। आप वैकल्पिक रूप से आउटपुट में एक एकल अनुगामी न्यूलाइन शामिल कर सकते हैं।

इसके अतिरिक्त, मानक कमियां जो अब हास्यास्पद नहीं हैं पर प्रतिबंध लगा दिया गया है


1
यह नॉनोग्राम्स को हल करने के लिए है, है ना? यह नौगामों का उल्लेख करने में मदद कर सकता है क्योंकि इससे चुनौती उन लोगों के लिए तत्काल समझ में आती है जो उन्हें हल करते हैं।
xnor

@ jimmy23013 ने प्रतिक्रिया में संपादित किया।
ड्यूर्रोन 597

जवाबों:


5

पर्ल, 134 बाइट्स

(1 स्विच शामिल है)

perl -pe '$p.="([#_]{$_})[x_]+"for@l=split;chop$p,$_=<>;/^[x_]*$p*$(?{$h[$_-1].=$$_ for 1..@l})(?!)/;$_=@h?join$",grep{$h[$_]!~/_/}0..$#l:ERROR'

STDIN से इनपुट की दो लाइनें लेता है। प्रत्येक इनपुट के लिए फिर से निष्पादित किया जाना चाहिए।

विचार पहले सभी संभव पैटर्न निकालने के लिए है जो दी गई लंबाई से मेल खाते हैं। उदाहरण के लिए, यदि हमारे पास लंबाई 1 2और पैटर्न है #_x_#_, तो मिलान पैटर्न हैं (#, _#)और (#, #_)। फिर, प्रत्येक सूचकांक के लिए मिलान किए गए पैटर्न को संक्षिप्त करें - उदाहरण के लिए परिणाम सूची है (##, _##_)। अब, सूची के सभी तारों के सूचकांकों को प्रिंट करें जिनमें केवल '#' अक्षर हैं।

मुझे यहां पर्ल में रेगेक्स से सभी संभावित मैचों को निकालने की विधि मिली ।


ठंडा। आप एक ungolfed संस्करण और एक ideone लिंक जोड़ सकते हैं कृपया?
ड्यूरोन 597

निश्चित रूप से, मैंने अपने उत्तर के अंत में लिंक जोड़ दिया है।
svsd

एक गोल्फ कोड स्निपेट कितना भयानक लग सकता है इसका सच्चा उदाहरण! कम से कम मेरे लिए।
अर्जुन

1
@ अर्जुन गोल्फ कोड को बाधित करता है। वहाँ गोल्फ कोड में सुंदरता है, लेकिन केवल अगर आप जानते हैं कि यह भाषा में लिखा है पता है।
svsd

1
मैंने एक नया उदाहरण जोड़ा क्योंकि समस्या वर्णन में एक परिदृश्य अभी भी अस्पष्ट था। सौभाग्य से, आपका कार्यक्रम अभी भी उस मामले में भी सही ढंग से काम करता है।
ड्यूर्रोन 597
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.