XOR समाधान के लिए कुछ आवश्यक प्रेरणा के लिए FryAmTheEggman को धन्यवाद।
0000 !@
0001 ?.|@!
0010 #?#!)@
0011 ?!@
0100 +?|@!?
0101 ??!@
0110 ?<@!!<_\~(
0111 ?<<@!
1000 )\!#?@{
1001 (~?/@#!
1010 ??|@!)
1011 \#??!1@
1100 ?(~!@
1101 ?.|@!)
1110 ?$@#)!<
1111 1!@
सभी प्रोग्राम 0झूठे और 1सच्चे के लिए उपयोग करते हैं ।
इसे ऑनलाइन आज़माएं! यह एक परीक्षण सूट नहीं है, आपको विभिन्न कार्यक्रमों और खुद को इनपुट करना होगा।
उपरोक्त समाधान इष्टतमता के 2-बाइट्स के भीतर है (जब तक कि हम सत्य / मिथ्या व्याख्या को आराम नहीं देते, मुझे लगता है)। मैंने सभी कार्यक्रमों पर लगभग दो दिनों के लिए एक ब्रूट फोर्स सर्च को चलने दिया है, जो साइड-लेंथ 2 में फिट होता है, यानी 7 बाइट्स तक ( बिल्कुल सभी प्रोग्राम नहीं - मैंने कुछ मान्यताओं पर विचार किया कि हर वैध प्रोग्राम को क्या चाहिए और क्या नहीं वैध कार्यक्रम हो सकता है)। खोज में 16 संभावित द्वारों में से 15 के लिए समाधान मिला - और अक्सर एक से अधिक बहुत कुछ। आप इस पास्टबिन में सभी वैकल्पिक समाधानों की एक सूची पा सकते हैं जहां मैंने उन्हें समान व्यवहार द्वारा समूहीकृत किया है। जो मैं ऊपर दिखा रहा हूं वह मैंने चुना है क्योंकि वे या तो सबसे सरल या सबसे दिलचस्प समाधान हैं, और मैं कल उनके लिए स्पष्टीकरण जोड़ूंगा।
16 वें गेट के लिए: XOR एकमात्र गेट है जिसे जाहिर तौर पर 7 बाइट्स में लागू नहीं किया जा सकता है। बड़े कार्यक्रमों पर एक क्रूर बल खोज दुर्भाग्य से मेरे पास वर्तमान में मौजूद कोड से संभव नहीं है। इसलिए XOR को हाथ से लिखना पड़ा। अब तक मैंने जो सबसे छोटा पाया है, वह उपरोक्त 10-बाइट प्रोग्राम है, जो FryAmTheEggman द्वारा विफल (लेकिन बहुत करीब) प्रयास पर आधारित है। यह संभव है कि एक 8-बाइट या 9-बाइट समाधान मौजूद है, लेकिन इसके अलावा, सभी समाधान वास्तव में इष्टतम होना चाहिए।
स्पष्टीकरण
चेतावनी: पाठ की दीवार। ऑफ-मौका पर किसी की दिलचस्पी है कि ये अत्यधिक संकुचित हेक्सागोनी कार्यक्रम वास्तव में कैसे काम करते हैं, मैंने उनमें से प्रत्येक के लिए स्पष्टीकरण शामिल किया है। मैंने उन मामलों में प्रत्येक गेट के लिए सबसे सरल समाधान चुनने की कोशिश की है, जहां एक से अधिक इष्टतम कार्यक्रम मौजूद हैं, ताकि स्पष्टीकरण को यथोचित रूप से छोटा रखा जा सके। हालांकि, उनमें से कुछ अभी भी मन को चकित करते हैं, इसलिए मैंने सोचा कि वे थोड़ा और विस्तार के लायक हैं।
0000: असत्य
मुझे नहीं लगता कि हमें इसके लिए आरेख की आवश्यकता होगी:
! @
. . .
. .
चूँकि पूरी मेमोरी ग्रिड शून्य से शुरू होती है, !बस एक शून्य प्रिंट करता है और @प्रोग्राम को समाप्त करता है।
यह भी केवल 2-बाइट समाधान है।
0001: तथा
? .
| @ !
. .
यह मूल रूप से शॉर्ट-सर्किटिंग को लागू करता है । नीचे दिए गए ग्रे आरेख कार्यक्रम की शुरुआत को दर्शाता है, जहां पहले इनपुट के साथ पढ़ा जाता है ?और अनुदेश सूचक (आईपी) बाएं कोने के चारों ओर घूमता है जहां |दर्पण इसे प्रतिबिंबित करता है। अब कोने एक सशर्त के रूप में कार्य करता है, जैसे पहले इनपुट के मूल्य के आधार पर दो अलग-अलग निष्पादन पथ हैं। लाल रेखाचित्र नियंत्रण के लिए A = 0और हरे रंग के चित्र के लिए प्रवाह को दर्शाता है A = 1:
जैसा कि आप देख सकते हैं, जब यह Aहोता है 0, तो हम बस इसे प्रिंट करते हैं और समाप्त करते हैं (याद रखें कि सभी .नो-ऑप हैं)। लेकिन जब Aहै 1, तो IP पहली पंक्ति को फिर से पढ़ता है, Bइसके बजाय पढ़ना और प्रिंट करना।
कुल मिलाकर इस गेट के लिए सोलह 5-बाइट समाधान हैं। उनमें से चौदह अनिवार्य रूप से ऊपर के समान हैं, या तो >इसके बजाय का उपयोग कर रहे हैं |या .एक कमांड के साथ प्रतिस्थापित कर रहे हैं जो प्रभावी रूप से एक नो-ऑप है, या ?दूसरी स्थिति में डाल रहा है:
?.|@! .?|@! ?=|@! =?|@! ?_|@! _?|@! ?0|@!
?.>@! .?>@! ?=>@! =?>@! ?_>@! _?>@! ?0>@!
और फिर दो अन्य समाधान हैं (जो एक दूसरे के बराबर हैं)। ये समान लघु-परिचालित तर्क को भी कार्यान्वित करते हैं, लेकिन निष्पादन पथ थोड़े क्रेज़ी होते हैं (और पाठक को एक अभ्यास के रूप में छोड़ दिया जाता है):
?<!@|
?<!@<
0010: ए और बी नहीं
# ?
# ! )
@ .
यह शॉर्ट-सर्क्युटिंग का एक रूप भी लागू करता है, लेकिन #नियंत्रण प्रवाह के उपयोग के कारण बहुत पेचीदा होता है। #एक सशर्त आईपी स्विच है। हेक्सागोनी वास्तव में लेबल किए 0गए छह आईपी के साथ आता है 5, जो कि ग्रिड के छह कोनों में शुरू होता है, जो घड़ी की धार के साथ इशारा करता है (और प्रोग्राम हमेशा आईपी से शुरू होता है 0)। जब एक #सामना किया जाता है, तो वर्तमान मान को मोडुलो लिया जाता है 6, और नियंत्रण प्रवाह संबंधित आईपी के साथ जारी रहता है। मुझे यकीन नहीं है कि पागलपन के फिट ने मुझे इस सुविधा को कैसे जोड़ा, लेकिन यह निश्चित रूप से कुछ आश्चर्यजनक कार्यक्रमों (जैसे यह) के लिए अनुमति देता है।
हम तीन मामलों में अंतर करेंगे। जब A = 0, कार्यक्रम काफी सरल होता है, क्योंकि मूल्य हमेशा 0तब होता है जब #उसका सामना ऐसे किया जाता है जैसे कोई आईपी-स्विचिंग नहीं होता है:
#कुछ नहीं करता है, ?पढ़ता है A(यानी कुछ भी नहीं करता है), फिर #भी कुछ नहीं करता है, !प्रिंट करता है 0, )वेतन वृद्धि करता है (यह महत्वपूर्ण है, अन्यथा आईपी तीसरी पंक्ति में नहीं कूदता), @कार्यक्रम को समाप्त करता है। काफी सरल। अब आइए मामले पर विचार करें (A, B) = (1, 0):
लाल पथ अभी भी IP से मेल खाता है 0, और मैंने IP के लिए हरा पथ जोड़ा है 1। हम देखते हैं कि ( इस समय) ?पढ़ने के बाद , शीर्ष दाएं कोने में शुरू होने वाले आईपी पर स्विच होता है। इसका मतलब है कि पढ़ सकते हैं ( )। अब वेतन वृद्धि कि , इस तरह के शीर्ष बाएँ कोने में कुछ भी नहीं है और हम आईपी के साथ रहते हैं । प्रिंट और आईपी बाईं विकर्ण इर्द-गिर्द घूमती। अभी भी कुछ नहीं करता है और कार्यक्रम को समाप्त करता है।A1#?B0)1#1!1#@
अंत में, वास्तव में अजीब मामला है जहां दोनों इनपुट हैं 1:
इस बार, दूसरा इनपुट भी है 1और )इसे बढ़ाता है 2। इसका मतलब #है कि ऊपरी बाएँ कोने में IP पर एक और IP स्विच होता है 2, जो नीले रंग में इंगित करता है। उस रास्ते पर, हम पहले इसे और बढ़ाते हैं 3(हालाँकि यह अप्रासंगिक है) और फिर ?तीसरी बार पास होते हैं। चूंकि अब हम EOF (यानी इनपुट समाप्त हो गया है), ?रिटर्न 0, !प्रिंट करता है और @प्रोग्राम को समाप्त कर देता है।
विशेष रूप से, यह इस गेट के लिए केवल 6-बाइट समाधान है।
0011: ए
? !
@ . .
. .
यह काफी सरल है कि हमें आरेख की आवश्यकता नहीं होगी: ?पढ़ता है A, !इसे प्रिंट करता है, @समाप्त करता है।
यह इस गेट के लिए केवल 3-बाइट समाधान है। (सिद्धांत रूप में, यह करना भी संभव होगा ,;@, लेकिन खोज में शामिल नहीं था ;, क्योंकि मुझे नहीं लगता कि यह !इस कार्य के लिए बाइट्स को कभी भी बचा सकता है ।)
0100: बी और ए नहीं
+ ?
| @ !
? .
यह अपने "भाई" की तुलना में बहुत सरल है 0010। नियंत्रण प्रवाह वास्तव में वैसा ही है जैसा हमने 0001(और) के लिए ऊपर देखा है । यदि A = 0, तो IP निचली पंक्ति, पढ़ने Bऔर मुद्रण करने से पहले समाप्त हो जाता है। अगर A = 1तब IP पहली लाइन को फिर से पढ़ता है B, तो रीडिंग भी करता है , लेकिन +दो अप्रयुक्त मेमोरी किनारों को जोड़ता है , इसलिए यह सब वर्तमान मूल्य को रीसेट करता है 0, ताकि !हमेशा प्रिंट होता रहे 0।
इसके (४२) कुल ६ बाइट विकल्प हैं। सबसे पहले, ऊपर के बराबर समाधानों का एक टन है। हम फिर से |और के बीच स्वतंत्र रूप से चुन सकते हैं >, और +किसी भी अन्य कमांड से बदला जा सकता है जो हमें एक खाली बढ़त देता है:
"?|@!? &?|@!? '?|@!? *?|@!? +?|@!? -?|@!? ^?|@!? {?|@!? }?|@!?
"?>@!? &?>@!? '?>@!? *?>@!? +?>@!? -?>@!? ^?>@!? {?>@!? }?>@!?
इसके अलावा, हम भी के ]बजाय उपयोग कर सकते हैं ?। ]अगले IP पर ले जाता है (अर्थात IP का चयन करता है 1), ताकि यह शाखा ?शीर्ष दाएं कोने में पुन: उपयोग करे । यह एक और 18 समाधान देता है:
"?|@!] &?|@!] '?|@!] *?|@!] +?|@!] -?|@!] ^?|@!] {?|@!] }?|@!]
"?>@!] &?>@!] '?>@!] *?>@!] +?>@!] -?>@!] ^?>@!] {?>@!] }?>@!]
और फिर छह अन्य समाधान हैं जो सभी पागलपन के अलग-अलग स्तरों के साथ अलग-अलग काम करते हैं:
/[<@!? ?(#!@] ?(#>@! ?/@#/! [<<@!? [@$\!?
0101: बी
? ?
! @ .
. .
Woohoo, एक और सरल एक: पढ़ना A, पढ़ना B, प्रिंट करना B, समाप्त करना। हालांकि इसके लिए वास्तव में विकल्प हैं। चूंकि Aकेवल एक ही चरित्र है, हम इसे भी पढ़ सकते हैं ,:
,?!@
और एक एकल ?का उपयोग करने और एक दर्पण का उपयोग करने का विकल्प भी है जो दो बार इसके माध्यम से चलता है:
?|@! ?>@!
0110: Xor
? < @
! ! < _
\ ~ ( . .
. . . .
. . .
जैसा कि मैंने ऊपर कहा, यह एकमात्र गेट था जो साइड-लेंथ 2 में फिट नहीं होगा, इसलिए यह FryAmTheEggman और स्वयं द्वारा एक हस्तलिखित समाधान है, और एक अच्छा मौका है कि यह इष्टतम नहीं है। भेद करने के दो मामले हैं। यदि A = 0नियंत्रण प्रवाह काफी सरल है (क्योंकि उस स्थिति में हमें केवल प्रिंट करने की आवश्यकता है B):
हम लाल पथ पर शुरू करते हैं। ?पढ़ता है A, <एक शाखा है जो बचे हुए शून्य को दर्शाती है। आईपी नीचे की ओर लपेटता है, फिर _एक और दर्पण होता है, और जब आईपी कोने से टकराता है, तो यह ऊपरी बाएं कोने में लपेटता है और नीले रास्ते पर जारी रहता है। इसे ?पढ़ता है B, !छापता है। अब (इसे घटाते हैं। यह महत्वपूर्ण है क्योंकि यह सुनिश्चित करता है कि मूल्य गैर-सकारात्मक है (यह 0या तो या -1अब है)। यह आईपी को दाहिने कोने में लपेटता है, जहां @कार्यक्रम को समाप्त करता है।
जब A = 1चीजें थोड़ी पेचीदा हो जाती हैं। उस स्थिति में हम प्रिंट करना चाहते हैं not B, जो अपने आप में बहुत कठिन नहीं है, लेकिन निष्पादन पथ थोड़ा दुखद है।
इस बार, <आईपी को सही दर्शाता है और फिर अगला <सिर्फ दर्पण के रूप में कार्य करता है। तो आईपी रिवर्स में उसी रास्ते को पीछे छोड़ता है, Bजब वह ?फिर से सामना करता है । आईपी दाहिने कोने के चारों ओर लपेटता है और हरे रास्ते पर जारी रहता है। यह अगले मुठभेड़ों (~जो "घटती, गुणा -1" है, जो स्वैप 0और 1और इसलिए गणना करता है not B। \सिर्फ एक दर्पण है और !वांछित परिणाम प्रिंट करता है। फिर ?दूसरे नंबर पर लौटने की कोशिश करता है लेकिन शून्य देता है। आईपी अब नीले रास्ते पर नीचे बाएँ कोने में जारी है। (घटाव, <प्रतिबिंबित,(फिर से गिरावट, ताकि आईपी के कोने से टकरा जाने पर वर्तमान मूल्य नकारात्मक हो। यह नीचे दाईं ओर तिरछे चलता है और फिर अंत में @कार्यक्रम को समाप्त करने के लिए हिट करता है।
0111: या
? <
< @ !
. .
अधिक शॉर्ट-सर्किटिंग।
A = 0मामले (लाल पथ) थोड़ा यहाँ भ्रमित है। आईपी बाईं ओर विक्षेपित हो जाता है, निचले बाएं कोने में लपेटता है, तुरंत दिखाई देता है <और ?पढ़ने के लिए वापस आ जाता है B। यह तब रिग कॉर्नर पर जाता है, प्रिंट Bकरता है !और समाप्त होता है।
A = 1मामले (हरा पथ) थोड़ा आसान है। <शाखा आईपी सही विक्षेपित, तो हम आसानी से प्रिंट !, वापस ऊपर बाईं ओर लपेट, और पर समाप्त @।
केवल एक अन्य 5-बाइट समाधान है:
\>?@!
यह अनिवार्य रूप से एक ही काम करता है, लेकिन वास्तविक निष्पादन पथ काफी अलग हैं और यह एक के बजाय शाखाओं के लिए एक कोने का उपयोग करता है <।
1000: न ही
) \
! # ?
@ {
यह इस खोज में पाया गया मेरा पसंदीदा कार्यक्रम हो सकता है। सबसे अच्छी बात यह है कि यह कार्यान्वयन norवास्तव में 5 इनपुट तक काम करता है। मुझे इस बारे में समझाने के लिए मेमोरी मॉडल के विवरण में जाना होगा। एक त्वरित रिफ्रेशर के रूप में, हेक्सागोनी का मेमोरी मॉडल एक अलग हेक्सागोनल ग्रिड है, जहां प्रत्येक किनारे एक पूर्णांक मान (शुरू में सभी शून्य) रखता है। एक मेमोरी पॉइंटर (MP) है जो उस किनारे के साथ एक किनारे और एक दिशा को इंगित करता है (जैसे कि वर्तमान किनारे के आगे और पीछे दो पड़ोसी किनारे हैं, सार्थक बाएँ और दाएँ पड़ोसी के साथ)। यहाँ किनारों का एक आरेख है जिसका हम उपयोग कर रहे हैं, जिसमें सांसद लाल रंग में दिखाया गया है:
आइए पहले उस मामले पर विचार करें जहां दोनों इनपुट हैं 0:
हम ग्रे पथ पर शुरू करते हैं, जो कि किनारे ए को बढ़ाता है 1ताकि #आईपी पर स्विच हो 1जो कि नीले रंग का रास्ता है, शीर्ष कोने वाले कोने में शुरू होता है। \वहाँ कुछ नहीं करता है और ?एक इनपुट पढ़ता है। हम शीर्ष बाएं कोने में लपेटते हैं, जहां )उस इनपुट में वृद्धि होती है। अब जब तक इनपुट शून्य है, तब तक इसमें परिणाम होगा 1, ताकि #कुछ भी न हो। फिर {MP को बाईं ओर ले जाता है, यानी A से B तक की पहली यात्रा पर । चूंकि इस किनारे पर अभी भी अपना प्रारंभिक शून्य है, आईपी शीर्ष दाएं कोने में और एक नए मेमोरी एज पर वापस लपेटता है। इसलिए यह लूप तब तक जारी रहेगा जब तक कि ?शून्य से सांसद को बी से षट्भुज के चारों ओर ले जाते हुए, शून्य पढ़ा जाता हैके सी के लिए डी और इतने पर। इससे कोई फर्क नहीं पड़ता कि क्या ?एक शून्य लौटाता है क्योंकि यह एक इनपुट था या क्योंकि यह ईओएफ था।
इस लूप के माध्यम से छह पुनरावृत्तियों के बाद, ए पर{ लौटता है । इस बार, किनारे पहले से ही बहुत अधिक चलना से मूल्य रखता है , इसलिए आईपी बाएं कोने में लपेटता है और इसके बजाय हरे रंग की राह पर जारी रहता है। बस प्रिंट करता है और कार्यक्रम को समाप्त करता है।1!1@
अब यदि कोई इनपुट है तो क्या होगा 1?
फिर ?पढ़ता है कि 1कुछ बिंदु पर और )इसे बढ़ाता है 2। इसका मतलब है कि #अब आईपी को फिर से स्विच किया जाएगा और हम लाल मार्ग पर दाहिने कोने में जारी रखेंगे। ?एक और इनपुट पढ़ता है (अगर वहाँ एक है), जो वास्तव में मायने नहीं रखता है और {एक किनारे को आगे बढ़ाता है। इसके लिए अप्रयुक्त किनारे होना चाहिए, इसलिए यह 5 इनपुट तक काम करता है। आईपी शीर्ष दाईं ओर लपेटता है जहां यह तुरंत परिलक्षित होता है और बाएं कोने में लपेटता है। अप्रयुक्त किनारे पर !प्रिंट करता है 0और #आईपी पर वापस स्विच करता है 0। वह आईपी अभी भी #दक्षिण पश्चिम (ग्रे पथ) पर जा रहा था, इसलिए यह तुरंत हिट करता है @और कार्यक्रम को समाप्त करता है।
कुल मिलाकर इस गेट के लिए सात 7-बाइट समाधान हैं। उनमें से 5 इसी तरह काम करते हैं और अप्रयुक्त किनारे पर जाने के लिए अन्य कमांड का उपयोग करते हैं (और एक अलग षट्भुज या एक अलग दिशा में घूम सकते हैं):
)\!#?@" )\!#?@' )\!#?@^ )\!#?@{ )\!#?@}
और समाधानों का एक अन्य वर्ग है जो केवल दो इनपुट के साथ काम करता है, लेकिन जिनके निष्पादन के मार्ग वास्तव में और भी गड़बड़ हैं:
?]!|<)@ ?]!|<1@
1001: समानता
( ~
? / @
# !
यह सशर्त आईपी चयन का बहुत चालाक उपयोग करता है। हमें फिर से A = 0और के बीच अंतर करने की जरूरत है A = 1। पहले मामले में हम प्रिंट करना चाहते हैं not B, दूसरे में हम प्रिंट करना चाहते हैं B। के लिए A = 0हम भी के लिए दो मामलों भेद B। आइए शुरू करते हैं A = B = 0:
हम ग्रे पथ पर शुरू करते हैं। (~नजरअंदाज किया जा सकता है, आईपी बाएं कोने (अभी भी ग्रे पथ पर) को लपेटता है और Aसाथ पढ़ता है ?। (ऐसा होने पर, हम प्राप्त करते हैं -1और आईपी निचले बाएं कोने में लपेटते हैं। अब जैसे मैंने पहले कहा, वह आईपी चुनने से पहले #वैल्यू मोडुलो लेता है 6, इसलिए -1वास्तव में आईपी से एक वैल्यू निकलती है 5, जो लाल रास्ते पर बाएं कोने में शुरू होती है। ?पढ़ता है B, (कि साथ ही साथ 5जब हम #फिर से हिट करते हैं तो हम आईपी पर बने रहते हैं । ~नकारता -1ताकि आईपी नीचे दाएं कोने में लपेटता, प्रिंट 1और समाप्त हो जाता है।
अब अगर Bहै 1बजाय, वर्तमान मूल्य हो जाएगा 0जब हम मारा #दूसरी बार है, तो हम वापस आईपी करने के लिए स्विच 0(अब हरी पथ पर)। वह ?तीसरी बार हिट करता है, उपज देता है 0, उसे !प्रिंट करता है और @समाप्त करता है।
अंत में, जहां मामला A = 1। जब हम #पहली बार हिट करते हैं तो इस बार वर्तमान मूल्य पहले से ही शून्य है , इसलिए यह पहली बार 5में आईपी पर स्विच नहीं करता है। हम बस तुरंत हरे रास्ते पर चलते रहते हैं। ?अब सिर्फ एक शून्य नहीं देता Bबल्कि बदले में देता है । !इसे प्रिंट करता है और @फिर से समाप्त करता है।
कुल में इस गेट के लिए तीन 7-बाइट समाधान हैं। अन्य दो बहुत अलग तरीके से (यहां तक कि एक दूसरे से भी) काम करते हैं, और भी अजीब उपयोग करते हैं #। विशेष रूप से वे एक या एक से अधिक मूल्यों के साथ ,पढ़ते हैं (एक पूर्णांक के बजाय एक वर्ण कोड पढ़ते हैं) और फिर एक आईपी चुनने के लिए उस मूल्य modulo 6 का उपयोग करते हैं। यह बहुत पागल है।
),)#?@!
?~#,~!@
1010: बी नहीं है
? ?
| @ !
) .
यह एक काफी सरल है। निष्पादन पथ वह क्षैतिज शाखा है जिसे हम पहले से andपहले से जानते हैं । ??पढ़ता है Aऔर फिर तुरंत B। पर |और ब्रांचिंग को प्रतिबिंबित करने के बाद , B = 0हम नीचे की शाखा को निष्पादित करेंगे, जहां )उस मूल्य को बढ़ाता है 1जिसे बाद में मुद्रित किया जाता है !। शीर्ष शाखा पर (यदि B = 1) ?बस किनारे को फिर से रीसेट करें 0जो तब भी मुद्रित होता है !।
इस गेट के लिए आठ 6-बाइट कार्यक्रम हैं। उनमें से चार काफी एक ही के साथ या तो कर रहे हैं >के बजाय |या 1के बजाय )(या दोनों):
??>@!) ??>@!1 ??|@!) ??|@!1
दो एकल का उपयोग करते हैं ?जो दर्पण के कारण दो बार उपयोग किया जाता है। नकार तब होता है जब हमने या xorतो (~उसके साथ किया था ~)।
?>!)~@ ?>!~(@
और अंत में, दो समाधान एक सशर्त आईपी स्विच का उपयोग करते हैं, क्योंकि अगर सरल भी काम करता है तो सरल तरीके का उपयोग क्यों करें:
??#)!@ ??#1!@
1011: B का तात्पर्य A है
\ #
? ? !
1 @
यह कुछ बल्कि विस्तृत आईपी स्विचिंग का उपयोग करता है। मैं A = 1इस बार मामले से शुरू करूंगा , क्योंकि यह सरल है:
हम ग्रे पथ पर शुरू करते हैं, जिसके Aसाथ पढ़ता है ?और फिर हिट करता है #। के बाद से Aहै 1इस आईपी पर स्विच करता है 1(हरी पथ)। !तुरंत प्रिंट कि, आईपी शीर्ष बाईं ओर लपेटता, पढ़ता B(अनावश्यक रूप से) और समाप्त हो जाता है।
जब A = 0चीजें थोड़ी और दिलचस्प हो जाती हैं। पहले विचार करें A = B = 0:
इस बार, #कुछ नहीं करता है और हम आईपी पर बने रहते हैं 0(उस बिंदु से लाल पथ)। ?पढ़ता है Bऔर 1इसे एक में बदल देता है 1। ऊपरी बाएं कोने में लपेटने के बाद, हम #फिर से हिट करते हैं, इसलिए हम सभी के बाद हरे रास्ते पर समाप्त होते हैं, और 1समाप्त होने से पहले पहले की तरह प्रिंट करते हैं।
अंत में, यहाँ (A, B) = (0, 1)झूठा मामला है:
ध्यान दें कि मैंने स्पष्टता के लिए प्रारंभिक ग्रे पथ को हटा दिया है, लेकिन कार्यक्रम उसी तरह से शुरू होता है, और हम पहले की तरह लाल पथ पर समाप्त होते हैं। तो इस बार दूसरा ?रिटर्न 1। अब हमारा सामना होता है 1। इस बिंदु पर यह समझना महत्वपूर्ण है कि हेक्सागोनी में वास्तव में क्या अंक हैं (अब तक हमने केवल उन्हें शून्य पर उपयोग किया है): जब एक अंक का सामना किया जाता है, तो वर्तमान मूल्य 10 से गुणा किया जाता है और फिर अंक जोड़ा जाता है। यह आमतौर पर दशमलव संख्या को स्रोत कोड में लिखने के लिए उपयोग किया जाता है, लेकिन इसका मतलब है कि B = 1वास्तव में मूल्य के लिए मैप किया गया है 11। इसलिए जब हम हिट करते हैं #, तो इसे 6देने के लिए मोडुलो लिया जाता है 5और इसलिए हम आईपी पर स्विच करते हैं 5( 1पहले की तरह) और नीले रास्ते पर चलते रहते हैं। साधते?तीसरी बार एक शून्य लौटाता है, इसलिए !प्रिंट करता है, और एक और दो के बाद ?, आईपी नीचे दाईं ओर लपेटता है जहां कार्यक्रम समाप्त होता है।
इसके लिए चार 7-बाइट समाधान हैं और वे सभी अलग-अलग काम करते हैं:
#)/!?@$ <!?_@#1 \#??!1@ |/)#?@!
1100: ए नहीं
? (
~ ! @
. .
बस एक सरल रैखिक एक: Aसाथ पढ़ें ?, साथ नकारात्मक (~, प्रिंट के साथ !समाप्त करें @।
एक वैकल्पिक समाधान है, और ~)इसके बजाय इसके साथ उपेक्षा है :
?~)!@
1101: A का तात्पर्य B है
? .
| @ !
) .
यह उस निहितार्थ की तुलना में बहुत सरल है जिसके बारे में हमने अभी बात की है। यह फिर से उन क्षैतिज शाखा कार्यक्रमों में से एक है, जैसे के लिए and। यदि Aहै 0, तो यह बस 1नीचे की शाखा पर बढ़ जाता है और मुद्रित होता है। अन्यथा, शीर्ष शाखा को फिर से निष्पादित किया जाता है जहां ?पढ़ता है Bऔर फिर !इसके बजाय प्रिंट करता है।
यहाँ विकल्पों में से एक टन है (कुल में 66 समाधान), ज्यादातर प्रभावी नो-ऑप्स की मुफ्त पसंद के कारण। एक शुरुआत के लिए हम सभी को एक ही तरीके से हम के लिए कर सकता है में ऊपर समाधान भिन्न हो सकते हैं andऔर हम भी बीच चयन कर सकते )हैं और 1:
?.|@!) .?|@!) ?=|@!) =?|@!) ?_|@!) _?|@!) ?0|@!)
?.|@!1 .?|@!1 ?=|@!1 =?|@!1 ?_|@!1 _?|@!1 ?0|@!1
?.>@!) .?>@!) ?=>@!) =?>@!) ?_>@!) _?>@!) ?0>@!)
?.>@!1 .?>@!1 ?=>@!1 =?>@!1 ?_>@!1 _?>@!1 ?0>@!1
और फिर वहाँ सशर्त आई पी चुनाव है, जिसकी पहली आदेश लगभग मनमाने ढंग से चुना जा सकता है का उपयोग करते हुए एक अलग संस्करण है, और वहाँ भी बीच एक विकल्प है )और 1उन विकल्पों में से कुछ के लिए:
"?#1!@ &?#1!@ '?#1!@ )?#1!@ *?#1!@ +?#1!@ -?#1!@ .?#1!@
0?#1!@ 1?#1!@ 2?#1!@ 3?#1!@ 4?#1!@ 5?#1!@ 6?#1!@ 7?#1!@
8?#1!@ 9?#1!@ =?#1!@ ^?#1!@ _?#1!@ {?#1!@ }?#1!@
"?#)!@ &?#)!@ '?#)!@ *?#)!@ +?#)!@ -?#)!@
0?#)!@ 2?#)!@ 4?#)!@ 6?#)!@
8?#)!@ ^?#)!@ _?#)!@ {?#)!@ }?#)!@
1110: नंद
? $
@ # )
! <
आखिरी जटिल। यदि आप अभी भी पढ़ रहे हैं, तो आप इसे लगभग बना चुके हैं। :) चलो A = 0पहले देखो :
?पढ़ता है Aऔर फिर हम हिट करते हैं $। यह एक जम्प कमांड है (जैसे बेफुज का #) जो अगले निर्देश को छोड़ देता है ताकि हम उस पर समाप्त न हों @। इसके बजाय आईपी पर जारी है #। हालाँकि, चूंकि Aयह 0कुछ भी नहीं करता है। )इसे बढ़ाता है 1ताकि IP नीचे के पथ पर जारी रहे जहां 1मुद्रित है। <विक्षेपित सही है, जहां यह छोड़ दिया कोने में लपेटता है और कार्यक्रम समाप्त हो जाता है करने के लिए आईपी।
अगला, जब इनपुट होता है (A, B) = (1, 0)तो हमें यह स्थिति मिलती है:
यह अनिवार्य रूप से पहले की तरह ही है सिवाय इसके कि #हम IP 1(ग्रीन पाथ) पर स्विच करते हैं , लेकिन जब Bसे 0हम दूसरी बार (अब ब्लू पाथ) 0मारते हैं, जब हम पहले की तरह #प्रिंट करते हैं, तो हम IP पर वापस आ जाते हैं 1।
अंत में, A = B = 1मामला:
इस बार, जब हम #दूसरी बार, वर्तमान मूल्य अभी भी 1इतना है कि हम फिर से आईपी नहीं बदलते हैं। <यह दर्शाता है और तीसरी बार हम मारा ?हम एक शून्य मिलता है। इसलिए आईपी बायीं ओर नीचे की ओर जाता है जहां !शून्य को प्रिंट करता है और प्रोग्राम समाप्त होता है।
इसके लिए कुल मिलाकर 9 7-बाइट समाधान हैं। पहला विकल्प केवल 1इसके बजाय उपयोग करता है ):
?$@#1!<
फिर दो समाधान हैं जो आपके सिर को आईपी स्विचिंग की मात्रा के साथ करेंगे जो कि चल रहा है:
)?#_[!@ 1?#_[!@
ये वास्तव में मेरे दिमाग को उड़ा देते हैं: दिलचस्प हिस्सा यह है कि आईपी स्विचिंग का उपयोग आस्थगित सशर्त के रूप में किया जा सकता है। भाषा के आईपी-स्विचिंग नियम ऐसे हैं कि वर्तमान आईपी स्विच होने से पहले एक और कदम बनाता है। यदि वह चरण एक कोने से गुजरने के लिए होता है, तो वर्तमान मूल्य यह तय करता है कि यदि हम कभी भी इसे वापस स्विच करते हैं तो आईपी किस शाखा पर जारी रहेगा। वास्तव में यह तब होता है जब इनपुट होता है A = B = 1। हालाँकि यह सब इस बात के अनुरूप है कि मैंने भाषा को कैसे डिज़ाइन किया है, मुझे कल्पना के इस निहितार्थ के बारे में कभी नहीं पता था, इसलिए यह अच्छा है जब मेरी भाषा मुझे कुछ नए गुर सिखाती है: डी।
फिर एक तीसरा समाधान है जिसकी आईपी स्विचिंग की मात्रा और भी बदतर है (हालांकि यह उस आस्थगित प्रभाव का उपयोग नहीं करता है):
>?1]#!@
और फिर एक और है:
?$@#)!<
और फिर ये चार समान समाधान हैं, जो कुछ गैर-सशर्त आईपी स्विचिंग का उपयोग करते हैं और इसके बजाय शाखाओं और कोनों के माध्यम से सभी तर्क को लागू करते हैं:
]<?<@!) ]<?<@!1 ]|?<@!) ]|?<@!1
1111: सच
1 !
@ . .
. .
आपने खुद को अंत के लिए कुछ सरल अर्जित किया है: किनारे पर सेट करें 1, साथ प्रिंट करें !, समाप्त करें @। :)
बेशक, एक विकल्प है:
)!@
हमेशा की तरह, सभी नियंत्रण प्रवाह आरेख टिमवी के हेक्सागोनीकॉलियर और मेमोरी आरेख के साथ उनके एसोटेरिकाइड के साथ बनाए गए थे ।
