मैं गर्व से परिचय देता हूं ...
<}74}}:23}29}59}}}}}}}:111_}}}}:::::::23_}:111
? @
:" }}_47}_95 3""""""""(
_ : } _ } {=}
2 23_}29_ _ ; : \
0 ; 3 +_( 3_" 60{ .{.{.
"-_95:}}"" 2 0 ) 2 " _ _ {
"" _ : 2 _ ."(; } 3 .{
;_92}_47} : _ 0 = : * ;
: "" 2 {.{{ . -""(
}}:59_}}:::: "";_ . { _ "
} " {.{.{. 32.
}}}_95:}}}}_20-
... मेरे नए दो आयामी एसोलैंग भूलभुलैया! उपरोक्त कोड अविश्वसनीय रूप से अच्छी तरह से गोल्फ नहीं है (161 रिक्त स्थान और 25 एनओपी हैं, इसलिए एक बेहतर लेआउट इसे बहुत छोटा कर सकता है), लेकिन कम से कम मैं यह दिखाने में कामयाब रहा कि भाषा गैर-तुच्छ कार्यों के लिए उपयोग करने योग्य है। :)
यह काम किस प्रकार करता है
सबसे पहले, भाषा का त्वरित अवलोकन:
- लैब्रिंथ दो स्टैक पर संचालित होता है, मुख्य और सहायक , जो मनमाने ढंग से हस्ताक्षरित पूर्णांक पकड़ सकता है। दोनों स्टैक के निचले भाग में जीरो की अनंत मात्रा होती है।
- कमांड एक 2D ग्रिड पर अलग-अलग वर्ण हैं और वे एक भूलभुलैया बनाते हैं (जो कि अज्ञात वर्ण, विशेष रूप से रिक्त स्थान, दीवारें हैं)।
"एक NOP है जो एक दीवार नहीं है और कोड में कुछ रास्तों को चलाने के लिए सहायक हो सकता है। कई अन्य 2D भाषाओं के विपरीत, किनारों के आसपास लपेट नहीं है।
- निर्देश सूचक (आईपी) पहले गैर-दीवार चरित्र (पढ़ने के क्रम में) से दाईं ओर बढ़ते हुए शुरू होता है।
@कार्यक्रम को समाप्त करता है।
- यदि संभव हो तो, आईपी गलियारों का अनुसरण करता है (झुकता भी)। यदि IP में कई सेल हैं, तो यह आम तौर पर बाईं ओर मुड़ जाएगा यदि मुख्य स्टैक का शीर्ष ऋणात्मक है, शून्य होने पर सीधे आगे बढ़ें या यदि यह सकारात्मक हो तो दाएं मुड़ें। जब IP एक दीवार से टकराती है तो वह दिशा को उलट देती है। (कुछ और सूक्ष्मताएँ हैं, लेकिन उन्हें इस कोड के लिए कोई फर्क नहीं पड़ना चाहिए।) यह नियंत्रण प्रवाह को लागू करने का एकमात्र तरीका है।
- अंकगणित और स्टैक हेरफेर आदेशों के अलावा, स्रोत कोड को चार कमांड के साथ रनटाइम पर संशोधित किया जा सकता है
>v<^जो स्रोत कोड की एक पंक्ति या स्तंभ को एक सेल द्वारा चक्रीय रूप से स्थानांतरित कर देगा। कौन सी पंक्ति या स्तंभ प्रभावित होता है यह स्टैक के शीर्ष पर निर्भर करता है। यदि आईपी की अपनी पंक्ति या कॉलम को स्थानांतरित किया जाता है, तो यह बदलाव के साथ आगे बढ़ेगा। यह स्रोत कोड के एक किनारे से दूसरे तक कूदना संभव बनाता है।
अब इस विशेष चुनौती के लिए, यहाँ एल्गोरिथ्म का सामान्य विचार है:
/ \_o oo oसहायक स्टैक पर बोनट (यानी ) तक कारों के सिरों को पुश करें ।- इनपुट पढ़ें और निर्धारित करें कि पुश करना है
__या /\अगला।
__ __ _/ \सहायक स्टैक पर शेष कारों (यानी और दो प्रमुख स्थान) को पुश करें ।- के अधिकतम मूल्य पर इनपुट को क्लैंप करें
20, चलो इस एन को कॉल करें ।
- अब निम्नलिखित 3 बार करें:
- एन रिक्त स्थान प्रिंट करें ।
- मुद्रित 6 संग्रहीत वर्ण।
- प्रिंट 60 - 3 * एन रिक्त स्थान।
- मुद्रित 6 संग्रहीत वर्ण।
- एक नई लाइन प्रिंट करें।
अंत में, आइए कोड के कुछ हिस्सों को देखें। एक ग्रिड शिफ्टिंग कमांड पर आईपी शीर्ष बाएं कोने में शुरू होता है। मुख्य स्टैक का शीर्ष है 0(जो एक सापेक्ष सूचकांक के रूप में उपयोग किया जाता है), इसलिए पहली पंक्ति को बाईं ओर स्थानांतरित किया जाता है, जो आईपी को ग्रिड के दाईं ओर भी ले जाता है। अब पहली पंक्ति को केवल दाईं से बाईं ओर निष्पादित किया जाता है, जो सहायक स्टैक पर निश्चित वर्णों के पहले सेट को धकेलता है:
}74}}:23}29}59}}}}}}}:111_}}}}:::::::23_}:111<
यह पंक्ति स्थानांतरण गोल्फिंग के लिए उपयोगी है जब आप बड़ी मात्रा में रैखिक कोड के साथ शुरू करना चाहते हैं।
अगला हम इनपुट पढ़ते हैं और सही बोनट को धक्का देते हैं:
?
:"
_
2
0 ;
"-_95:}}""
"" _
;_92}_47}
तीन एनओपी के साथ बाईं ओर का बिट शीर्ष शाखा के साथ नकारात्मक परिणाम और नीचे की शाखा के साथ गैर-नकारात्मक परिणाम भेजता है। दाईं ओर वे वापस एक साथ जुड़ जाते हैं।
अब एक और बड़े रैखिक खंड का अनुसरण करता है (जो शायद एक और पंक्ति-शिफ्टिंग ट्रिक के साथ बहुत बड़ा हो सकता है):
}}_47}_95
: }
23_}29_ _
3
2
:
:
:
}}:59_}}::::
}
}}}_95:}}}}
यह सहायक स्टैक पर शेष कारों को धक्का देता है।
अगला, हम गणना करते हैं min(20, input), जो पहली शाखा के समान है:
;
+_(
0 )
2 _
_ 0
"" 2
"";_
"
_20-
अंत में, हमारे पास लूप है जो लाइनों को प्रिंट करने के लिए तीन बार चलता है। लूप के प्रत्येक पुनरावृत्ति में रिक्त स्थान को मुद्रित करने के लिए दो छोटे (3x3) लूप होते हैं, साथ ही सहायक स्टैक से 6 वर्णों को मुद्रित करने के लिए दो खंड होते हैं:
@
3""""""""(
_ } {=}
: \
3_" 60{ .{.{.
2 " _ _ {
."(; } 3 .{
= : * ;
{.{{ . -""(
. { _ "
{.{.{. 32.
एक निफ्टी ट्रिक जो मैं ध्यान आकर्षित करना चाहूंगा .{.{.वह दाहिने किनारे पर है। यह एक मृत अंत है, इसलिए इसके .अंत में कोड दो बार निष्पादित किया जाता है, एक बार आगे और एक बार पीछे। यह पलिंड्रोमिक कोड को छोटा करने का एक आसान तरीका देता है (पकड़ यह है कि आपको यह सुनिश्चित करने की आवश्यकता है कि मृत अंत से बाहर निकलने पर आईपी सही मोड़ लेता है)।
/ \के रूप में नीचे करने का विरोध किया_ _?