:?
:
#/)
\ #
!"*@
"
इसे ऑनलाइन आज़माएं!
यह C, B, Aलाइनफ़ीड द्वारा अलग किए गए क्रम में परिणामों को आउटपुट करता है ।
व्याख्या
हमेशा की तरह, एक छोटा भूलभुलैया प्राइमर:
- लैब्रिंथ में मनमाने ढंग से सटीक पूर्णांक, मुख्य और ऑक्स (इलरी) के दो ढेर होते हैं, जो शुरू में शून्य (अनंत) अनंत राशि से भरे होते हैं। हम केवल उपयोग करेंगे इस उत्तर के लिए मुख्य ।
- स्रोत कोड एक भूलभुलैया जैसा दिखता है, जहां निर्देश सूचक (आईपी) गलियारों का अनुसरण करता है जब यह (यहां तक कि कोनों के आसपास भी) हो सकता है। कोड पढ़ने के क्रम में पहले वैध चरित्र से शुरू होता है, अर्थात इस मामले में शीर्ष बाएं कोने में। जब आईपी जंक्शन के किसी भी रूप में आता है (यानी इसके अलावा कई आसन्न कोशिकाएं), तो यह मुख्य स्टैक के शीर्ष के आधार पर एक दिशा लेगा। बुनियादी नियम हैं: नकारात्मक होने पर बाएं मुड़ें, शून्य होने पर आगे बढ़ते रहें, सकारात्मक होने पर दाएं मुड़ें। और जब इनमें से एक भी संभव नहीं है क्योंकि दीवार है, तो आईपी विपरीत दिशा में ले जाएगा। मृत सिरों को मारते समय आईपी भी घूमता है।
दो नो-ऑप्स ( ") के बावजूद जो लेआउट को थोड़ा बेकार लगता है, मैं इस समाधान से काफी खुश हूं, क्योंकि इसका नियंत्रण प्रवाह वास्तव में काफी सूक्ष्म है।
IP :दाहिने तरफ ऊपर बाएं कोने में शुरू होता है । यह तुरंत एक मृत अंत को हिट करेगा ?और चारों ओर मुड़ जाएगा, ताकि प्रोग्राम वास्तव में कोड के इस रैखिक टुकड़े से शुरू हो:
: Duplicate top of main stack. This will duplicate one of the implicit zeros
at the bottom. While this may seem like a no-op it actually increases
the stack depth to 1, because the duplicated zero is *explicit*.
? Read n and push it onto main.
: Duplicate.
: Duplicate.
इसका मतलब है कि अब हमें nमुख्य स्टैक पर तीन प्रतियां मिल गई हैं , लेकिन इसकी गहराई है 4। यह सुविधाजनक है क्योंकि इसका मतलब है कि हम इनपुट की प्रतियों के माध्यम से काम करते समय वर्तमान गुणक को प्राप्त करने के लिए स्टैक डेप्थ कर सकते हैं।
आईपी अब (क्लॉकवाइज) 3x3 लूप में प्रवेश करता है। ध्यान दें #, जो स्टैक की गहराई को धक्का देता है, हमेशा एक सकारात्मक मूल्य को धक्का देगा जैसे कि हम जानते हैं कि आईपी हमेशा इस बिंदु पर पूर्व की ओर जाएगा।
लूप बॉडी यह है:
# Push the stack depth, i.e. the current multiplier k.
/ Compute n / k (rounding down).
) Increment.
# Push the stack depth again (this is still k).
* Multiply. So we've now computed (n/k+1)*k, which is the number
we're looking for. Note that this number is always positive so
we're guaranteed that the IP turns west to continue the loop.
" No-op.
! Print result. If we've still got copies of n left, the top of the
stack is positive, so the IP turns north and does another round.
Otherwise, see below...
\ Print a linefeed.
Then we enter the next loop iteration.
!तीन बार लूप ट्रेस होने (अप ) होने के बाद , सभी प्रतियाँn उपयोग किया जाता है और नीचे का शून्य पता चलता है। "तल पर होने के कारण (जो अन्यथा बहुत बेकार लगता है) यह स्थिति एक जंक्शन है। इसका मतलब है कि स्टैक के शीर्ष पर एक शून्य के साथ, आईपी सीधे (पश्चिम) आगे जाने की कोशिश करता है, लेकिन क्योंकि वहाँ एक दीवार है जो वास्तव में 180 डिग्री मोड़ देती है और पूर्व की ओर वापस जाती है जैसे कि यह एक मृत अंत मारा था।
परिणामस्वरूप, निम्न बिट अब निष्पादित की गई है:
" No-op.
* Multiply two zeros on top of the stack, i.e. also a no-op.
The top of the stack is now still zero, so the IP keeps moving east.
@ Terminate the program.
C B Aउत्तर में स्पष्ट रूप से निर्दिष्ट हैं, तो क्या हम (लगातार) एक अलग क्रम में परिणाम (जैसे) आउटपुट कर सकते हैं ?