रेटिना , 744 बाइट्स
क्षमा करें दोस्तों, इस बार कोई हेक्सागोनी नहीं ...
बाइट गिनती आईएसओ 8859-1 एन्कोडिंग मानती है।
.+¶
$.'$*_¶$&
^_¶
¶
((^_|\2_)*)_\1{5}_+
$2_
^_*
$.&$*×_$&$&$.&$*×
M!&m`(?<=(?=×*(_)+)\A.*)(?<-1>.)+(?(1)!)|^.*$
O$`(_)|.(?=.*$)
$1
G-2`
T`d`À-É
m`\A(\D*)(?(_)\D*¶.|(.)\D*¶\2)((.)(?<=(?<4>_)\D+)?((?<=(?<1>\1.)\4\D*)|(?<=(?<1>\D*)\4(?<=\1)\D*)|(?<=\1(.(.)*¶\D*))((?<=(?<1>\D*)\4(?>(?<-7>.)*)¶.*\6)|(?<=(?<1>\D*)(?=\4)(?>(?<-7>.)+)¶.*\6))|(?<=(×)*¶.*)((?<=(?<1>\1.(?>(?<-9>¶.*)*))^\4\D*)|(?<=(?<1>\D*)\4(?>(?<-9>¶.*)*)(?<=\1)^\D*)|(?<=(?<1>\1\b.*(?(9)!)(?<-9>¶.*)*)\4×*¶\D*)|(?<=(?<1>\D*\b)\4.*(?(9)!)(?<-9>¶.*)*(?<=\1.)\b\D*))|(?<=(?<1>\1.(?>(?<-11>.)*)¶.*)\4(.)*¶\D*)|(?<=(?<1>\1(?>(?<-12>.)*)¶.*)\4(.)*¶\D*)|(?<=(?<1>\1.(?>(?<-13>.)*¶\D*))\4(\w)*\W+.+)|(?<=(?<1>.*)\4(?>(?<-14>.)*¶\D*)(?<=\1.)(\w)*\W+.+))(?<=\1(\D*).+)(?<!\1\15.*(?<-1>.)+))*\Z
पहली पंक्ति पर लक्ष्य स्ट्रिंग और इनपुट की दूसरी पंक्ति पर षट्भुज की अपेक्षा करता है। प्रिंट 0या 1तदनुसार।
इसे ऑनलाइन आज़माएं! (पहली पंक्ति एक परीक्षण सूट को सक्षम करती है, जहां प्रत्येक पंक्ति एक परीक्षण का मामला है, ¦लाइनफीड के बजाय अलगाव के लिए उपयोग करती है ।)
इस चुनौती को हल करने का उचित तरीका निश्चित रूप से regex है। ;) और अगर यह इस तथ्य के लिए नहीं था कि इस चुनौती में हेक्सागोन की खुलासा प्रक्रिया भी शामिल है , तो इस जवाब में वास्तव में एक एकल ~ 600-बाइट लंबे रेगेक्स के अलावा कुछ भी नहीं होगा।
यह अभी तक काफी उम्मीद के मुताबिक नहीं है, लेकिन मैं परिणाम से काफी खुश हूं (मेरा पहला वर्किंग वर्जन, नाम वाले समूहों को हटाने के बाद और स्वच्छता के लिए आवश्यक अन्य सामान, लगभग 1000 बाइट्स था)। मुझे लगता है कि मैं स्ट्रिंग और षट्भुज के क्रम को स्वैप करके लगभग 10 बाइट्स बचा सकता हूं, लेकिन इसके लिए अंत में रेगेक्स को फिर से लिखना होगा, जिसे मैं अभी महसूस नहीं कर रहा हूं। Gमंच को छोड़ने से 2-बाइट की बचत भी होती है , लेकिन यह समाधान को काफी धीमा कर देता है, इसलिए मैं उस बदलाव को करने के साथ इंतजार करूंगा जब तक कि मुझे यकीन नहीं हो जाता कि मैंने इसे और साथ ही साथ गोल्फ भी खेला।
व्याख्या
इस समाधान का मुख्य भाग संतुलन समूहों का व्यापक उपयोग करता है , इसलिए मैं उन पर पढ़ने की सलाह देता हूं, यदि आप यह समझना चाहते हैं कि यह कैसे विस्तार से काम करता है (यदि आप नहीं करते हैं तो मैं आपको दोष नहीं दूंगा ...)।
समाधान का पहला भाग (यानी पिछली दो पंक्तियों को छोड़कर सब कुछ) हेक्सागोनी स्रोत कोड को अनफॉलो करने के लिए मेरे उत्तर का एक संशोधित संस्करण है । यह षट्कोण का निर्माण करता है, जबकि लक्ष्य स्ट्रिंग को अछूता छोड़ता है (और यह वास्तव में लक्ष्य स्ट्रिंग से पहले षट्कोण का निर्माण करता है)। मैंने बाइट्स को बचाने के लिए पिछले कोड में कुछ बदलाव किए हैं:
- बैकग्राउंड कैरेक्टर
×एक स्पेस के बजाय है ताकि यह इनपुट में संभावित स्पेस के साथ संघर्ष न करे।
- नो-ऑप / वाइल्डकार्ड वर्ण
_इसके बजाय है ., ताकि ग्रिड कोशिकाओं को शब्द वर्णों के रूप में मज़बूती से पहचाना जा सके।
- षट्भुज के पहली बार निर्माण के बाद मैं कोई स्थान या इंडेंटेशन सम्मिलित नहीं करता हूं। यह मुझे एक पतला षट्भुज देता है, लेकिन यह वास्तव में काम करने के लिए बहुत अधिक सुविधाजनक है और आसन्न नियम काफी सरल हैं।
यहाँ एक उदाहरण है। निम्नलिखित परीक्षण मामले के लिए:
ja
abcdefghij
हमें मिला:
××abc
×defg
hij__
____×
___××
ja
इसकी तुलना षट्भुज के सामान्य लेआउट से करें:
a b c
d e f g
h i j _ _
_ _ _ _
_ _ _
हम देख सकते हैं कि पड़ोसी अब उत्तर-पश्चिम और दक्षिण-पूर्व पड़ोसियों को छोड़कर सभी सामान्य 8 मूर-पड़ोसी हैं। इसलिए हमें क्षैतिज, ऊर्ध्वाधर और दक्षिण-पश्चिम / उत्तर-पूर्व आसन्न (अच्छी तरह से और फिर लपेटने वाले किनारे) की जांच करने की आवश्यकता है। इस अधिक कॉम्पैक्ट लेआउट का उपयोग करने पर बोनस भी मिलता है जिसे हम ××मक्खी पर षट्भुज के आकार को निर्धारित करने के लिए उपयोग कर सकते हैं जब हमें इसकी आवश्यकता होती है।
इस फॉर्म के निर्माण के बाद, हम पूरे स्ट्रिंग में एक और बदलाव करते हैं:
T`d`À-É
यह विस्तृत ASCII पत्रों के साथ अंकों की जगह लेता है
ÀÁÂÃÄÅÆÇÈÉ
चूंकि वे दोनों हेक्सागोन में और लक्ष्य स्ट्रिंग में बदल दिए जाते हैं, इसलिए यह प्रभावित नहीं होगा कि स्ट्रिंग मिलान किया गया है या नहीं। इसके अलावा, चूंकि वे अक्षर हैं \wऔर \bअभी भी उन्हें षट्भुज कोशिकाओं के रूप में पहचानते हैं। इस प्रतिस्थापन को करने का लाभ यह है कि अब हम \Dआगामी रेगेक्स में किसी भी वर्ण (विशेषकर, लाइनफीड के साथ-साथ गैर-लाइनफीड पात्रों) का मिलान करने के लिए उपयोग कर सकते हैं । हम इसे sपूरा करने के लिए विकल्प का उपयोग नहीं कर सकते , क्योंकि हमें .कई स्थानों पर गैर-लाइनफीड पात्रों से मेल खाना होगा ।
अब अंतिम बिट: यह निर्धारित करना कि क्या कोई पथ हमारे दिए गए स्ट्रिंग से मेल खाता है। यह एक एकल राक्षसी रीगेक्स के साथ किया जाता है। आप अपने आप से पूछ सकते हैं क्यों!?! ठीक है, यह मूल रूप से एक बैकट्रैकिंग समस्या है: आप कहीं से शुरू करते हैं और जब तक यह स्ट्रिंग से मेल खाता है, तब तक एक पथ का प्रयास करते हैं, और एक बार जब आप बैकट्रैक नहीं करते हैं और पिछले चरित्र से एक अलग पड़ोसी की कोशिश करते हैं जो काम करता है। एक बातरेगेक्स के साथ काम करने पर आपको मुफ्त में मिलता है। वस्तुतः यही एकमात्र चीज है जो रेगेक्स इंजन करता है। इसलिए यदि हम केवल एक वैध मार्ग का वर्णन करने के लिए एक रास्ता खोजते हैं (जो इस तरह की समस्या के लिए काफी मुश्किल है, लेकिन निश्चित रूप से संतुलन समूहों के साथ संभव है), तो रेगेक्स इंजन हमारे लिए सभी संभव लोगों के बीच उस मार्ग को खोजने का प्रयास करेगा। यह निश्चित रूप से कई चरणों के साथ मैन्युअल रूप से लागू करना संभव होगा ( और मैंने अतीत में ऐसा किया है ), लेकिन मुझे संदेह है कि यह इस विशेष मामले में छोटा होगा।
एक regex के साथ इसे लागू करने के साथ एक मुद्दा यह है कि हम मनमाने ढंग से regex इंजन के कर्सर को आगे और पीछे के माध्यम से स्ट्रिंग के माध्यम से बुनाई नहीं कर सकते हैं (जिसकी हमें आवश्यकता होगी क्योंकि पथ ऊपर या नीचे जा सकता है)। इसलिए इसके बजाय, हम एक कैप्चरिंग ग्रुप में अपने "कर्सर" पर नज़र रखते हैं और अपडेट करते हैं कि हर कदम पर (हम अस्थायी रूप से कर्सर की स्थिति में एक नज़र के साथ स्थानांतरित कर सकते हैं)। यह हमें पिछले सभी पदों को संग्रहीत करने में सक्षम बनाता है, जिसका उपयोग हम यह जांचने के लिए करेंगे कि हमने पहले की स्थिति का दौरा नहीं किया है।
तो चलिए इसे प्राप्त करते हैं। यहां नाम समूह, इंडेंटेशन, पड़ोसियों के कम यादृच्छिक क्रम और कुछ टिप्पणियों के साथ रेगेक्स का थोड़ा सा वर्जन है:
\A
# Store initial cursor position in <pos>
(?<pos>\D*)
(?(_)
# If we start on a wildcard, just skip to the first character of the target.
\D*¶.
|
# Otherwise, make sure that the target starts with this character.
(?<first>.)\D*¶\k<first>
)
(?:
# Match 0 or more subsequent characters by moving the cursor along the path.
# First, we store the character to be matched in <next>.
(?<next>.)
# Now we optionally push an underscore on top (if one exists in the string).
# Depending on whether this done or not (both of which are attempted by
# the engine's backtracking), either the exact character, or an underscore
# will respond to the match. So when we now use the backreference \k<next>
# further down, it will automatically handle wildcards correctly.
(?<=(?<next>_)\D+)?
# This alternation now simply covers all 6 possible neighbours as well as
# all 6 possible wrapped edges.
# Each option needs to go into a separate lookbehind, because otherwise
# the engine would not backtrack through all possible neighbours once it
# has found a valid one (lookarounds are atomic).
# In any case, if the new character is found in the given direction, <pos>
# will have been updated with the new cursor position.
(?:
# Try moving east.
(?<=(?<pos>\k<pos>.)\k<next>\D*)
|
# Try moving west.
(?<=(?<pos>\D*)\k<next>(?<=\k<pos>)\D*)
|
# Store the horizontal position of the cursor in <x> and remember where
# it is (because we'll need this for the next two options).
(?<=\k<pos>(?<skip>.(?<x>.)*¶\D*))
(?:
# Try moving north.
(?<=(?<pos>\D*)\k<next>(?>(?<-x>.)*)¶.*\k<skip>)
|
# Try moving north-east.
(?<=(?<pos>\D*)(?=\k<next>)(?>(?<-x>.)+)¶.*\k<skip>)
)
|
# Try moving south.
(?<=(?<pos>\k<pos>.(?>(?<-x>.)*)¶.*)\k<next>(?<x>.)*¶\D*)
|
# Try moving south-east.
(?<=(?<pos>\k<pos>(?>(?<-x>.)*)¶.*)\k<next>(?<x>.)*¶\D*)
|
# Store the number of '×' at the end in <w>, which is one less than the
# the side-length of the hexagon. This happens to be the number of lines
# we need to skip when wrapping around certain edges.
(?<=(?<w>×)*¶.*)
(?:
# Try wrapping around the east edge.
(?<=(?<pos>\k<pos>.(?>(?<-w>¶.*)*))^\k<next>\D*)
|
# Try wrapping around the west edge.
(?<=(?<pos>\D*)\k<next>(?>(?<-w>¶.*)*)(?<=\k<pos>)^\D*)
|
# Try wrapping around the south-east edge.
(?<=(?<pos>\k<pos>\b.*(?(w)!)(?<-w>¶.*)*)\k<next>×*¶\D*)
|
# Try wrapping around the north-west edge.
(?<=(?<pos>\D*\b)\k<next>.*(?(w)!)(?<-w>¶.*)*(?<=\k<pos>.)\b\D*)
)
|
# Try wrapping around the south edge.
(?<=(?<pos>\k<pos>.(?>(?<-x>.)*¶\D*))\k<next>(?<x>\w)*\W+.+)
|
# Try wrapping around the north edge.
(?<=(?<pos>.*)\k<next>(?>(?<-x>.)*¶\D*)(?<=\k<pos>.)(?<x>\w)*\W+.+)
)
# Copy the current cursor position into <current>.
(?<=\k<pos>(?<current>\D*).+)
# Make sure that no matter how many strings we pop from our stack of previous
# cursor positions, none are equal to the current one (to ensure that we use
# each cell at most once).
(?<!\k<pos>\k<current>.*(?<-pos>.)+)
)*
# Finally make sure that we've reached the end of the string, so that we've
# successfully matched all characters in the target string.
\Z
मुझे उम्मीद है कि सामान्य विचार इससे लगभग स्पष्ट है। पथ के साथ उन आंदोलनों में से एक कैसे काम करता है, इसके उदाहरण के रूप में, आइए उस बिट को देखें जो कर्सर को दक्षिण की ओर ले जाता है:
(?<=(?<pos>\k<pos>.(?>(?<-x>.)*)¶.*)\k<next>(?<x>.)*¶\D*)
याद रखें कि lookbehinds को दाएं से बाएं (या नीचे से ऊपर तक) पढ़ा जाना चाहिए, क्योंकि यही वह क्रम है जिसमें वे निष्पादित होते हैं:
(?<=
(?<pos>
\k<pos> # Check that this is the old cursor position.
. # Match the character directly on top of the new one.
(?>(?<-x>.)*) # Match the same amount of characters as before.
¶.* # Skip to the next line (the line, the old cursor is on).
) # We will store everything left of here as the new
# cursor position.
\k<next> # ...up to a match of our current target character.
(?<x>.)* # Count how many characters there are...
¶\D* # Skip to the end of some line (this will be the line below
# the current cursor, which the regex engine's backtracking
# will determine for us).
)
ध्यान दें कि यह सुनिश्चित करने के लिए एंकर को सामने रखना आवश्यक नहीं है \k<pos>कि यह वास्तव में स्ट्रिंग की शुरुआत तक पहुंचता है। <pos>हमेशा ×उस राशि से शुरू होता है जो कहीं और नहीं मिल सकती है, इसलिए यह पहले से ही एक अंतर्निहित लंगर के रूप में कार्य करता है।
मैं इस पोस्ट को आवश्यकता से अधिक ब्लोट नहीं करना चाहता, इसलिए मैं अन्य 11 मामलों में विस्तार से नहीं जाऊंगा, लेकिन सिद्धांत रूप में वे सभी इसी तरह काम करते हैं। हम जाँचते हैं कि <next>संतुलन समूहों की मदद से पुराने कर्सर की स्थिति से कुछ विशिष्ट (स्वीकार्य) दिशा में पाया जा सकता है, और फिर हम उस मिलान तक स्ट्रिंग को नए कर्सर स्थिति के रूप में संग्रहीत करते हैं <pos>।