यह बेहद मजेदार था। इस चुनौती को पोस्ट करने के लिए धन्यवाद।
पूर्ण प्रकटीकरण: जिस समय यह चुनौती पोस्ट की गई थी उस समय भाषा (हेक्सागोनी) मौजूद नहीं थी। हालाँकि, मैंने इसका आविष्कार नहीं किया था, और भाषा को इस चुनौती (या किसी अन्य विशिष्ट चुनौती) के लिए नहीं बनाया गया था।
){_2"_{\"{{""}"{'2//_.\><*\"\/_><[\]/3\'\_;|#__/(\2\'3_'}(#:|{$#{>_\//(#={/;01*&"\\_|[##={|}$_#></)]$_##|){*_.>.(/?#//~-="{}<_"=#/\}.>"%<.{#{x\"<#_/=&{./1#_#>__<_'\/"#|@_|/{=/'|\"".{/>}]#]>(_<\'{\&#|>=&{{(\=/\{*'"]<$_
हेक्सागोनली से बाहर निकलना:
) { _ 2 " _ { \ "
{ { " " } " { ' 2 /
/ _ . \ > < * \ " \ /
_ > < [ \ ] / 3 \ ' \ _
; | # _ _ / ( \ 2 \ ' 3 _
' } ( # : | { $ # { > _ \ /
/ ( # = { / ; 0 1 * & " \ \ _
| [ # # = { | } $ _ # > < / ) ]
$ _ # # | ) { * _ . > . ( / ? # /
/ ~ - = " { } < _ " = # / \ } .
> " % < . { # { x \ " < # _ /
= & { . / 1 # _ # > _ _ < _
' \ / " # | @ _ | / { = /
' | \ " " . { / > } ] #
] > ( _ < \ ' { \ & #
| > = & { { ( \ = /
\ { * ' " ] < $ _
कार्यक्रम वास्तव में #निर्देश का उपयोग नहीं करता है , इसलिए मैंने उस चरित्र का उपयोग यह दिखाने के लिए किया कि कौन सी कोशिकाएं वास्तव में अप्रयुक्त हैं।
यह कार्यक्रम कैसे काम करता है? वह निर्भर करता है। क्या आप छोटा संस्करण चाहते हैं, या लंबा?
संक्षिप्त व्याख्या
निम्नलिखित स्पष्टीकरण में "लाइन" और "सेगमेंट" से मेरा क्या मतलब है, यह समझाने के लिए, इच्छित आउटपुट के इस विच्छेदन पर विचार करें:
segments →
│ │ │ │ │ │x lines
─┼───┼─┼─────────┼─┼───┼─ ↓
│ │ │ │ │xxx│
─┼───┼─┼─────────┼─┼───┘
│ │ │ │x│
─┼───┼─┼─────────┼─┘
│ │ │xxxxxxxxx│
─┼───┼─┼─────────┘
│ │x│
─┼───┼─┘
│xxx│
─┼───┘
x│
उस व्याख्या के साथ, यह कार्यक्रम निम्नलिखित छद्मकोश से मेल खाता है:
n = get integer from stdin
# Calculate the number of lines we need to output.
line = pow(2, n+1)
while line > 0:
line = line - 1
# For all segments except the last, the character to use is spaces.
ch = ' ' (space, ASCII 32)
# The number of segments in each line is
# equal to the line number, counting down.
seg = line
while seg > 0:
seg = seg - 1
# For the last segment, use x’s.
if seg = 0:
ch = 'x' (ASCII 120)
# Calculate the actual segment number, where the leftmost is 1
n = line - seg
# Output the segment
i = pow(3, number of times n can be divided by 2)
i times: output ch
output '\n' (newline, ASCII 10)
end program
लंबी व्याख्या
कृपया इस रंग-कोडित कोड पथ आरेख को देखें।
शीर्ष बाएं कोने में निष्पादन शुरू होता है। निर्देशों ){2'"''3''"2}?)का अनुक्रम "{एक बहुत ही जटिल मार्ग का अनुसरण करके निष्पादित किया जाता है (साथ ही कुछ अनावश्यक निरस्तीकरण, आदि)। हम इंस्ट्रक्शन पॉइंटर # 0 से शुरू करते हैं, जिसे क्रिमसन में हाइलाइट किया गया है। आधे रास्ते में, हम # 1 पर स्विच करते हैं, शीर्ष-दाएं कोने में शुरू करते हैं और वन ग्रीन में चित्रित होते हैं। जब आईपी # 2 कॉर्नफ्लॉवर ब्लू (मध्य दाएं) में शुरू होता है, तो मेमोरी लेआउट यह है:
पूरे कार्यक्रम के दौरान, 2 ए और 2 बी लेबल वाले किनारों का हमेशा मान होगा 2(हम उन्हें 2ⁿ⁺¹ की गणना करने के लिए और क्रमशः 2 से विभाजित करने के लिए उपयोग करते हैं) और 3 लेबल वाले किनारे हमेशा रहेंगे 3(हम उपयोग करते हैं कि 3ⁱ की गणना करें)।
हम अपने पहले लूप में प्रवेश करते ही व्यापार को प्राप्त कर लेते हैं, जिसे कॉर्नफ्लावर ब्लू में हाइलाइट किया जाता है। यह लूप (}*{=&}{=मान 2 exec की गणना करने के निर्देशों को निष्पादित करता है । जब लूप निकल जाता है, तो काठी भूरा रास्ता ले लिया जाता है, जो हमें निर्देश सूचक # 3 पर ले जाता है। यह आईपी केवल गोल्डनरोड पीले रंग में पश्चिम की ओर नीचे किनारे के साथ डबल्स करता है और जल्द ही आईपी # 4 को नियंत्रित करता है।
फुचिया पथ इंगित करता है कि कैसे आईपी # 4, नीचे बाईं ओर शुरू, तेजी से क्षय रेखा के लिए आगे बढ़ता है , ch को 32(स्थान वर्ण) और seg to (नया मूल्य) रेखा पर सेट करता है । यह शुरुआती गिरावट के कारण है कि हम वास्तव में 2− eventually 1 से शुरू करते हैं और अंततः मूल्य 0. के साथ एक अंतिम पुनरावृत्ति का अनुभव करते हैं। हम फिर पहले नेस्टेड लूप में प्रवेश करते हैं ।
हम अपना ध्यान उस ब्रिगेड इंडिगो की ओर मोड़ते हैं, जहाँ, seg की थोड़ी कमी के बाद , हम ch को xकेवल तभी अपडेट करते हुए देखते हैं, जब seg अब शून्य है। बाद में, n को लाइन में सेट किया जाता है - हम जिस सेगमेंट में हैं उसकी वास्तविक संख्या निर्धारित करने के लिए। तुरंत हम एक और लूप दर्ज करते हैं, इस बार टमाटर के उचित रंग में।
यहां, हम यह पता लगाते हैं कि n कितनी बार n (वर्तमान खंड संख्या) 2 से विभाजित किया जा सकता है। जब तक मॉडुलो हमें शून्य देता है, हम वृद्धि करते हैं I और n को 2 से विभाजित करते हैं। जब हम संतुष्ट होते हैं तो n अब इस तरह से विभाज्य नहीं है , हम स्लेट ग्रे में शाखा करते हैं, जिसमें दो लूप होते हैं: पहले यह 3 की शक्ति बढ़ाता है I हमने गणना की, और फिर यह कई बार ch आउटपुट करता है। गौर करें कि इनमें से पहले छोरों में ए[निर्देश, जो आईपी # 3 पर नियंत्रण स्विच करता है - वह जो केवल नीचे के किनारे के साथ बच्चे के कदम उठा रहा था। लूप के शरीर (3 से गुणा और घटते हुए) को एक अकेला आईपी # 3 द्वारा निष्पादित किया जाता है, जो कोड के निचले किनारे के साथ एक अंतहीन अंधेरे जैतून के हरे चक्र में कैद है। इसी तरह, इन स्लेट ग्रे लूप्स के दूसरे हिस्से में एक ]निर्देश है, जो आईपी # 5 को आउटपुट च और डिक्रीमेंट को सक्रिय करता है, जो यहां गहरे भारतीय लाल में दिखाया गया है। दोनों मामलों में, सेवा में फंसे उन इंस्ट्रक्शन पॉइंटर्स को आज्ञाकारी रूप से एक समय में एक पुनरावृत्ति निष्पादित करते हैं और आईपी # 4 पर वापस नियंत्रण प्राप्त करते हैं, केवल एक बार फिर से उनकी सेवा के लिए पल को बांधने के लिए। इस बीच, स्लेट ग्रे, इसके फ्यूशिया और इंडिगो ब्रेट्रेन के साथ जुड़ जाता है।
जैसे ही एसईजी अनिवार्य रूप से शून्य तक पहुंचता है, इंडिगो लूप लॉन ग्रीन पथ से बाहर निकलता है, जो केवल न्यूलाइन वर्ण को आउटपुट करता है और तुरंत लाइन लूप को जारी रखने के लिए फ्यूशिया में वापस विलीन हो जाता है । लाइन लूप के अंतिम पुनरावृत्ति से परे अंतिम कार्यक्रम समाप्ति का छोटा सेबल एबॉन पथ निहित है।
(,],~3^#@~.)@]बजाय पावर लूप के अंदर(1,[:,1,"0~3*])। और अगर आप!आउटपुट चार के रूप में एक और एकu:32+को' #'{~बचाने के बजाय ठीक कर रहे हैं ।