रेटिना , 108 102 94 87 82 64 63 बाइट्स
मेरे मूल दृष्टिकोण को आगे बढ़ाने के लिए Sp3000 का धन्यवाद, जिसने बाइट की गिनती 108 से घटाकर 82 कर दी।
कोबी के लिए बड़े पैमाने पर धन्यवाद, जिसने बहुत अधिक सुरुचिपूर्ण समाधान पाया, जिसने मुझे उस के शीर्ष पर एक और 19 बाइट्स को बचाने की अनुमति दी।
S_`(?<=^(?<-1>.)*(?:(?<=\G(.)*).)+)
.
$0
m+`^(?=( *)\S.*\n\1)
<space>
जहां <space>एक एकल अंतरिक्ष चरित्र का प्रतिनिधित्व करता है (जो अन्यथा एसई द्वारा छीन लिया जाएगा)। गिनती के उद्देश्यों के लिए, प्रत्येक पंक्ति एक अलग फ़ाइल में जाती है और \nइसे वास्तविक लाइनफ़ीड वर्ण से प्रतिस्थापित किया जाना चाहिए। सुविधा के लिए, आप कोड को चला सकते हैं जैसा कि -sझंडे के साथ एक एकल फ़ाइल से है ।
इसे ऑनलाइन आज़माएं।
व्याख्या
खैर ... हमेशा की तरह मैं यहाँ समूहों को संतुलित करने के लिए पूर्ण परिचय नहीं दे सकता। प्राइमर के लिए मेरा स्टैक ओवरफ्लो उत्तर देखें ।
S_`(?<=^(?<-1>.)*(?:(?<=\G(.)*).)+)
पहला चरण एक Sप्लिट चरण है, जो इनपुट को बढ़ती लंबाई की रेखाओं में विभाजित करता है। _इंगित करता है कि खाली हिस्सा बंटवारे (जो केवल अंत को प्रभावित करता है, क्योंकि वहाँ अंतिम स्थिति में एक मैच हो जाएगा) से हटा दिया जाना चाहिए। रेगेक्स स्वयं पूरी तरह से एक लुक-अराउंड में समाहित है, इसलिए यह किसी भी वर्ण से मेल नहीं खाता, लेकिन केवल स्थिति।
यह हिस्सा कुछ अतिरिक्त गोल्फ के साथ कोबी के समाधान पर आधारित है जो मैंने खुद पाया। ध्यान दें कि lookbehinds .NET में राइट-टू-लेफ्ट से मेल खाते हैं, इसलिए निम्नलिखित स्पष्टीकरण को नीचे से ऊपर तक पढ़ा जाना चाहिए। मैंने \Gस्पष्टीकरण के लिए स्पष्टीकरण में एक और डाला है , हालांकि यह काम करने के लिए पैटर्न के लिए आवश्यक नहीं है।
(?<=
^ # And we ensure that we can reach the beginning of the stack by doing so.
# The first time this is possible will be exactly when tri(m-1) == tri(n-1),
# i.e. when m == n. Exactly what we want!
(?<-1>.)* # Now we keep matching individual characters while popping from group <1>.
\G # We've now matched m characters, while pushing i-1 captures for each i
# between 1 and m, inclusive. That is, group <1> contains tri(m-1) captures.
(?:
(?<=
\G # The \G anchor matches at the position of the last match.
(.)* # ...push one capture onto group <1> for each character between here
# here and the last match.
) # Then we use a lookahead to...
. # In each iteration we match a single character.
)+ # This group matches all the characters up to the last match (or the beginning
# of the string). Call that number m.
) # If the previous match was at position tri(n-1) then we want this match
# to happen exactly n characters later.
मैं अब भी कोबी के काम की प्रशंसा कर रहा हूं। यह प्राइम टेस्टिंग रेगेक्स की तुलना में अधिक सुरुचिपूर्ण है। :)
चलिए अगले चरण पर चलते हैं:
.
$0
सरल: प्रत्येक गैर-लाइनफीड चरित्र के बाद एक स्थान डालें।
m+`^(?=( *)\S.*\n\1)
<space>
यह अंतिम चरण त्रिकोण बनाने के लिए सभी पंक्तियों को सही ढंग से इंगित करता है। mबनाने के लिए बस हमेशा की तरह बहु विधा है ^एक पंक्ति के आरंभ से मेल खाते हैं। +इस स्तर को दोहराने के लिए रेटिना बताता है जब तक स्ट्रिंग को बदलने बंद हो जाता है (जो है, इस मामले में अर्थ है कि regex अब मैचों)।
^ # Match the beginning of a line.
(?= # A lookahead which checks if the matched line needs another space.
( *) # Capture the indent on the current line.
\S # Match a non-space character to ensure we've got the entire indent.
.*\n # Match the remainder of the line, as well as the linefeed.
\1 # Check that the next line has at least the same indent as this one.
)
तो यह किसी भी पंक्ति की शुरुआत से मेल खाता है जिसमें अगले की तुलना में बड़ा इंडेंट नहीं है। ऐसी किसी भी स्थिति में हम एक स्थान सम्मिलित करते हैं। यह प्रक्रिया समाप्त हो जाती है, एक बार लाइनों को एक साफ त्रिकोण में व्यवस्थित किया जाता है, क्योंकि यह न्यूनतम लेआउट है जहां प्रत्येक पंक्ति में अगले की तुलना में बड़ा इंडेंट होता है।