रेगेक्स को उलट दें

Question

चुनौती

एक वैध रेगेक्स को देखते हुए, एक रेगेक्स का उत्पादन करता है जो स्ट्रिंग्स के समान सेट से मेल खाता है, लेकिन उलटा हुआ।

काम

यह चुनौती सबसे बुनियादी regex संचालन का उपयोग करता है: ^, $, ?, +, *, [], {}, |। कब्जा समूहों या उस जटिल सामान में से कोई भी ऐसी कोई चीज नहीं है। विशेष पात्र बच सकते हैं।

नमूना इनपुट / आउटपुट

नोट: अमान्य इनपुट कभी नहीं दिया जाएगा, और आम तौर पर दिए गए इनपुट के लिए कई संभावित उत्तर हैं!

Input      | Sample Output
-----------|-------------
abc        | cba
tuv?       | v?ut
a(b|c)     | (c|b)a
1[23]      | [23]1
a([bc]|cd) | (dc|[bc])a
^a[^bc]d$  | ^d[^bc]a$
x[yz]{1,2} | [yz]{1,2}x
p{2}       | p{2}
q{7,}      | q{7,}
\[c[de]    | [de]c\[
ab[c       | <output undefined>
a(?bc)     | <output undefined>
a[]]bc     | <output undefined>

डेमो

वर्किंग डेमो जो सही इनपुट / आउटपुट प्रदर्शित करता है। यह उन इनपुट्स को मान्य करने के लिए कुछ अतिरिक्त तर्क है जो वास्तविक उत्तर में आवश्यक नहीं हैं। अपरिभाषित व्यवहार करने के लिए अमान्य इनपुट पर विचार करें।

विशिष्ट तथ्य

सादगी के लिए, सभी विशेष वर्ण या तो अपना विशेष अर्थ रखते हैं या बच जाते हैं; यह है, के [[]लिए एक चरित्र सीमा नहीं है [। लंबाई पर्वतमाला मानक POSIX EREs से आती हैं; यह है कि, {n}, {n,}, और {n,m}समर्थित हैं। चरित्र पर्वतमाला []और [^]समर्थित हैं। इन नियमों के कारण, और चूंकि कोई अमान्य इनपुट नहीं दिया गया है, इसलिए आपको वास्तव में केवल इन सामग्रियों को सीधे आउटपुट में कॉपी करना होगा। अंत में, लालच कोई मायने नहीं रखता है, यानी इससे कोई फर्क नहीं पड़ता कि उलटा रेगेक्स पहले एक अलग मैच पाता है , बस इसे स्ट्रिंग्स के एक ही सेट के लिए एक मैच खोजने की आवश्यकता है।

स्कोरिंग

बाइट्स में सबसे छोटा कार्यक्रम (नेटवर्क अनुरोधों के रूप में धोखा देने पर रोक) जीतता है। प्रोग्राम या तो वास्तविक IO का उपयोग कर सकता है या बस एक फ़ंक्शन को परिभाषित कर सकता है।

Comments

क्योंकि इसमें ?संलग्न करने के लिए कुछ भी नहीं है। /a(?bc)/ब्राउज़र के कंसोल में टाइप करने की कोशिश करें ।

— TND

अब अच्छा लग रहा है। आप (^a|b)(c$|d)एक परीक्षण मामले के रूप में हालांकि कुछ जोड़ना चाहते हो सकता है ।

— मार्टिन एंडर

क्या हम मान सकते हैं कि इनपुट में केवल मुद्रण योग्य ASCII वर्ण होंगे? विशेष रूप से, कोई लाइनफ़ीड वर्ण?

— मार्टिन एंडर

क्या हमें समूहों यानी (a)?(b)+applied पर लागू होने वाले क्वालीफायर पर विचार करना चाहिए (b)+(a)??

— 20

रेगेक्स ऑपरेशन की आपकी सूची गायब है (), जिसका उपयोग आपके उदाहरण में किया गया है।

— n --h'a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳

Answer 1

रेटिना , 136 114 110 बाइट्स

यो डॉग, मैंने सुना है आपको रेगेक्स की तरह ...

^
;
(T`^$`$^`;.
(.*);(\[(\\.|[^]])*]|\\.|.)([*+?]|{\d+(,|,\d+)?})?
$2$4!$1;
^\(!
) 
^\)(.*)!(.+?) 
($2$1
;$|!
<empty>

जहां <empty>एक खाली अनुरेखण रेखा का प्रतिनिधित्व करता है। -sध्वज के साथ एक फ़ाइल से कोड चलाएँ ।

... जब आप रिवर्स रेगेक्स चाहते हैं तो आपको रेगेक्स का उपयोग करना चाहिए। जब आप regex का उपयोग करना चाहते हैं तो आपको एक regex- आधारित प्रोग्रामिंग भाषा का उपयोग करना चाहिए।

यह कोड मानता है कि इनपुट में न तो ;और !न ही रिक्त स्थान हैं। हालांकि मैं मानता हूं कि यह एक बहुत मजबूत और संभावित रूप से अमान्य धारणा है, आप उन तीनों को कोड में किसी भी तीन अनपेक्षित वर्णों (जैसे नल बाइट्स, घंटी चरित्र, <DEL>आप इसे नाम देते हैं) से बदल सकते हैं, और यह कोड आकार या कार्यक्षमता को प्रभावित नहीं करेगा। बिलकुल।

जब मैं गोल्फ कर रहा होता हूँ तो एक स्पष्टीकरण जोड़ देता हूँ।

Comments

"मैं झुंड * आप

— झूठ

मुझे लगता है कि कोड यह भी मानता है कि रेगेक्स में कोई कच्ची नई पंक्ति वर्ण नहीं है।

— n --h'a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳ 3

@ n @h thata̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳ ओह, यह सच है, मैं इस धारणा के अधीन था कि इनपुट में कोई भी अनपेक्षित वर्ण नहीं होगा। मैं ठीक करूंगा कि एक बार हम ओपी से स्पष्टीकरण प्राप्त करेंगे। (यदि कोई भी वर्ण प्रकट हो सकता है, तो अभी भी कुछ संयोजन हैं जो यह नहीं दिखाएंगे कि यह चुनौती एक मान्य रेगेक्स को क्या मानती है, उदाहरण के लिए ]]], इस तरह, इस उत्तर में बहुत संशोधन की आवश्यकता नहीं होगी।)

— मार्टिन एंडर

एक साल से अधिक समय के बाद गोल्फ किया? : पी

— ओकेक्स

Answer 2

जावास्क्रिप्ट ईएस 6, 574 बाइट्स

मैं शायद कुछ varबयानों को हटा सकता हूं ।

R=e=>{for(var s=0,c=[],h=/(\?|\+|\{\d*,*\d*\}|\*)(\?*)/,t=0;t<e.length;t++)switch(s){case 0:switch(e[t]){case"\\":t++,c.push("\\"+e[t]);break;case"[":j=t,s=1;break;case"(":k=t,s=2;break;default:var l=e.search(h,t);(l>=t+1||0>l)&&c.push(l==t+1?e[t]+e.slice(t,e.length).match(h)[0]:e[t])}break;case 1:"\\"==e[t]?t++:"]"==e[t]&&(c.push(e.slice(j,t+1)+(e.search(h,t)==t+1?e.slice(t,e.length).match(h)[0]:"")),s=0);break;case 2:"\\"==e[t]?t++:")"==e[t]&&(a=R(e.slice(k+1,t)),c.push("("+a+")"),s=0)}c.reverse(),r=c;var i=c.length-1;return"^"==c[i]&&(r[i]="$"),"$"==c[0]&&(r[0]="^"),r.join``}}

जेएस ईएस 6, अप्रयुक्त, 559 बाइट्स

घर पर परीक्षण करेंगे।

R=e=>{for(s=0,c=[],h=/(\?|\+|\{\d*,*\d*\}|\*)(\?*)/,t=0;t<e.length;t++)switch(s){case 0:switch(e[t]){case"\\":t++,c.push`\\${e[t]}`;break;case"[":j=t,s=1;break;case"(":k=t,s=2;break;default:l=e.search(h,t);(l>=t+1||0>l)&&c.push(l==t+1?e[t]+e.slice(t,e.length).match(h)[0]:e[t])}break;case 1:"\\"==e[t]?t++:"]"==e[t]&&(c.push(e.slice(j,t+1)+(e.search(h,t)==t+1?e.slice(t,e.length).match(h)[0]:"")),s=0);break;case 2:"\\"==e[t]?t++:")"==e[t]&&(a=R(e.slice(k+1,t)),c.push`(${a})`,s=0)}c.reverse(),r=c;i=c.length-1;return"^"==c[i]&&(r[i]="$"),"$"==c[0]&&(r[0]="^"),r.join``}}

जावास्क्रिप्ट ईएस 5, अनगोल्डेड, 961 बाइट्स

function revRegex(str){
 var mode = 0;
 var oS = [];
 var post = /(\?|\+|\{\d*,*\d*\}|\*)(\?*)/;
 for(var i=0;i<str.length;i++){
  switch(mode){
   case 0: switch(str[i]){
    case "\\": i++; oS.push("\\"+str[i]); break;
    case "[": j=i; mode = 1; break;
    case "(": k=i; mode = 2; break;
    default:
     var pLoc = str.search(post,i);
     if(pLoc>=i+1||pLoc<0){ // current is not pLoc
      if(pLoc==i+1){
       oS.push(str[i] + str.slice(i,str.length).match(post)[0]);
      } else {
       oS.push(str[i]);
      }
     }
   }; break;
   case 1: if(str[i]=="\\") i++; else if(str[i]=="]"){oS.push

(str.slice(j,i+1)+(str.search(post,i)==i+1?str.slice

(i,str.length).match(post)[0]:""));mode = 0}; break;
   case 2: if(str[i]=="\\") i++; else if(str[i]==")")

{a=revRegex(str.slice(k+1,i));oS.push("("+a+")");mode = 

0};break;
  }
 }
 oS.reverse();
 r=oS;
 var l=oS.length-1;
 if(oS[l]=="^") r[l]="$";
 if(oS[0]=="$") r[0]="^";
 return r.join("");
}

Comments

योग्य, आपने रेगेक्स को रिवर्स रेगेक्स: डी

— क्रिति लिथोस

@ ΣριΚικσιΛίθοΚ हां, मैंने किया था: D मैं HTML को पार्स करने के लिए इसका उपयोग करूँगा यदि मैं कर सकता था ...

— Conor O'Brien

"अगर आप कर सकते हैं"

— ऑप्टिमाइज़र

@ C @O'Bʀɪᴇɴ मैंने regex के साथ html कोडों को पार्स किया लेकिन यूनिकोड के साथ एक गंभीर समस्या मिली

— Abr001am

@ C @O'Bʀɪᴇɴ यह एक विकल्प है: `code.replace (/.*/," ट्रोलोलोल ");

— क्रिति लिथोस

Answer 3

जावास्क्रिप्ट ईएस 6, 343 बाइट्स

t=r=>(u="substr",T="(?:[+?*]|{\\d+(?:,\\d*)?})?)([^]*)",(c=r[0])=="(")?([n,s]=v(r[u](1)),[_,q,s]=s.match("^(\\)"+T),["("+n+q,s]):c==")"||c==null?["",r]:c=="^"?["^",r[u](1)]:c=="$"?["^",r[u](1)]:r.match("^("+/(?:\[(?:[^\]\\]|\\[^])*\]|[^[\\]|\\[^])/.source+T).slice(1);(v=r=>{var o="";do{[n,r]=t(r);o=n+o;}while(n&&r);return[o,r]})(prompt())[0]

मूल कोड (कार्य, लेकिन बिना prompt):

function reverse(regex) {
    var out = "";
    do {
        // console.log("calling term");
        var [node, regex] = term(regex);
        // console.log("reverse: " + [node, regex]);
        out = node + out;
    } while (node && regex);
    return [out, regex];
}

function term(regex) {
    switch (regex[0]) {
        case "(":
            // console.log("calling reverse");
            var [node, sequel] = reverse(regex.substr(1));
            // console.log("term: " + regex + " / " + [node, sequel]);
            var [_, quantifier, sequel] = sequel.match(/^(\)(?:[+?*]|{\d+(?:,\d*)?})?)([^]*)/);
            return ["(" + node + quantifier, sequel];
        case ")":
        case void 0:
            return ["", regex];
        case "^":
            return ["$", regex.substr(1)];
        case "$":
            return ["^", regex.substr(1)];
        default:
            return regex.match(/^((?:\[(?:[^\]\\]|\\[^])*\]|[^[\\]|\\[^])(?:[+?*]|{\d+(?:,\d+)?})?)([^]*)/).slice(1);
    }
}

reverse("^\\(([The(){}*\\] ]{2,3}world\\\\(begin(ner|ning)?|ends*)+|Con\\|ti\\*n\\)ue...[^%\\[\\]()\\\\])$")[0]

कोड को पुनरावर्ती टॉप-डाउन पार्सर के रूप में कार्यान्वित किया जाता है, इसलिए यह गहरी नेस्टेड इनपुट पर स्टैक ओवरफ्लो का कारण हो सकता है।

अमान्य मामलों में कोड अनंत लूप का कारण बन सकता है, क्योंकि मैं उनका परीक्षण नहीं करता, "अपरिभाषित व्यवहार" खंड का लाभ उठाता हूं।

Answer 4

पायथन 3, 144 बाइट्स

(यह एक समूह की तरह क्वालीफायर का समर्थन नहीं करता है(a)+(b)*(cde)? ।)

import re;f=lambda x:''.join({e:e,'^':'$','$':'^','(':')',')':'('}[e]for e in re.findall(r'(?:\\.|\[(?:\\?.)+?\]|.)(?:[?+*]|\{.+?\})?',x)[::-1])

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

test_cases = [
    # Provided test cases
    r'abc',
    r'tuv?',
    r'a(b|c)',
    r'1[23]',
    r'a([bc]|cd)',
    r'^a[^bc]d$',
    r'x[yz]{1,2}',
    r'p{2}',
    r'q{7,}',
    r'\[c[de]',

    # Pathological cases
    r'a{3}b',
    r'(a)?(b)+',            # <-- currently failing!
    r'[\[]{5}[^\]]{6}',
    r'[\[]\]{7}',
    r'[\[\]]{8,9}',
    r'\(\)\^\$',

    # Undefined cases
    r'ab[c',
    r'a(?bc)',
    r'a[]]bc',
]

for t in test_cases:
    print(t, '->', f(t))

परिणाम:

abc -> cba
tuv? -> v?ut
a(b|c) -> (c|b)a
1[23] -> [23]1
a([bc]|cd) -> (dc|[bc])a
^a[^bc]d$ -> ^d[^bc]a$
x[yz]{1,2} -> [yz]{1,2}x
p{2} -> p{2}
q{7,} -> q{7,}
\[c[de] -> [de]c\[
a{3}b -> ba{3}
(a)?(b)+ -> )+b))?a)                    # <-- note: wrong
[\[]{5}[^\]]{6} -> [^\]]{6}[\[]{5}
[\[]\]{7} -> \]{7}[\[]
[\[\]]{8,9} -> [\[\]]{8,9}
\(\)\^\$ -> \$\^\)\(
ab[c -> c[ba
a(?bc) -> (cb(?a
a[]]bc -> cb[]]a