यह चुनौती अप्रैल 2018 लोटम चैलेंज के हिस्से के रूप में पोस्ट की गई थी , साथ ही ब्रेन-फ्लैक के दूसरे जन्मदिन के लिए भी
मैं इस बारे में सोच रहा था कि मस्तिष्क-फ्लैक कार्यक्रमों को एन्कोड करने का सबसे कुशल तरीका क्या होगा। स्पष्ट बात यह है कि, केवल 8 मान्य वर्ण हैं, प्रत्येक वर्ण को 3-बिट अनुक्रम में मैप करना है। यह निश्चित रूप से बहुत प्रभावी है, लेकिन यह अभी भी बहुत बेमानी है। ब्रेन-फ्लैक कोड की कुछ विशेषताएं हैं जिनका उपयोग हम एन्कोडिंग को छोटा करने के लिए कर सकते हैं।
निलाड्स, जो सभी 2 मिलान वाले ब्रैकेट द्वारा दर्शाए जाते हैं, वास्तव में 2 के बजाय सूचना की एक एकल इकाई के रूप में कार्य करते हैं। यदि हम प्रत्येक ब्रैकेट को एक एकल बाइट चरित्र के साथ बदल देते हैं, तो यह बिना किसी डेटा को खोए एन्कोडिंग को बहुत छोटा कर देगा।
यह एक कम स्पष्ट है, लेकिन भिक्षुओं के समापन बाइट्स भी बेमानी हैं। सोचें कि आप अनुमान लगा सकते हैं कि
'?'निम्नलिखित स्निपेट में कौन से अक्षर हैं?{(({}?<>?<>?यदि हम मानते हैं कि इनपुट वैध मस्तिष्क-फ्लैक कोड है, तो उन प्रत्येक प्रश्न चिह्न के लिए केवल एक ही विकल्प है। इसका मतलब यह है कि हम प्रत्येक समापन कोष्ठक का प्रतिनिधित्व करने के लिए एक करीबी सन्यासी चरित्र का उपयोग कर सकते हैं । यह चरित्र सेट को छोटा रखने का अतिरिक्त लाभ है, जो अगर हम एक हफ़मैन एन्कोडिंग का उपयोग करना चाहते हैं तो बहुत मदद करेगा। चूँकि क्लोज मोनाड चरित्र व्यापक रूप से सबसे आम चरित्र होगा, यह एक एकल बिट द्वारा प्रतिनिधित्व किया जा सकता है, जो बेहद कुशल है।
ये दो ट्रिक हमें निम्नलिखित एल्गोरिथ्म के माध्यम से मस्तिष्क-फ्लैक कोड को संपीड़ित करने देंगे:
एक मठ के हर समापन कोष्ठक से बदलें
|। या दूसरे शब्दों में, प्रत्येक समापन कोष्ठक को बदलें जो कि बार के साथ मैच खोलने से पहले नहीं है । इसलिए...(({})<(()()())>{})बन जाएगा
(({}|<(()()()||{}|इसे बंद करने वाले ब्रैकेट के साथ प्रत्येक निलाद को बदलें। इसलिए, उनमें से कुछ नहीं के साथ मिलान किए गए कोष्ठक निम्नलिखित मानचित्रण का उपयोग करते हैं:
() --> ) {} --> } [] --> ] <> --> >अब हमारा अंतिम उदाहरण बन गया है:
((}|<()))||}|अनुगामी
|वर्ण निकालें । क्योंकि हम जानते हैं कि सलाखों की कुल संख्या को({[<वर्णों की कुल संख्या के बराबर होना चाहिए , यदि अंत में बार गायब हैं, तो हम उन्हें अनुमान लगा सकते हैं। तो एक उदाहरण की तरह:({({})({}[()])})बन जाएगा
({(}|(}[)
आज के लिए आपकी चुनौती इस प्रक्रिया को उलट देना है।
केवल वर्णों वाले संपीड़ित मस्तिष्क-फ्लैक की एक स्ट्रिंग को देखते हुए (){}[]<>|, इसे मूल मस्तिष्क-फ्लैक कोड में विस्तारित करें। आप मान सकते हैं कि इनपुट हमेशा मान्य मस्तिष्क-फलक तक विस्तारित होगा। इसका मतलब है कि इनपुट के किसी भी उपसर्ग में वर्णों |से अधिक कभी नहीं होगा ({[<।
इनपुट में अनुगामी |वर्ण नहीं होंगे । इन्हें संदर्भ से अलग होना चाहिए।
हमेशा की तरह, आप या तो एक पूर्ण कार्यक्रम या एक फ़ंक्शन सबमिट कर सकते हैं, और इनपुट / आउटपुट प्रारूप अनुमत हैं। और चूंकि यह एक कोड-गोल्फ है , इसलिए आपके कोड को बाइट्स में स्रोत कोड की लंबाई से स्कोर किया जाएगा, स्कोर जितना छोटा होगा उतना बेहतर होगा।
परीक्षण के मामलों
यहाँ कुछ परीक्षण मामले हैं। यदि आप अधिक चाहते हैं, तो आप इस अजगर स्क्रिप्ट और ब्रेन-फ्लैक विकी के साथ अपने स्वयं के परीक्षण मामलों को उत्पन्न कर सकते हैं , जहां इन परीक्षण मामलों में से अधिकांश आते हैं।
#Compressed code
#Original code
())))
(()()()())
([([}()||||(>||{(})|>|}{((<}|||>}|}>}
([([{}(())])](<>)){({}())<>}{}{((<{}>))<>{}}{}<>{}
({(}|(}[)|||}
({({})({}[()])}{})
(((()))||(](((}}||(}([(((}))||||(]((}}|}|}}|||]||]|[))||(}))|}(}|(}]]|}
((((()()()))([]((({}{}))({}([((({}()())))]([](({}{}){}){}{})))[]))[])[()()])({}()()){}({})({}[][]){}