Cubix, 94 83 82 79 63 56 बाइट्स
p>q'-?w.uh'e@U7.'hqi?oqB-!ul.-..$WWu_q<o'\;>....6t?.../!@
विस्तारित:
p > q '
- ? w .
u h ' e
@ U 7 .
' h q i ? o q B - ! u l . - . .
$ W W u _ q < o ' \ ; > . . . .
6 t ? . . . / ! @ . . . . . . .
. . . . . . . . . . . . . . . .
. . . .
. . . .
. . . .
. . . .
टिप्पणियाँ
- प्रोग्राम शुरू होने पर दुभाषिया इनपुट फ़ील्ड को निष्क्रिय कर देता है। जैसे, इनपुट की एक अनंत धारा असंभव है। यह प्रोग्राम इनपुट कैरेक्टर-बाय-कैरेक्टर लेता है, इसलिए यदि यह इस सीमा के लिए नहीं था, तो यह ठीक से काम करेगा।
- यह कार्यक्रम स्टैक को साफ नहीं करता है, और यह बहुत जल्दी गड़बड़ हो जाता है। चूँकि यह मशीन जाहिरा तौर पर अनंत इनपुट स्ट्रीम दे सकती है, इसलिए यह उचित है कि इसमें अनंत स्मृति भी हो।
- किसी भी और सभी गोल्फ मदद की बहुत सराहना की है।
इसे ऑनलाइन आज़माएं
आप यहां कार्यक्रम की कोशिश कर सकते हैं ।
व्याख्या
सामान्य विचार
सामान्य विचार यह है कि हम एक चरित्र को पढ़ना चाहते हैं, और फिर इसे अलग-अलग वर्णों के खिलाफ जांचते हैं (पहले h, फिर e, फिरl आदि)। हमारे द्वारा याद किए गए चरित्र का ट्रैक रखने के लिए, हम इसे स्टैक के बहुत नीचे रखते हैं। जब हमें इसकी आवश्यकता होती है, हम इसे आसानी से फिर से शीर्ष पर ला सकते हैं।
पढ़ें / लिखें पाश
रीड-राइट लूप केवल 5 वीं पंक्ति है। उपयोग नहीं किए जाने वाले सभी वर्णों को प्रतिस्थापित नहीं किया जाता है ( .):
. . . .
. . . .
. . . .
@ . . .
' h q i ? o q B - ! u l . - . .
. . . . _ . . . . . . . . . . .
. . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . .
. . . .
. . . .
. . . .
. . . .
इसे दो भागों में विभाजित किया जा सकता है: पढ़ना और (लिखना और जाँचना)। पहले भाग में प्रश्नचिह्न तक और सहित निर्देश हैं। दूसरा भाग ऊपर की शेष रेखा है। क्योंकि यह छोरों के आसपास है, हम मानते हैं कि हम एक ढेर के साथ शुरू करते हैं[...]
@
'hqi?
_
Explanation
'h Push the character code of the h
Stack: [..., 104]
q Send it to the bottom
Stack: [104, ...]
i Read one character of the input (-1 for EOF)
Stack: [104, ..., input]
? Start of condition:
if (input < 0):
@ execute '@', ending the program
if (input = 0):
continue going right
if (input > 0):
_ turn to the right, reflect back ('_') and
turn right again, effectively not changing
the direction at all
दूसरा भाग (लेखन और जाँच) फिर से रैखिक है। ढेर के रूप में शुरू होता है [next-char, ..., input]। हमने अगले चरित्र को अमूर्त किया, क्योंकि वह बाद में कार्यक्रम में बदल जाता है।
oqB-!ul.- Explanation
o Output the character at the top of the stack
q Send the input to the bottom of the stack
Stack: [input, next-char, ...]
B Reverse the stack
Stack: [..., next-char, input]
- Push the difference of the top two characters, which
is 0 if both are equal, something else otherwise
Stack: [..., next-char, input, diff]
! if (diff = 0):
u make a u-turn to the right
else:
l. execute two no-ops
- push [input - next-char - input], which is disregarded
later, so it effectively is a no-op as well.
अब, आईपी इस लूप की शुरुआत में फिर से शुरू होगा, जांच करने के लिए अगले चरित्र को रीसेट करना h।
अगले चरित्र का मिलान
अगर आईपी ने एक यू-टर्न बनाया (यानी जो चरित्र हम पढ़ते हैं और मुद्रित अगले वर्ण से मेल खाते हैं 'hello'), हमें यह जांचने की आवश्यकता है कि इनपुट किस वर्ण का था और उसके आधार पर, अगले वर्ण को स्टैक के निचले भाग में धकेलें। उसके बाद, हमें पढ़ने / लिखने के पाश पर लौटने की जरूरत है, बिना धक्का दिएh स्टैक पर आवश्यकता है, इसलिए हमें वहां पहुंचने के लिए एक और रास्ता चाहिए।
पहली चीजें पहले: यह निर्धारित करें कि इनपुट किस वर्ण का था। स्टैक इस तरह दिखता है [..., prev-char, input, 0]:।
. . . .
- ? . .
u h ' e
. . . .
. . . . . . . . . ! u . . . . .
. . . . . . . . . \ ; . . . . .
. . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . .
. . . .
. . . .
. . . .
. . . .
इनपुट की तुलना करने के लिए, हम hफिर से वर्ण कोड का उपयोग करते हैं । प्रारंभ में, यह इसलिए था क्योंकि मुझे वास्तव में नहीं पता था कि मैं इसे कैसे संभाल सकता हूं और hयह स्ट्रिंग में पहला चरित्र है, जिसकी जांच करने के लिए यह काफी सुविधाजनक है। यदि हम इनपुट से h के कैरेक्टर कोड को घटाते हैं, तो हमें यह मिलता -3है कि इनपुट है e, 0यदि इनपुट है h, 4यदि इनपुट है lऔर 7यदि इनपुट है o।
यह उपयोगी है, क्योंकि ? कमांड हमें नकारात्मक मूल्यों को सकारात्मक मूल्यों और शून्य से आसानी से अलग करता है। जैसे, यदि आईपी छोड़ दिया जाता है, तो अंतर नकारात्मक था e, इसलिए इनपुट था , इसलिए अगला चरित्र ए होना चाहिए l। यदि आईपी सीधे चलता रहता है, तो अंतर था 0, इसलिए इनपुट था h, इसलिए अगला चरित्र ए होना चाहिए e। यदि इनपुट एक lया एक हैo , तो आईपी सही हो जाता है।
उपरोक्त प्रश्न चिह्न से पहले निष्पादित सभी निर्देश हैं:
;!e'h- Explanation
; Delete the top of the stack
Stack: [..., prev-char, input]
! if (input = 0):
e execute 'e' (no-op)
'h Push the character code of h
Stack: [..., prev-char, input, 104]
- Push the difference of the input and 104
Stack: [..., prev-char, input, 104, diff]
अब आईपी ऊपर की दिशा में अपनी दिशा बदल देता है। चलो विभिन्न संभावनाओं पर चलते हैं।
इनपुट 'e'
पहले हम इनपुट पर विचार करेंगे e , जिसके कारण IP ऊपर की ओर बढ़ता है ?, क्योंकि अंतर 3 है। सभी अप्रासंगिक वर्णों को क्यूब से हटा दिया गया है।
. > q '
. ? . .
. . . .
. . . .
. . q . . . . . . . . l . . . .
$ W W . . . . . . . . > . . . .
. . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . .
. . . .
. . . .
. . . .
. . . .
इस क्रम में वर्ण निष्पादित किए जाते हैं (कुछ नियंत्रण-प्रवाह वर्णों को छोड़कर):
q'l$WWq
q Save the difference (-3) to the bottom of the stack so
we can tell whether the l on the bottom of the stack is
the first or the second l in hello
Stack: [-3, ...]
'l Push the character code of l to the stack
Stack: [-3, ..., 108]
$W no-op
W Sidestep into the loop
q Send the character code to the bottom
Stack: [108, -3, ...]
अब IP फिर से रीड / राइट लूप पर पहुंच गया है।
इनपुट 'h'
यदि इनपुट था 'h', तो अंतर 0 है, इसलिए आईपी अपनी दिशा नहीं बदलता है। यहाँ फिर से क्यूब है, सभी अप्रासंगिक पात्रों को हटा दिया गया है। चूँकि इस रास्ते में काफी कम ऑप्स शामिल हैं, इसके द्वारा पास किए गए सभी ऑप्स को बदल दिया गया है &। आईपी प्रश्न चिह्न पर शुरू होता है।
. . . .
. ? w .
. . ' e
. . . .
. . . . . . . . . ! . . . . . .
. . . u _ q < . . \ . . . . . .
. . ? & & & / . . & . . . . . .
. . & . . . . . . & . . . . . .
. . . .
& & & &
. . . .
. . . .
निष्पादित निर्देश हैं:
'e!\?q_
'e Push the character code of the e
Stack: [..., 101]
! if (101 = 0):
\ reflect away (effectively a no-op)
? if (101 > 0):
turn right (always happens)
q Move 101 to the bottom of the stack
Stack: [101, ...]
_ No-op
और अब हम रीड / राइट लूप में फिर से प्रवेश कर रहे हैं, इसलिए हम कर रहे हैं।
अन्य जानकारी
अन्य सभी इनपुटों में सकारात्मक अंतर होता है, इसलिए आईपी प्रश्न चिह्न पर सही हो जाता है। हमें अभी भी lऔर अलग करने की आवश्यकता हैo , इसलिए हम आगे क्या करेंगे।
अलग करना 'l'और'o'
ध्यान रखें कि अंतर 7 के लिए oऔर 4 के लिए है lऔर हमें प्रोग्राम को समाप्त करना होगा यदि इनपुट ए था o। यहाँ क्यू को फिर से अप्रासंगिक भागों के साथ बदल दिया गया है .और आईपी क्रॉस को नो-ऑप्स द्वारा बदल दिया गया है और इसे एम्परसेंड्स द्वारा बदल दिया गया है।
. . q .
. ? w .
. h ' .
. U 7 .
. . . . . . . . . . . . . - . .
. . . . . . . . . . . . . & . .
. . . . . . / ! @ . . . . & . .
. . . . . . & . . . . . . & . .
. . & .
. . & .
. . & .
. . & .
h7'wq-!@
h no-op
7 Push 7 to the stack
Stack: [..., diff, 7]
'wq Push w to the stack and send it to
the bottom. We don't care about it,
so it's now part of the ellipsis.
Stack: [..., diff, 7]
-! if (diff = 7):
@ End the program
दोनों के बीच भेदभाव 'l' रों
तो, अब हम जानते हैं कि इनपुट एक था l, लेकिन हम नहीं जानते कि कौन सा है l। यदि यह पहला है, तो हमें lस्टैक के नीचे एक और पुश करने की आवश्यकता है , लेकिन अगर यह दूसरा है, तो हमें ए को पुश करने की आवश्यकता है o। याद रखें -3कि हमने पहले धकेलने से ठीक पहले स्टैक के नीचे तक बचाया था l? हम इसका उपयोग दो शाखाओं को अलग करने के लिए कर सकते हैं।
. . . .
. . . .
. . . .
. . . .
. . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . .
6 t ? . . . . . . . . . . . . .
. . . . . . . . . . . . . . . .
. . . .
. . . .
. . . .
. . . .
ढेर के रूप में शुरू होता है [..., -3 or 140, ...]
Explanation
6t?
6t Take the 6th item from the top and move
it to the top (which is either -3 or 140)
? If that's positive, turn right, otherwise,
turn left
प्रथम 'l'
यदि यह पहला था 'l', तो हमें दूसरे को आगे बढ़ाने की जरूरत है 'l'। बाइट्स को बचाने के लिए, हम पहले जैसे ही वर्णों का उपयोग करते हैं 'l'। हम स्टैक को सरल बना सकते हैं [...]। यहां क्यूब का प्रासंगिक हिस्सा है, जिसमें एम्परसेंड द्वारा प्रतिस्थापित ओप्स नहीं है।
p > q '
. . . .
. . . .
. . . .
' . q . . . . . . . . l . . . .
$ W W . . . . . . . . > & & & &
. . ? . . . . . . . . . . . . .
. . . . . . . . . . . . . . . .
. . . .
. . . .
. . . .
. . . .
निम्नलिखित निर्देशों को निष्पादित किया जाता है:
$'pq'lq
$' no-op
pq no-op
'l Push the character code of l
Stack: [..., 108]
q Send it to the bottom
Stack: [108, ...]
हम रीड / राइट लूप में प्रवेश करने वाले हैं, इसलिए हम इस शाखा के साथ काम कर रहे हैं।
दूसरा 'l'
यदि इनपुट दूसरा 'l'था 'hello', तो प्रश्न चिह्न पर IP सही निकला। एक बार फिर, हम स्टैक को सरल बना सकते हैं [...]और आईपी ?इस समय दक्षिण की ओर इशारा करते हुए शुरू होता है ।
. . . .
. . . .
. . . .
. . . .
. . . . . . . . . . . . . . . .
. . . u _ q < o ' \ . . . . . .
. . ? . . . . . . & . . . . . .
. . & . . . . . . & . . . . . .
. . . .
& & & &
. . . .
. . . .
निष्पादित निर्देश हैं:
'oq_
'o Push the character code of 'o'
Stack: [..., 111]
q Move the top item to the bottom
Stack: [111, ...]
_ No-op
और IP फिर से रीड / राइट लूप दर्ज करने वाला है, इसलिए हम इस शाखा के साथ भी काम कर रहे हैं।