स्ट्रिंग्स में पैटर्न खोजें

Question

इस इनवॉइस में, आपका काम किसी दिए गए स्ट्रक्चर के साथ सबस्ट्रिंग का पता लगाना है।

इनपुट

आपका इनपुट दो गैर-रिक्त अक्षरांकीय तार, एक पैटर्न p और एक पाठ होगा t । विचार यह है कि प्रत्येक वर्ण pएक सन्निहित गैर-रिक्त विकल्प का प्रतिनिधित्व करता है, tजो एक दूसरे के बगल में होते हैं, और pउनके संघनन का प्रतिनिधित्व करते हैं। समान वर्णों के समान पहचान वाले पात्र; उदाहरण के लिए, पैटर्न aaकिसी भी गैर-खाली वर्ग का प्रतिनिधित्व करता है (एक स्ट्रिंग जो अपने आप को एक छोटा स्ट्रिंग समाप्‍त करके प्राप्त होता है)। इस प्रकार पैटर्न प्रत्येक मिलान के साथ, aaसबस्ट्रिंग से मेल खा सकता है ।byebyeabye

उत्पादन

यदि पाठ tमें एक विकल्प है जो pमेल खाता है, तो आपका आउटपुट वह सबस्ट्रिंग होगा, जिसमें :वर्णों के अनुरूप तार के बीच कॉलोन डाले गए हैंp । उदाहरण के लिए, यदि हमारे पास t = byebyenowऔर p = aa, फिर bye:byeएक स्वीकार्य उत्पादन होता है। मिलान विकल्प के लिए कई विकल्प हो सकते हैं, लेकिन आप उनमें से केवल एक का ही उत्पादन करेंगे।

अगर t एक मेल खाने वाला विकल्प नहीं है, तो आपका आउटपुट एक उदास चेहरा होगा :(।

नियम और स्पष्टीकरण

अलग-अलग वर्णों के pसमान समरूप पदार्थों के अनुरूप हो p = abaसकते हैं , इसलिए स्ट्रिंग से मेल खा सकते हैं AAA। ध्यान दें कि पात्रों को गैर-खाली तारों के अनुरूप होना चाहिए; विशेष रूप से, अगर इससे pअधिक है t, तो आउटपुट अवश्य होना चाहिए :(।

आप एक पूर्ण कार्यक्रम या एक फ़ंक्शन लिख सकते हैं, और आप दो इनपुट के क्रम को भी बदल सकते हैं। सबसे कम बाइट गिनती जीतता है, और मानक खामियों को रोक दिया जाता है।

परीक्षण के मामलों

प्रारूप में दिया गया pattern text -> output। ध्यान दें कि अन्य स्वीकार्य आउटपुट मौजूद हो सकते हैं।

a Not -> N
aa Not -> :(
abcd Not -> :(
aaa rerere -> re:re:re
xx ABAAAB -> A:A
MMM ABABBAABBAABBA -> ABBA:ABBA:ABBA
x33x 10100110011001 -> 10:1001:1001:10
abcacb 0a00cca0aa0cc0ca0aa0c00c0aaa0c -> c:a0aa:0c:c:0c:a0aa
abccab 0a00cca0aa0cc0ca0aa0c00c0aaa0c -> a:a:0c0:0c0:a:a
abcbcab 0a00cca0aa0cc0ca0aa0c00c0aaa0c -> :(
abcbdcab 0a00cca0aa0cc0ca0aa0c00c0aaa0c -> 00:c:ca0aa0c:c:0:ca0aa0c:00:c

Comments

सभी सब्सट्रेट का अधिकार? क्यों नहीं!

— orlp

@orlp यह केवल है O(2^((n * (n + 1))/2)): पी

— थ्री एफएक्स

पैटर्न स्ट्रिंग में एक अंक क्या दर्शाता है?

— feersum

@ फर्सम यह एक चरित्र है, इसलिए यह अनिवार्य रूप से किसी भी अन्य चरित्र के समान है।

— थ्री एफएक्स

@ThreeFx मैं अनिश्चित हूं क्योंकि पहला पैराग्राफ पैटर्न में केवल "अक्षरों" को संदर्भित करता है।

— feersum

Answer 1

पायथन, 207 बाइट्स

import re
h=lambda x:"a"+str(ord(x))
def g(a,b):
 c,d="",set()
 for e in a:
  c+=["(?P<"+h(e)+">.+)","(?P="+h(e)+")"][e in d]
  d.add(e)
 f=re.search(c,b)
 return f and":".join(f.group(h(e))for e in a)or":("

के साथ बुलाना g(pattern, string)

reअधिकांश काम करने के लिए मॉड्यूल का उपयोग करता है ।

Answer 2

जावास्क्रिप्ट (स्पाइडरमोंकी) (ES5.1), 198 बाइट्स

चूंकि ईएस 6 जून 2015 में जारी किया गया था, इसलिए मैं ईएस 6 के समकक्ष ईएस 5.1 संस्करण को एक साथ पोस्ट करता हूं, लेकिन ईएस 5.1 संस्करण को मुख्य उत्तर घोषित करता हूं।

लालची मैच, इसलिए पहला मामला "एन" के बजाय "नहीं" देता है।

function(a,b){c=[o="indexOf"];r=a.split("");return(m=RegExp(r.map(function(i){return(e=c[o](i))>0?"\\"+e:(c.push(i),"(.+)")}).join("")).exec(b))?r.map(function(x){return m[c[o](x)]}).join(":"):":("}

इसे ऑनलाइन आज़माएं!

जावास्क्रिप्ट (Node.js) (ES6), 141 बाइट्स

a=>b=>(c=[o="indexOf"],r=[...a],m=RegExp(r.map(i=>(e=c[o](i))>0?"\\"+e:(c.push(i),"(.+)")).join``).exec(b))?r.map(x=>m[c[o](x)]).join`:`:":("

इसे ऑनलाइन आज़माएं!

सिंटेक्स को करीने में तर्क देता है: f(a)(b)

स्पष्टीकरण (और अपुष्ट):

function matchPattern(a, b) {                   // Main function
 var c = ["indexOf"];                           // Array used for the capturing groups
 var r = [...a];                                // Split the pattern first
 var m = RegExp(r.map(function(i) {             // Create the regex
  var e = c.indexOf(i);                         // Check if the character is found before
  if (e > 0)                                    // If so
   return "\\" + e;                             // Append the back reference to the regex
  else {                                        // If not
   c.push(i);                                   // Append the character to the array
   return "(.+)";                               // Append a capturing group to the regex
  }             
 }).join("")).exec(b);                          // Execute the regex
 if (m != null)                                 // If the pattern matches the string
  return r.map(function(x) {                    // Replace each letter
   return m[c.indexOf(x)];                      // With the corresponding substring
  }).join(":");                                 // And join them with ":"
 else                                           // If there is no match
  return ":(";                                  // Return ":("
}

Answer 3

ब्रेकीलॉग , 35 बाइट्स

sᵗ~cᵗXlᵛ∧Xzdz≠ʰ∧Xt~ṇ{Ḷ∧":"|}ᵐ.∨":("

इसे ऑनलाइन आज़माएं!

छोटे-छोटे इनपुट पर, बहुत धीमी गति से। मैं-वास्तव में छठे-परीक्षण-के-केस-के-नहीं-बल्कि-कमी के लिए-धीमी गति से कोशिश कर रहा हूं। (संभवत: प्रत्येक प्रतिस्थापन के प्रत्येक विभाजन को ब्रूट-फोर्सिंग के कारण, सबसे बड़े से शुरू करना, और फिर जांचना कि क्या यह मेल है।) इनपुट को एक सूची के रूप में लेता है।[pattern,string] ।

संघनित और विभाजित विवरण:

sᵗ~cᵗX

एक्स इनपुट स्ट्रिंग के एक विकल्प के विभाजन के साथ जोड़ा गया पैटर्न है।

lᵛ

पैटर्न और विभाजन में तत्वों की संख्या समान है।

Xzdz≠ʰ

कोई भी दो अद्वितीय pattern char, matched substringजोड़े एक पैटर्न चरित्र साझा नहीं करते हैं । यह है कि कोई भी पैटर्न चरित्र कई सबस्ट्रिंग में मैप नहीं करता है, हालांकि कई पैटर्न कैरेक्टर एक सबस्ट्रिंग में मैप कर सकते हैं।

Xt~ṇ{Ḷ∧":"|}ᵐ.∨":("

आउटपुट कॉलन से जुड़े विभाजन के तत्व हैं, जब तक कि कुछ नहीं किया जा सकता है, जिस स्थिति में यह है :( इसके बजाय है।

अखंड विवरण:

                                       The input
 ᵗ  ᵗ                                  with its last element replaced with
  ~c                                   a list which concatenates to
s                                      a substring of it
     X                                 is X,
       ᵛ                               the elements of which all have the same
      l                                length.
        ∧                              And,
         X                             X
          z                            zipped
           d                           with duplicate pairs removed
            z                          and zipped back
              ʰ                        has a first element
             ≠                         with no duplicate values.
               ∧                       Furthermore,
                 t                     the last element of
                X                      X
                  ~ṇ                   with its elements joined by newlines
                    {      }ᵐ          where each character of the joined string
                     Ḷ                 is a newline
                      ∧                and
                          |            is replaced with
                       ":"             a colon
                          |            or is passed through unchanged
                             .         is the output.
                              ∨        If doing any part of that is impossible,
                                       the output is
                               ":("    ":(".

Comments

यह एक घंटे से अधिक हो गया है और इसने अभी भी छठा परीक्षण मामला नहीं किया है ... शायद यह वास्तव में काम नहीं करता है? यह प्रोसेसर के अपने हिस्से से अधिक का उपयोग कर रहा है ...

— असंबंधित स्ट्रिंग

ठीक है, या तो मैंने हार्ड ब्रूट बल की कई परतों का उपयोग करने के समय की जटिलता को कम करके आंका, या यह किसी तरह से टूट गया है, क्योंकि इसने अभी भी छठा परीक्षण मामला नहीं किया है

— असंबंधित स्ट्रिंग

मैंने इसे अभी बंद कर दिया है क्योंकि अगर इसमें तीन घंटे लगते हैं तो मुझे यकीन नहीं है कि मैं इंतजार करने के लिए कितना लंबा हूं

— असंबंधित स्ट्रिंग