<
,,}:?
.
;(" {(={}{".
,",;=};} }) "{@
इनपुट Nस्ट्रिंग द्वारा पीछा किया जाता है, किसी भी गैर-संख्यात्मक चरित्र द्वारा अलग किया जाता है।
इसे ऑनलाइन आज़माएं!
यह Sp3000 के साथ मिलकर लिखा गया था (जिसका अर्थ है कि मुझे एक एल्गोरिथ्म का पता लगाने के लिए परेशान नहीं किया जा सकता है, इसलिए उन्होंने इस पर काम करना शुरू कर दिया, 118 बाइट समाधान के साथ आया लेकिन इसे गोल्फिंग से परेशान नहीं किया जा सकता था, इसलिए मैंने गोल्फ किया। .. टीम वर्क के लिए याय)।
व्याख्या
सपा के सामान्य प्राइमर (हमेशा की तरह थोड़ा संशोधित):
- भूलभुलैया एक स्टैक-आधारित 2 डी भाषा है, जिसमें दो ढेर हैं, मुख्य और सहायक। बहुत कुछ सब कुछ मुख्य स्टैक पर होता है, लेकिन आप मूल्यों को दूसरे पर शिफ्ट कर सकते हैं, जैसे कि उन्हें उल्टा करना या बाद में उन्हें सहेजना।
- ढेर नीचे और शून्य से भरे होते हैं, इसलिए खाली स्टैक से पॉपिंग करना कोई त्रुटि नहीं है।
- निष्पादन पहले वैध चरित्र (यहां शीर्ष बाएं) से शुरू होता है। प्रत्येक जंक्शन पर, जहां निर्देश सूचक (आईपी) के लिए दो या अधिक संभावित रास्ते हैं, आगे जाने के लिए यह निर्धारित करने के लिए स्टैक के शीर्ष की जाँच की जाती है। नेगेटिव लेफ्ट है, जीरो आगे है और पॉजिटिव राइट है। एक ओर जहां यह किया गया था मतलब घुमावदार, twisty मार्ग की तरह कोड देखो बनाने के लिए, वहाँ "कमरे" जहाँ इन शर्तों के हर सेल में जाँच कर रहे हैं करने से रोक रहा है कुछ भी नहीं है। वे काफी अप्रत्याशित व्यवहार पैदा कर सकते हैं, लेकिन गोल्फ के लिए महान हैं।
- स्रोत कोड (और इसलिए भूलभुलैया के लेआउट) को रनटाइम पर संशोधित किया जा सकता है,
<>^vजिसमें एक चक्र या स्तंभ या ग्रिड को स्थानांतरित किया जाता है।
" ऑप्स नहीं हैं।
ये रहा।
कोड पर शुरू होता है <, जो कि एक गोल्फ चाल है जिसे मैंने रैखिक कोड के लंबे टुकड़े के साथ शुरू करते समय कुछ बार उपयोग किया है। यह पहली पंक्ति को चक्रवात से बाईं ओर बदलता है, उस पर आईपी के साथ , इसलिए स्रोत फिर इस तरह दिखता है:
<
,,}:?
.
;(" {(={}{".
,",;=};} }) "{@
लेकिन अब आईपी कहीं भी स्थानांतरित नहीं हो सकता है, इसलिए यह <फिर से निष्पादित करता है । यह तब तक जारी रहता है जब तक हम इस अवस्था तक नहीं पहुँच जाते:
<
,,}:?
.
;(" {(={}{".
,",;=};} }) "{@
इस बिंदु पर, आईपी सेल छोड़ सकता है और दूसरी लाइन को शुरू करना शुरू कर सकता है ?। तो यहाँ रैखिक कोड टूट गया है:
? # Read the first integer on STDIN, i.e. N.
:} # Duplicate it and move one copy over to the auxiliary stack.
, # Read the separator character.
,. # Read the first character of the input string and directly print it.
आईपी अब इस 3x2 कमरे में प्रवेश करता है, जो वास्तव में दो कसकर संकुचित (अतिव्यापी) 2x2 दक्षिणावर्त छोरों है। पहला लूप N-1STDIN के वर्णों को पढ़ता है और उनकी व्याख्या करता है।
; # Discard the top of the stack. On the first iteration, this is the
# separator we've already read. On subsequent iterations this will be
# one of the N-1 characters from the input string.
( # Decrement N. If this hits zero, we leave the loop, otherwise we continue.
, # Read the next character from STDIN to be discarded.
अब हम दूसरे लूप में प्रवेश करते हैं जो इनपुट स्ट्रिंग के शेष भाग को पढ़ता है। हम ईओएफ का पता लगा सकते हैं क्योंकि उस मामले में ,वापस आ जाएगा -1, जिससे आईपी मोड़ बचेगा।
, # Read a character. Exit the loop if EOF.
( # Decrement it.
यह कमी वास्तव में उपयोगी नहीं है, लेकिन हम इसे बाद में मुफ्त में पूर्ववत कर सकते हैं और यहां यह हमें दो छोरों को ओवरलैप करने की अनुमति देता है।
यदि हम 5 ABCDEFGHIJKLMNOPइनपुट को एक उदाहरण के रूप में लेते हैं , तो स्टैक इस तरह दिखता है:
Main [ ... 'E' 'F' 'G' 'H' 'I' 'J' 'K' 'L' 'M' 'N' 'O' -1 | 5 ... ] Auxiliary
ध्यान दें कि ये वास्तव में इनपुट वर्णों के अनुरूप हैं FGHIJKLMNOP(क्योंकि हमने उन्हें डिक्रिप्ट किया है), और यह कि हम वास्तव में उनमें से पहला प्रिंट नहीं करना चाहते हैं (हम केवल N-1वर्णों को छोड़ चुके हैं, लेकिन छोड़ना चाहते हैं N)।
अब एक छोटी रैखिक बिट है जो अगले लूप के लिए स्टैक तैयार करती है:
; # Discard the -1.
= # Swap the tops of the stacks, i.e. N with the last character.
# By putting the last character on the auxiliary stack, we ensure that
# it doesn't get discarded in the next loop.
} # Move N over to the auxiliary stack as well.
स्टैक अब जैसे दिखते हैं:
Main [ ... 'E' 'F' 'G' 'H' 'I' 'J' 'K' 'L' 'M' 'N' | 5 'O' ... ] Auxiliary
हम एक और 2x2 दक्षिणावर्त लूप दर्ज करते हैं। यह Nमुख्य पात्र से शीर्ष वर्णों को निकालता है:
; # Discard the top of the main stack.
{ # Pull N over from the auxiliary stack.
( # Decrement it. It it's 0 we leave the loop.
} # Push N back to the auxiliary stack.
जब हम बाहर निकलते हैं तो लूप =स्वैप होता है 0और इनपुट स्ट्रिंग के अंतिम वर्ण को फिर से। अब स्टैक इस तरह दिखते हैं:
Main [ ... 'E' 'F' 'G' 'H' 'I' 'O' | ... ] Auxiliary
हम मुख्य स्टैक की सामग्री को प्रिंट करना चाहते हैं (नीचे के तत्व को छोड़कर और सभी 1 से बढ़े हुए), बाईं ओर से । इसका मतलब है कि हमें इसे सहायक स्टैक पर लाने की आवश्यकता है। यही अगले 2x2 (दक्षिणावर्त) लूप करता है:
{ # Pull an element over from the auxiliary stack. This is necessary so we
# have a 0 on top of the stack when entering the loop, to prevent the IP
# from turning right immediately.
} # Move the top of the main stack back to the auxiliary stack. If this was the
# bottom of the stack, exit the loop.
) # Increment the current character.
} # Move it over to the auxiliary stack.
ढेर अब:
Main [ ... | 'F' 'G' 'H' 'I' 'J' 'P] ... ] Auxiliary
हम उनमें से पहले को स्थानांतरित करते हैं (एक जिसे हम प्रिंट नहीं करना चाहते हैं) मुख्य स्टैक के साथ वापस आ जाते हैं {। और अब हम अंतिम 2x2 ( वामावर्त ) लूप में प्रवेश करते हैं, जो बाकी प्रिंट करता है:
{ # Pull another character over from the auxiliary stack. Exit the loop
# if that's the zero at the bottom of the stack.
. # Print the character.
अंत में हम के साथ कार्यक्रम समाप्त करते हैं @।
'गिनती के चरित्र के समान कुछ के साथ एन को लेना ठीक है ? उदाहरण के लिए''123321:?