यह कार्य प्रथम आवधिक प्रीमियर प्रोग्रामिंग पहेली पुश का हिस्सा है ।
आपको निम्न प्रारूप में वस्तुओं का एक पदानुक्रम मिलता है:
2
Hat
1
Gloves
जिसे बॉक्स में डालने की जरूरत है, जैसे:
.------------.
| Hat |
| .--------. |
| | Gloves | |
| '--------' |
'------------'
इनपुट फॉर्मेट में नंबर एक बॉक्स को शुरू करते हैं, जितने नंबर निर्दिष्ट होते हैं उतने आइटम के साथ। पहले बॉक्स में दो आइटम होते हैं (टोपी और वह बॉक्स जिसमें दस्ताने होते हैं), दूसरे में केवल एक ही आइटम होता है - दस्ताने।
जैसा कि देखा जा सकता है, बक्से बक्से के अंदर भी रह सकते हैं। और वे हमेशा गोल होते हैं ... जैसे (नुकीले कोने एक घाव का खतरा होते हैं और हम ऐसा नहीं चाहेंगे)।
नीचे उन लोगों के लिए बुरा विवरण दिया गया है जो विनिर्देशन देता है हर छोटे से छोटे रास्ते का उपयोग करना चाहते हैं। आप पर ध्यान दें, युक्ति को न पढ़ना गलत समाधान प्रस्तुत करने का कोई बहाना नहीं है। बहुत अंत में एक परीक्षण स्क्रिप्ट और कुछ परीक्षण मामले हैं।
विशिष्टता
निम्नलिखित पात्रों से बक्से बनाए जाते हैं:
|(U + 007C) का उपयोग ऊर्ध्वाधर किनारों के निर्माण के लिए किया जाता है।-(U + 002D) का उपयोग क्षैतिज किनारों के निर्माण के लिए किया जाता है।'(U + 0027) गोल निचले कोने हैं।.(U + 002E) गोल ऊपरी कोने हैं।
एक बॉक्स इस तरह दिखता है:
.--. | | '--'ध्यान दें कि जबकि यूनिकोड में गोल कोने और उचित बॉक्स-ड्राइंग वर्ण हैं, यह कार्य केवल ASCII में है। जितना मैं यूनिकोड से प्यार करता हूँ मुझे एहसास है कि वहाँ भाषाएँ और वातावरण हैं जो पिछले दूसरे दशक में काफी नहीं आए थे।
बक्से में उन वस्तुओं का अनुक्रम हो सकता है जो या तो पाठ या अन्य आइटम हैं। एक बॉक्स में व्यक्तिगत आइटम ऊपर से नीचे तक प्रदान किए जाते हैं। अनुक्रम A, B, C इस प्रकार प्रस्तुत करता है:
.---. | A | | B | | C | '---'यह निश्चित रूप से नेस्टेड बॉक्स पर भी लागू होता है, जो पाठ की तरह एक आइटम हैं। तो अनुक्रम ए, बी, बॉक्स (सी, बॉक्स (डी, ई)), एफ निम्नानुसार प्रस्तुत करेगा:
.-----------. | A | | B | | .-------. | | | C | | | | .---. | | | | | D | | | | | | E | | | | | '---' | | | '-------' | | F | '-----------'बक्से अपने आकार को सामग्री में समायोजित करते हैं और नेस्टेड बक्से हमेशा अपने माता-पिता के आकार तक विस्तारित होते हैं। सामग्री से पहले और बाद में हमेशा एक स्थान होता है, ताकि न तो पाठ और न ही नेस्टेड बॉक्स बाहरी बॉक्स के किनारे के बहुत करीब हों। संक्षेप में, निम्नलिखित गलत है:
.---. |Box| '---'और निम्नलिखित सही है:
.-----. | Box | '-----'बहुत अच्छा लग रहा है, :-)
पाठ आइटम ( नीचे इनपुट देखें) को बिल्कुल पुन: प्रस्तुत करना होगा।
हमेशा एक एकल शीर्ष-स्तरीय बॉक्स (cf. XML) होता है। हालाँकि, एक बॉक्स में कई अन्य बॉक्स हो सकते हैं।
इनपुट
इनपुट मानक इनपुट पर दिया गया है; किसी फ़ाइल से रीडायरेक्ट की जाने वाली आसान जांच के लिए।
इनपुट को लाइन-वार दिया जाता है, जिसमें प्रत्येक लाइन को वर्तमान बॉक्स में डालने के लिए टेक्स्ट आइटम का प्रतिनिधित्व करता है या एक नया बॉक्स खोलता है।
हर लाइन को एक लाइन ब्रेक द्वारा समाप्त किया जाता है।
टेक्स्ट आइटम को एक पंक्ति द्वारा चिह्नित किया जाता है जिसमें एक संख्या नहीं होती है (नीचे देखें)। पाठ वर्णमाला वर्ण, स्थान और विराम चिह्न (
.,-'"?!()) का उपयोग करता है । पाठ एक स्थान के साथ शुरू या समाप्त नहीं होगा और इसमें हमेशा कम से कम एक वर्ण होगा।एक बॉक्स एकल पंक्ति से शुरू होता है जिसमें एक संख्या होती है। संख्या बॉक्स का आकार बताती है, अर्थात निम्नलिखित आइटमों की संख्या जो इसमें डाली जाती है:
2 A Bदो टेक्स्ट आइटम के साथ एक बॉक्स देता है:
.---. | A | | B | '---'एक बॉक्स में हमेशा कम से कम एक आइटम होगा।
बक्से का अंत स्पष्ट रूप से एक पंक्ति के साथ चिह्नित नहीं है; इसके बजाय बक्सों को स्पष्ट रूप से बंद कर दिया जाता है क्योंकि उनमें निर्दिष्ट संख्या में आइटम डाल दिए जाते हैं।
एक बॉक्स हमेशा केवल एक आइटम होता है, भले ही इसमें कितने आइटम हों। उदाहरण के लिए
3 A 4 a b c d Bएक बॉक्स में तीन आइटम होंगे, जिनमें से दूसरा एक बॉक्स होगा जिसमें चार आइटम होंगे।
नेस्टिंग इस तथ्य को भी प्रभावित नहीं करता है कि एक बॉक्स सिर्फ एक आइटम है।
सीमाएं
अधिकतम घोंसले का स्तर पांच है । यानी एक-दूसरे के अंदर अधिकतम पांच बक्से हैं। इसमें सबसे बाहरी भी शामिल है।
प्रति बॉक्स में अधिकतम दस आइटम हैं।
पाठ आइटम में अधिकतम 100 वर्ण हैं।
उत्पादन
- आउटपुट रेंडर बॉक्स है जिसमें ऊपर उल्लिखित नियमों के अनुसार सभी युक्त और नेस्टेड आइटम शामिल हैं।
- आउटपुट मानक आउटपुट पर दिया जाना चाहिए और इसे बिल्कुल मिलान करना होगा। किसी भी अग्रणी या अनुगामी व्हाट्सएप की अनुमति नहीं है।
- प्रत्येक पंक्ति को अंतिम सहित लाइन ब्रेक के साथ समाप्त किया जाना चाहिए।
जीतने की स्थिति
- सबसे छोटा कोड जीतता है (अर्थात स्वीकृत उत्तर मिलता है)।
नमूना इनपुट 1
3
This is some text!
Oh, more text?
Just text for now, as this is a trivial example.
नमूना उत्पादन 1
.--------------------------------------------------.
| This is some text! |
| Oh, more text? |
| Just text for now, as this is a trivial example. |
'--------------------------------------------------'
नमूना इनपुट 2
4
Extreme
nesting
3
of
boxes
4
might
lead
to
2
interesting
1
visuals.
Indeed!
नमूना आउटपुट 2
.--------------------------.
| Extreme |
| nesting |
| .----------------------. |
| | of | |
| | boxes | |
| | .------------------. | |
| | | might | | |
| | | lead | | |
| | | to | | |
| | | .--------------. | | |
| | | | interesting | | | |
| | | | .----------. | | | |
| | | | | visuals. | | | | |
| | | | '----------' | | | |
| | | '--------------' | | |
| | '------------------' | |
| '----------------------' |
| Indeed! |
'--------------------------'
नमूना इनपुट 3
1
1
1
1
1
Extreme nesting Part Two
नमूना आउटपुट 3
.------------------------------------------.
| .--------------------------------------. |
| | .----------------------------------. | |
| | | .------------------------------. | | |
| | | | .--------------------------. | | | |
| | | | | Extreme nesting Part Two | | | | |
| | | | '--------------------------' | | | |
| | | '------------------------------' | | |
| | '----------------------------------' | |
| '--------------------------------------' |
'------------------------------------------'
नमूना इनपुट 4
3
Foo
2
Bar
Baz
2
Gak
1
Another foo?
नमूना उत्पादन 4
.----------------------.
| Foo |
| .------------------. |
| | Bar | |
| | Baz | |
| '------------------' |
| .------------------. |
| | Gak | |
| | .--------------. | |
| | | Another foo? | | |
| | '--------------' | |
| '------------------' |
'----------------------'
टेस्ट स्क्रिप्ट
चूंकि विवरण प्राप्त करना सही हो सकता है इसलिए कई बार हम ( वेंटरो और मेरे) ने एक परीक्षण स्क्रिप्ट तैयार की है जो आप सही है या नहीं यह जांचने के लिए अपना समाधान चला सकते हैं। यह पॉवरशेल स्क्रिप्ट और बैश स्क्रिप्ट दोनों के रूप में उपलब्ध है । मंगलाचरण है: <test-script> <program invocation>।
अद्यतन: परीक्षण लिपियों को अद्यतन किया गया है; कई परीक्षण मामले थे जिन्होंने मेरे द्वारा परिभाषित सीमाओं का सम्मान नहीं किया। पॉवरशेल परीक्षण स्क्रिप्ट ने परिणाम की जाँच के लिए केस-संवेदी तुलना का उपयोग नहीं किया। मुझे उम्मीद है कि अब सब कुछ ठीक है। परीक्षण मामलों की संख्या घटाकर 156 कर दी गई, हालांकि अब अंतिम एक काफी ... बड़ा है।
अद्यतन 2: मैंने अपना परीक्षण-केस जनरेटर अपलोड किया । C # में लिखा है , .NET 2 रनटाइम को लक्षित कर रहा है। यह मोनो पर चलता है। यह लोगों को उनके कार्यान्वयन का परीक्षण करने में मदद कर सकता है। एक निश्चित सबसे खराब स्थिति के रूप में आप जिस कार्य को करने की कोशिश कर सकते हैं, उसमें सीमाएँ दी गई हैं:
nb.exe 1 10 10 5 100 100 | my invocation
जो केवल अंतरतम स्तर तक बक्से उत्पन्न करेगा और प्रति बॉक्स अधिकतम आइटम और पाठ आइटम की अधिकतम लंबाई दोनों का उपयोग करेगा। मैंने इस टेस्ट केस को टेस्ट स्क्रिप्ट में शामिल नहीं किया, हालाँकि, यह काफी बड़ा है और आउटपुट भी बड़ा है।
अद्यतन 3: मैंने पॉवरशेल परीक्षण स्क्रिप्ट को अद्यतन किया था, जो इस बात पर निर्भर करती थी कि स्क्रिप्ट में लाइन एंडिंग कैसे होती है और प्रिंट की गई समाधान क्या लाइन समाप्त होती है। अब यह दोनों के लिए अज्ञेय होना चाहिए। भ्रम के लिए फिर से क्षमा करें।