पर्ल, 1116 1124 बाइट्स, n = 3, स्कोर = 1124 ^ (2/3) या लगभग 108.1
अपडेट : मैंने अब सत्यापित किया है कि यह br = बल के माध्यम से n = 3 के साथ काम करता है (जिसमें कुछ दिन लगे); इस परिसर में एक कार्यक्रम के साथ, हाथ से विकिरण-प्रतिरोध की जांच करना कठिन है (और मैंने पिछले संस्करण में एक गलती की थी, यही वजह है कि बाइट की गिनती में वृद्धि हुई है)। अद्यतन समाप्त करें
मैं कहीं न कहीं आप इसे देख नहीं होगा कि stderr पुनर्निर्देशित करने की सलाह देते हैं; जब आप इसमें से वर्णों को नहीं हटा रहे हैं , तब भी यह प्रोग्राम संदिग्ध सिंटैक्स के बारे में चेतावनी देता है।
यह संभव है कि कार्यक्रम को छोटा किया जा सकता है। इस पर काम करना काफी दर्दनाक है, जिससे संभव सूक्ष्म अनुकूलन को याद करना आसान हो जाता है। मैं अधिक से अधिक हटाने योग्य वर्णों की संख्या को अधिक से अधिक प्राप्त करने का लक्ष्य बना रहा था (क्योंकि यह कार्यक्रम का वास्तव में चुनौतीपूर्ण हिस्सा है), और कोड-गोल्फ टाईब्रेक को कुछ ऐसा माना गया, जिसका लक्ष्य अच्छा था, लेकिन मैं ऐसा कुछ नहीं करूंगा। अनुकूलन में हास्यास्पद प्रयास (इस आधार पर कि दुर्घटना द्वारा विकिरण प्रतिरोध को तोड़ना बहुत आसान है)।
कार्यक्रम
नोट: _प्रत्येक चार घटनाओं के तुरंत पहले एक शाब्दिक नियंत्रण- चरित्र (ASCII 31) है -+। मुझे नहीं लगता कि इसे StackOverflow पर कॉपी-पेस्ट किया गया है, इसलिए आपको प्रोग्राम चलाने से पहले इसे फिर से जोड़ना होगा।
eval+<eval+<eval+<eval+(q(FoPqOlengthFoBBPP181XXVVVVJJJKKKNdoWchopJFtPDevalMODx4KNFrPIPA-MN-TUV-ZPINFsPIFoPqOI.Fo.IQNevalFoINevalIFsPZyI.Fr.IT-UPINsayDFtJqJFsKPZyPT-UFWrYrKD.DEEEEQDx6NsayDNDforB1..4YforB1..4NexitQNevalFo)=~y=A-Z=-+;-AZz-~=r)####>####>####>####>####>####>
;
;
;
;
eval+<eval+<eval+<eval+(q(FoPqOlengthFoBBPP181XXVVVVJJJKKKNdoWchopJFtPDevalMODx4KNFrPIPA-MN-TUV-ZPINFsPIFoPqOI.Fo.IQNevalFoINevalIFsPZyI.Fr.IT-UPINsayDFtJqJFsKPZyPT-UFWrYrKD.DEEEEQDx6NsayDNDforB1..4YforB1..4NexitQNevalFo)=~y=A-Z=-+;-AZz-~=r)####>####>####>####>####>####>
;
;
;
;
eval+<eval+<eval+<eval+(q(FoPqOlengthFoBBPP181XXVVVVJJJKKKNdoWchopJFtPDevalMODx4KNFrPIPA-MN-TUV-ZPINFsPIFoPqOI.Fo.IQNevalFoINevalIFsPZyI.Fr.IT-UPINsayDFtJqJFsKPZyPT-UFWrYrKD.DEEEEQDx6NsayDNDforB1..4YforB1..4NexitQNevalFo)=~y=A-Z=-+;-AZz-~=r)####>####>####>####>####>####>
;
;
;
;
eval+<eval+<eval+<eval+(q(FoPqOlengthFoBBPP181XXVVVVJJJKKKNdoWchopJFtPDevalMODx4KNFrPIPA-MN-TUV-ZPINFsPIFoPqOI.Fo.IQNevalFoINevalIFsPZyI.Fr.IT-UPINsayDFtJqJFsKPZyPT-UFWrYrKD.DEEEEQDx6NsayDNDforB1..4YforB1..4NexitQNevalFo)=~y=A-Z=-+;-AZz-~=r)####>####>####>####>####>####>
;
;
;
;
स्पष्टीकरण
यह कार्यक्रम काफी स्पष्ट है, एक साथ मिलकर बनाए गए चार समान छोटे कार्यक्रमों में से एक है। मूल विचार यह है कि कार्यक्रम की प्रत्येक प्रतिलिपि यह सत्यापित करेगी कि इसे चलाने के लिए बहुत बुरी तरह से क्षतिग्रस्त किया गया है या नहीं; यदि यह हो गया है, तो यह कुछ भी नहीं करेगा (संभवतः संभावित चेतावनियों के अलावा) और अगली कॉपी को चलने देगा; यदि यह नहीं किया गया है (अर्थात कोई विलोपन नहीं है, या हटा दिया गया वर्ण वह है जो प्रोग्राम के संचालन में कोई अंतर नहीं करता है), यह अपनी क्वीन बात करेगा (पूर्ण प्रोग्राम के स्रोत कोड को प्रिंट करना; यह एक उचित क्वीन है; प्रत्येक भाग के साथ पूरे स्रोत कोड का एन्कोडिंग है) और फिर बाहर निकलें (स्रोत कोड को फिर से प्रिंट करने से किसी भी अन्य अप्रकाशित प्रतियों को रोकना और इस प्रकार बहुत अधिक पाठ को मुद्रित करके क्वीन को बर्बाद करना)।
प्रत्येक भाग बारी-बारी से दो भागों से बना होता है जो प्रभावी रूप से कार्यात्मक रूप से स्वतंत्र होते हैं; एक बाहरी आवरण और कुछ आंतरिक कोड। जैसे, हम उन पर अलग से विचार कर सकते हैं।
बाहर का आवरण
बाहरी आवरण, मूल रूप से, eval<+eval<+eval< ... >####>####...>###(साथ ही अर्धविरामों और न्यूलाइन्स का एक समूह है, जिसका उद्देश्य बहुत स्पष्ट होना चाहिए; यह सुनिश्चित करना है कि कार्यक्रम के कुछ हिस्सों की परवाह किए बिना अलग-अलग बने रहेंगे यदि कुछ अर्धविराम, या उनसे पहले की नई सूची, हटाए जाएं) )। यह काफी सरल लग सकता है, लेकिन यह कई मायनों में सूक्ष्म है, और इस चुनौती के लिए मैंने पर्ल को चुना।
सबसे पहले, आइए देखें कि प्रोग्राम की एक अप्रकाशित प्रतिलिपि में रैपर कैसे कार्य करता है। evalएक अंतर्निहित फ़ंक्शन के रूप में पर्स करता है, जो एक तर्क लेता है। क्योंकि एक तर्क की उम्मीद की जाती है, +यहां एक एकता है +(जो अब तक पर्ल गोल्फर्स के लिए बहुत परिचित होगी; वे अक्सर उपयोगी आश्चर्यजनक रूप से आते हैं)। हम अभी भी एक तर्क की उम्मीद कर रहे हैं (हमने सिर्फ एक संयुक्त संचालक को देखा है), इसलिए जो <अगले आता है उसे <>ऑपरेटर की शुरुआत के रूप में व्याख्या की जाती है (जो कि कोई उपसर्ग या पोस्टफ़िक्स तर्क नहीं लेता है, और इस तरह से ऑपरेटर की स्थिति में उपयोग किया जा सकता है)।
<>काफी अजीब ऑपरेटर है। इसका सामान्य उद्देश्य फ़ाइलहैंडल्स पढ़ना है, और आप फ़ाइल नाम को कोन कोष्ठक के अंदर रखते हैं। वैकल्पिक रूप से, यदि अभिव्यक्ति एक फ़ाइलहैंडल नाम के रूप में मान्य नहीं है, तो यह ग्लोबिंग करता है (मूल रूप से, एक ही प्रक्रिया जिसे UNIX शेल उपयोगकर्ता द्वारा दर्ज किए गए पाठ का उपयोग कमांड-लाइन तर्कों के अनुक्रम में करता है; पर्ल के पुराने संस्करण वास्तव में उपयोग किए गए हैं; इसके लिए शेल, लेकिन आजकल पर्ल आंतरिक रूप से ग्लोबिंग को संभालता है)। इसलिए, इच्छित उपयोग, की तर्ज पर है <*.c>, जो आम तौर पर एक सूची की तरह लौटाएगा ("foo.c", "bar.c")। एक स्केलर संदर्भ में (जैसे कि तर्कeval), यह केवल पहली प्रविष्टि को चलाता है जो पहली बार इसे चलाने (पहली दलील के बराबर) पाता है, और काल्पनिक भविष्य के रन पर अन्य प्रविष्टियों को लौटाता है जो कभी नहीं होता है।
अब, गोले अक्सर कमांड-लाइन तर्कों को संभालते हैं; यदि आप -rबिना किसी तर्क के साथ कुछ देते हैं , तो यह केवल प्रोग्राम वर्बेटिम को दिया जाएगा, भले ही उस नाम के साथ कोई फ़ाइल हो या नहीं। पर्ल उसी तरह से कार्य करता है, इसलिए जब तक हम यह सुनिश्चित करते हैं कि ऐसे अक्षर नहीं हैं जो शेल और पर्ल के बीच <और मिलान के लिए विशेष हैं >, तो हम इसे प्रभावी रूप से स्ट्रिंग शाब्दिक के अजीब रूप में उपयोग कर सकते हैं। इससे भी बेहतर, पर्ल जैसे पार्सर को कोट-जैसे ऑपरेटरों के लिए संदर्भों में भी ब्रैकेट्स से मिलान करने की एक अनिवार्य प्रवृत्ति होती है, जहां इसका कोई मतलब नहीं है, इसलिए हम <>सुरक्षित रूप से घोंसला बना सकते हैं (जो इस कार्यक्रम के लिए आवश्यक खोज संभव है)। इन सभी नेस्टेड के प्रमुख नकारात्मक पक्ष यह <>है कि सामग्री से बचना<>लगभग असंभव है; ऐसा लगता है कि प्रत्येक के साथ अनसेफिंग की दो परतें हैं <>, इसलिए सभी तीनों के अंदर कुछ बच निकलने के लिए, इसे 63 बैकस्लैश के साथ पूर्ववर्ती होना चाहिए। मैंने तय किया कि भले ही कोड का आकार इस समस्या में एक माध्यमिक विचार है, लेकिन यह लगभग निश्चित रूप से मेरे स्कोर के लिए इस तरह के दंड का भुगतान करने के लायक नहीं था, इसलिए मैंने सिर्फ आक्रामक चरित्रों का उपयोग किए बिना बाकी कार्यक्रम लिखने का फैसला किया।
तो क्या होगा अगर रैपर के कुछ हिस्सों को हटा दिया जाए?
- शब्द में विलोपन
evalइसका कारण नंगेपन में बदल जाता है , एक स्ट्रिंग जिसका कोई अर्थ नहीं है। पर्ल को ये पसंद नहीं है, लेकिन यह उन्हें व्यवहार करता है जैसे कि वे उद्धरणों से घिरे थे; इस प्रकार eal<+eval<+...व्याख्या की जाती है"eal" < +eval<+...। इसका कार्यक्रम के संचालन पर कोई प्रभाव नहीं पड़ता है, क्योंकि यह मूल रूप से केवल भारी नेस्टेड (जो हम वैसे भी उपयोग नहीं करते हैं) से परिणाम ले रहे हैं, इसे एक पूर्णांक में कास्टिंग कर रहे हैं, और इस पर कुछ व्यर्थ तुलना कर रहे हैं। (इस तरह की चीज़ों के कारण बहुत सी चेतावनी स्पैम का कारण बनती है क्योंकि यह स्पष्ट रूप से सामान्य परिस्थितियों में करने के लिए एक उपयोगी चीज नहीं है; हम इसे हटाने को अवशोषित करने के लिए उपयोग कर रहे हैं।) इससे हमें आवश्यक कोष्ठक कोष्ठक बंद करने की संख्या में परिवर्तन होता है (क्योंकि उद्घाटन ब्रैकेट अब इसकी तुलना एक तुलना ऑपरेटर के रूप में की जा रही है), लेकिन अंत में टिप्पणियों की श्रृंखला सुनिश्चित करती है कि स्ट्रिंग सुरक्षित रूप से समाप्त हो जाएगी चाहे कितनी बार नेस्टेड हो। (यहां #कड़ाई से आवश्यक से अधिक संकेत हैं; मैंने इसे लिखा था जैसे मैंने कार्यक्रम को और अधिक संकुचित करने के लिए किया था, मुझे क्वीन को स्टोर करने के लिए कम डेटा का उपयोग करने की अनुमति देता है।)
- यदि कोई
<हटा दिया जाता है, तो कोड अब पार्स हो जाता है eval(eval<...>)। माध्यमिक, बाहर evalका कोई प्रभाव नहीं है, क्योंकि जिन कार्यक्रमों का हम मूल्यांकन कर रहे हैं, वे किसी भी चीज को वापस नहीं करते हैं, जिसका कोई भी वास्तविक प्रभाव एक कार्यक्रम के रूप में होता है (यदि वे सामान्य रूप से सभी पर लौटते हैं, तो यह आमतौर पर एक अशक्त स्ट्रिंग या एक नंगेपन है; और आमतौर पर वे के माध्यम से लौटते हैं; अपवाद, जो evalएक अशक्त स्ट्रिंग को वापस करने का कारण बनता है, या exitसभी पर लौटने से बचने के लिए उपयोग करता है)।
- यदि
+हटा दिया जाता है, तो इसका कोई तत्काल प्रभाव नहीं पड़ता है यदि आसन्न कोड बरकरार है; +कार्यक्रम पर यूनरी का कोई प्रभाव नहीं है। (मूल +एस वहाँ कारण है कि मरम्मत की क्षति में मदद करने के लिए; वे परिस्थितियों की संख्या में वृद्धि करते हैं जिसमें एक रिलेशनल ऑपरेटर के बजाय <एक यूनरी के रूप में व्याख्या की जाती है <>, जिसका अर्थ है कि आपको अमान्य प्रोग्राम का उत्पादन करने के लिए अधिक विलोपन की आवश्यकता है।)
रैपर को पर्याप्त विलोपन के साथ क्षतिग्रस्त किया जा सकता है, लेकिन आपको कुछ ऐसा करने के लिए कुछ विलोपन करने की आवश्यकता है जो पार्स नहीं करता है। चार विलोपन के साथ, आप यह कर सकते हैं:
eal<evl<eval+<...
और पर्ल में, रिलेशनल ऑपरेटर <गैर-सामाजिक है, और इस प्रकार आपको एक सिंटैक्स त्रुटि मिलती है (वही जिसे आप प्राप्त करेंगे 1<2<3)। जैसे, प्रोग्राम के लिए कैप n = 3 है। अधिक unary +s जोड़ना इसे बढ़ाने के लिए एक आशाजनक तरीका लगता है, लेकिन जैसा कि यह तेजी से संभावना बना देगा कि आवरण के अंदर भी टूट सकता है, यह सत्यापित करते हुए कि कार्यक्रम का नया संस्करण बहुत मुश्किल हो सकता है।
आवरण इतना मूल्यवान है कि evalपर्ल अपवादों को पकड़ता है, जैसे कि (उदाहरण के लिए) अपवाद जो आपको तब मिलता है जब आप सिंटैक्स त्रुटि को संकलित करने का प्रयास करते हैं। क्योंकि यह evalएक स्ट्रिंग शाब्दिक है, स्ट्रिंग का संकलन रनटाइम पर होता है, और यदि शाब्दिक संकलन करने में विफल रहता है, तो परिणामस्वरूप अपवाद पकड़ा जाता है। यह evalएक अशक्त स्ट्रिंग को वापस करने और त्रुटि संकेतक सेट करने का कारण बनता है $@, लेकिन हम कभी भी (या कभी-कभी प्रोग्राम के कुछ उत्परिवर्तित संस्करणों में लौटे नल स्ट्रिंग को छोड़कर) की जाँच नहीं करते हैं। गंभीर रूप से, इसका मतलब है कि अगर कोड के अंदर कुछ होना चाहिएआवरण, एक वाक्यविन्यास त्रुटि पैदा करता है, तो आवरण केवल कोड के बजाय कुछ भी नहीं करने का कारण होगा (और कार्यक्रम स्वयं की एक अप्रकाशित प्रतिलिपि खोजने के प्रयास में निष्पादन करेगा)। इसलिए, अंदर के कोड को रैपर के रूप में लगभग विकिरण-सबूत नहीं होना चाहिए; हम इस बात की परवाह करते हैं कि यदि क्षतिग्रस्त है, तो यह या तो प्रोग्राम के नामांकित संस्करण के लिए समान रूप से कार्य करेगा, या फिर यह दुर्घटनाग्रस्त हो जाएगा ( evalअपवाद को पकड़ने और जारी रखने की अनुमति देता है) या सामान्य रूप से कुछ भी छपाई किए बिना बाहर निकलें।
रैपर के अंदर
रैपर के अंदर कोड, मौलिक रूप से, इस तरह दिखता है (फिर से, वहाँ एक नियंत्रण है - _कि स्टैक एक्सचेंज तुरंत पहले नहीं दिखाएगा -+):
eval+(q(...)=~y=A-Z=-+;-AZz-~=r)
यह कोड पूरी तरह से ग्लोब-सुरक्षित वर्णों के साथ लिखा गया है, और इसका उद्देश्य विराम चिह्नों की एक नई वर्णमाला जोड़ना है जो एक वास्तविक कार्यक्रम लिखना संभव है, एक स्ट्रिंग शाब्दिक का अनुवाद और मूल्यांकन करके (हम उपयोग नहीं कर सकते हैं 'या "हमारे उद्धरण के रूप में) अंक, लेकिन q(... )पर्ल में एक स्ट्रिंग बनाने का एक वैध तरीका भी है)। (अनप्रेडिबल कैरेक्टर का कारण यह है कि हमें प्रोग्राम में शाब्दिक स्पेस के बिना स्पेस कैरेक्टर में कुछ ट्रांसलेट करना होगा। इस प्रकार हम ASCII 31 से शुरू होने वाली रेंज बनाते हैं, और रेंज के दूसरे एलिमेंट के रूप में स्पेस पकड़ते हैं।) जाहिर है, अगर हम लिप्यंतरण के माध्यम से कुछ पात्रों का निर्माण कर रहे हैं, हम उन्हें लिप्यन्तरण के लिए पात्रों का बलिदान करने के लिए है से, लेकिन अपरकेस अक्षर बहुत उपयोगी नहीं हैं और विराम चिह्नों तक पहुंच के बिना उन तक पहुंच के बिना लिखना बहुत आसान है।
यहाँ ग्लोब के परिणामस्वरूप उपलब्ध होने वाले विराम चिह्नों की वर्णमाला है (ऊपरी रेखा एन्कोडिंग को दर्शाती है, निचली पंक्ति जिस वर्ण को एनकोड करती है):
BCDEFGHIJKLMNOPQRSTUVWXYZ
! "# $% & '() * +;? <=> @ Azz {|} ~
सबसे विशेष रूप से, हमारे पास विराम चिह्नों का एक गुच्छा है जो ग्लोब-सुरक्षित नहीं हैं, लेकिन पर्ल चरित्र लिखने में उपयोगी हैं, साथ में अंतरिक्ष चरित्र। मैं भी दो पत्र अपरकेस, शाब्दिक बचाया Aऔर Z(जो एनकोड खुद को नहीं है, लेकिन करने के लिए Tऔर Uहै, क्योंकि Aएक ऊपरी और साथ ही एक कम रेंज समाप्ति बिंदु की जरूरत थी); यह हमें नए एन्कोडेड वर्ण सेट का उपयोग करके लिप्यंतरण निर्देश को स्वयं लिखने की अनुमति देता है (हालाँकि अपरकेस अक्षर उस उपयोगी नहीं हैं, वे अपरकेस अक्षरों में परिवर्तन निर्दिष्ट करने में उपयोगी हैं)। सबसे उल्लेखनीय अक्षर है कि हम उपलब्ध नहीं है कर रहे हैं [, \और ], लेकिन कोई भी जरूरत है (जब मैं उत्पादन में एक नई पंक्ति की जरूरत है, मैं इसे से निहित न्यू लाइन का उपयोग कर उत्पादन कियाsayलिखने की आवश्यकता के बजाय \n; chr 10काम भी किया होगा लेकिन अधिक क्रिया है)।
हमेशा की तरह, हमें इस बारे में चिंता करने की ज़रूरत है कि अगर रैपर के अंदर स्ट्रिंग शाब्दिक के बाहर क्षतिग्रस्त हो जाता है तो क्या होगा। एक भ्रष्ट व्यक्ति evalकुछ भी चलने से रोकेगा; हम इसके साथ ठीक हैं। यदि उद्धरण चिह्न क्षतिग्रस्त हो जाते हैं, तो स्ट्रिंग के अंदर वैध पर्ल नहीं होता है, और इस प्रकार आवरण इसे पकड़ लेगा (और तार पर कई घटाव का मतलब है कि भले ही आप इसे वैध पर्ल बना सकते हैं, यह कुछ भी नहीं करेगा, जो एक स्वीकार्य परिणाम है)। लिप्यंतरण में नुकसान, अगर यह एक सिंटैक्स त्रुटि नहीं है, तो स्ट्रिंग का मूल्यांकन किया जाएगा, आमतौर पर यह सिंटैक्स त्रुटि बनने का कारण बनता है ; मुझे यकीन नहीं है कि ऐसे कोई मामले नहीं हैं जिनमें यह टूटता है, लेकिन मैं यह सुनिश्चित करने के लिए इस समय पर मजबूर हूं और अगर ऐसा है तो इसे ठीक करना आसान होना चाहिए।
एन्कोडेड प्रोग्राम
स्ट्रिंग शाब्दिक के अंदर देखते हुए, मैंने जो एन्कोडिंग का इस्तेमाल किया था, उसे उलट दिया और इसे और अधिक पठनीय बनाने के लिए व्हॉट्सएप को जोड़ा, हमें यह मिलता है (फिर से, नियंत्रण-अंडरस्कोर की कल्पना करें -+, जो कि इनकोडेड है A):
$o=q<
length$o ==181 || zzzz((()));
do {
chop ($t = "eval+<"x4);
$r = '=-+;-AZz-~=';
$s = '$o=q<' . $o . '>;eval$o';
eval '$s=~y' . $r . 'A-Z=';
say "$t(q($s)=~y=A-Z${r}r)" . "####>"x6;
say ";" for 1..4
} for 1..4;
exit>;
eval $o
जिन लोगों का उपयोग किया जाता है, वे इस सामान्य संरचना को पहचानेंगे। सबसे महत्वपूर्ण हिस्सा शुरुआत में है, जहां हम यह सत्यापित करते हैं कि $ o अप्रयुक्त है; यदि पात्रों हटा दिया गया है, इसकी लंबाई से मेल नहीं खाएगी 181, तो हम चलाते हैं zzzz((())), जो अगर यह बेजोड़ कोष्ठक की वजह से एक सिंटैक्स त्रुटि नहीं है, भले ही आप क्योंकि कोई भी, किसी भी तीन वर्णों को हटाने के एक रनटाइम त्रुटि हो जाएगा zzzz, zzz, zz, और zएक फ़ंक्शन है, और इसे हटाने के अलावा एक फ़ंक्शन के रूप में पार्स करने (((और एक अप्रिय सिंटैक्स त्रुटि पैदा करने का कोई तरीका नहीं है । चेक खुद भी क्षति के लिए प्रतिरक्षा है; ||को क्षतिग्रस्त किया जा सकता |लेकिन यह है कि कारण होगा zzzz((()))बिना शर्त को चलाने के लिए कॉल; हानिकारक चर या स्थिरांक एक बेमेल का कारण बनेंगे क्योंकि आप इनमें से किसी एक की तुलना कर रहे हैं 0,180, 179, 178के अंकों में से कुछ सबसेट के लिए समानता के लिए 181; और एक =को हटाने से एक पार्स विफलता का कारण होगा, और दो =अनिवार्य रूप से एलएचएस का कारण बनता है कि या तो पूर्णांक 0 या शून्य स्ट्रिंग का मूल्यांकन करें, जो दोनों ही गलत हैं।
अद्यतन : यह जाँच कार्यक्रम के पूर्ववर्ती संस्करण में थोड़ी गलत थी, इसलिए मुझे इस समस्या को ठीक करने के लिए इसे संपादित करना पड़ा। पिछले संस्करण डिकोड के बाद इस तरह दिखे:
length$o==179||zzzz((()))
और इसे पाने के लिए पहले तीन विराम चिह्नों को हटाना संभव था:
lengtho179||zzz((()))
lengtho179नंगे होने के नाते, सत्य है और इस तरह चेक को तोड़ता है। मैंने अतिरिक्त दो Bवर्णों को जोड़कर इसे ठीक किया (जो कि अंतरिक्ष वर्णों को कूटबद्ध करता है), जिसका अर्थ है कि क्वीन का नवीनतम संस्करण यह करता है:
length$o ==181||zzzz((()))
अब सिंटैक्स त्रुटि उत्पन्न करने के बिना =संकेत और संकेत दोनों को छिपाना असंभव है $। (मुझे एक के बजाय दो स्थान जोड़ना था क्योंकि लंबाई में 180एक शाब्दिक 0वर्ण स्रोत में रखा जाएगा , जिसे इस संदर्भ में दुरुपयोग किया जा सकता है एक पूर्णांक के साथ शून्य की तुलना करें, जो सफल होता है।) अंतिम अद्यतन।
एक बार जब लंबाई की जाँच हो जाती है, तो हमें पता चलता है कि यह कॉपी अप्रकाशित है, कम से कम इसके चरित्र विलोपन के संदर्भ में, इसलिए यह सब वहाँ से सीधा सीधा क्विनिंग है (एक भ्रष्ट डिकोडिंग टेबल के कारण विराम चिह्नों के प्रतिस्थापन इस चेक को नहीं पकड़ा जाएगा। , लेकिन मैंने पहले ही पाशविक-बल के माध्यम से सत्यापित कर दिया है कि केवल डिकोडिंग टेबल से कोई तीन विलोपन क्वीन को नहीं तोड़ते हैं, संभवतः उनमें से अधिकांश सिंटैक्स त्रुटियों का कारण बनते हैं)। हमारे पास $oपहले से ही एक चर है, इसलिए हमें बस इतना करना है कि बाहर के रैपरों को हार्डकोड करें (कुछ छोटी-छोटी डिग्री संपीड़न के साथ; मैंने प्रश्न के कोड-गोल्फ भाग को पूरी तरह से बाहर नहीं छोड़ा )। एक चाल यह है कि हम एन्कोडिंग तालिका के थोक को स्टोर करते हैं$r; अंदर के आवरण के एन्कोडिंग टेबल सेक्शन को जनरेट करने के लिए या तो हम इसके बारे में जान सकते हैं या इसके चारों ओर कुछ कोड समेट सकते हैं और evalडिकोडिंग प्रक्रिया को रिवर्स में चलाने के लिए (हमें यह पता लगाने की अनुमति देते हैं कि $ o का एन्कोडेड संस्करण क्या है) , इस बिंदु पर उपलब्ध केवल डिकोड किया गया संस्करण)।
अंत में, यदि हम एक अक्षुण्ण प्रति हैं और इस प्रकार पूरे मूल कार्यक्रम का उत्पादन कर सकते हैं, तो हम कार्यक्रम exitको प्रिंट करने की कोशिश कर रही अन्य प्रतियों को भी रोकने के लिए कॉल करते हैं।
सत्यापन स्क्रिप्ट
बहुत सुंदर नहीं, लेकिन इसे पोस्ट करना क्योंकि किसी ने पूछा। मैंने इसे कई बार कई प्रकार की सेटिंग्स (आमतौर पर बदलने $minऔर $maxब्याज के विभिन्न क्षेत्रों की जांच करने के लिए) के साथ चलाया ; यह पूरी तरह से स्वचालित प्रक्रिया नहीं थी। यह भारी सीपीयू लोड के कारण कहीं और चलने से रोकने की प्रवृत्ति है; जब ऐसा हुआ, तो मैंने $minपहले मूल्य को बदल दिया $xऔर पूरी तरह से जाँच नहीं की और स्क्रिप्ट चलाना जारी रखा (इस तरह यह सुनिश्चित करना कि रेंज के सभी कार्यक्रम अंततः जांच लिए गए)। मैंने केवल कार्यक्रम की पहली प्रति से विलोपन की जाँच की है, क्योंकि यह काफी स्पष्ट है कि अन्य प्रतियों से विलोपन अधिक नहीं कर सकते हैं।
use 5.010;
use IPC::Run qw/run/;
undef $/;
my $program = <>;
my $min = 1;
my $max = (length $program) / 4 - 3;
for my $x ($min .. $max) {
for my $y ($x .. $max) {
for my $z ($y .. $max) {
print "$x, $y, $z\n";
my $p = $program;
substr $p, $x, 1, "";
substr $p, $y, 1, "";
substr $p, $z, 1, "";
alarm 4;
run [$^X, '-M5.010'], '<', \$p, '>', \my $out, '2>', \my $err;
if ($out ne $program) {
print "Failed deleting at $x, $y, $z\n";
print "Output: {{{\n$out}}}\n";
exit;
}
}
}
}
say "All OK!";
Subleq। मुझे लगता है कि यह इस तरह की चुनौती के लिए आदर्श होगा!