रेगेक्स जो केवल खुद से मेल खाता है

338

रीजेक्स ( स्व-मिलान रेगेक्स , रेगेक्स वैलेजिंग रेगेक्स ) से संबंधित कुछ बहुत अच्छी चुनौतियां हैं

यह अच्छी तरह से असंभव हो सकता है, लेकिन क्या कोई रेगेक्स है जो केवल खुद से मेल खाएगा?

नोट, सीमांकक शामिल किया जाना चाहिए:

उदाहरण के लिए /thing/मेल खाना चाहिए /thing/और नहीं thing। आपकी अभिव्यक्ति के लिए एकमात्र मैच ही अभिव्यक्ति होना चाहिए। कई भाषाएं नियमित अभिव्यक्ति के स्थान पर एक स्ट्रिंग के कार्यान्वयन की अनुमति देती हैं। उदाहरण के लिए गो में

package main

import "fmt"
import "regexp"

func main() {

    var foo = regexp.MustCompile("bar")
    fmt.Println(foo.MatchString("foobar"))
}

लेकिन चुनौती के लिए, अभिव्यक्ति को सीमांकित किया जाना चाहिए (प्रतीक, अभिव्यक्ति शुरू करना, प्रतीक समाप्त करना पूर्व: /fancypantpattern/या @[^2048]@), यदि आप उद्धरण को अपने परिसीमनक के रूप में बहस करना चाहते हैं, तो ऐसा ही हो। मुझे लगता है कि इस समस्या की स्पष्ट कठिनाई को देखते हुए इससे बहुत फर्क नहीं पड़ेगा।

आपकी सहायता के लिए:

Quick hack मैंने rubular.com के लिए एक साथ रखा (माणिक रेगेक्स एडिटिंग के लिए एक वेबपेज):

var test = document.getElementById("test")
,regex = document.getElementById("regex")
,delimiter="/"
,options = document.getElementById("options")
,delay = function(){test.value = delimiter + regex.value + delimiter + options.value}
,update = function(e){
    // without delay value = not updated value
    window.setTimeout(delay,0);
}
regex.onkeydown = update;
options.onkeydown = update;

भले ही यह तकनीकी रूप से 'कोड गोल्फ' हो लेकिन मैं बहुत प्रभावित होऊंगा अगर कोई भी इसका उत्तर पा सकता है / साबित कर सकता है कि यह असंभव है।

लिंक अब तय हो गया है। सभी को क्षमा करें

इस प्रकार उत्तर जीतना अब तक: 40 पात्रों के साथ jimmy23013

— डायलन मेडिसेट्टी
स्रोत

जाहिर है कि किसी भी नियमित अभिव्यक्ति में केवल शाब्दिक शामिल हैं: //, / a /, / xyz /, आदि। यह आवश्यक है कि रेगेक्स को एक गैर-शाब्दिक संचालन शामिल करना आवश्यक हो।

— ब्रेडबॉक्स

शाब्दिक काम नहीं करेगा क्योंकि आपको बैकस्लैश का मिलान करना आवश्यक है उदाहरण के लिए / aaa

— आआ

@DylanMadisetti क्या हमें //सीमांकक का उपयोग करना है, या क्या हम अन्य सीमांकक का चयन कर सकते हैं (PCRE बहुत अधिक वर्ण का समर्थन करता है, और विशेष रूप से आप मिलान किए गए कोष्ठक / ब्रेसिज़ / कोष्ठक को परिसीमाक के रूप में उपयोग कर सकते हैं)।

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

मुझे लगता है कि यह काफी अच्छी गणितीय / कम्प्यूटेशनल समस्या है और इसका प्रमाण आसान नहीं हो सकता है ... कई महत्वपूर्ण प्रमेयों को शुरू करने के लिए एक सरल प्रश्न के रूप में शुरू किया गया है, इसलिए शायद 5 वर्षों में विकिपीडिया लेख "मैडीसेटी समस्या" होगा;)

— पावेल टोकरज

हाँ बिल्कुल। कुछ भाषाओं में (थिंक में grep लगता है) सीमांकक अनिवार्य रूप से एक खाली स्ट्रिंग है। इसलिए यह मानते हुए कि regexp के लिए पहले से ही सीमांकक गलत है। दरअसल, चूंकि grep regexp के सबसे पुराने कार्यान्वयन में से एक है, इसलिए regexp की कैनोनिकल परिभाषा में डेलिगेटर नहीं है। इस धारणा की सबसे गलत अभिव्यक्ति PHP है जिसमें दो सीमांकक की आवश्यकता होती है: "/और/"

— स्लीबेटमैन

588

पीसीआरई फ्लेवर, 261 289 210 184 127 109 71 53 51 44 40 बाइट्स

हाँ यह संभव है!

<^<()(?R){2}>\z|\1\Q^<()(?R){2}>\z|\1\Q>

इसे यहाँ आज़माएँ। (लेकिन /Regex101 पर परिसीमन दिखाया गया है।)

^{कृपया Regex101 पृष्ठ पर अनावश्यक संपादन (अपडेट) करने से बचें। यदि आपका संपादन वास्तव में इस रेगेक्स में सुधार, प्रयास या परीक्षण शामिल नहीं करता है, तो आप इसे कांटा कर सकते हैं या अपने मुखपृष्ठ से नए बना सकते हैं ।}

संस्करण Regex101 (44 बाइट्स) पर अधिक सही ढंग से काम करता है:

/^\/()(?R){2}\/\z|\1\Q^\/()(?R){2}\/\z|\1\Q/

इसे यहाँ आज़माएँ।

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

स्पष्टीकरण:

\Q^\/()(?R){2}\/\z|\1\Qस्ट्रिंग से मेल खाता है ^\/()(?R){2}\/\z|\1\Q। यह एक क्विक का उपयोग \Q...\Eकरता है जिसे बंद नहीं करना पड़ता है, और अनसैप्ड डेलिमिटर काम करते हैं \Q। इसने पिछले कुछ संस्करणों को केवल Regex101 पर काम किया और स्थानीय रूप से नहीं। लेकिन सौभाग्य से नवीनतम संस्करण ने काम किया, और मैंने इसका उपयोग करके कुछ और बाइट्स को बंद कर दिया।
\1\Qकैप्चर किए गए समूह के मैचों से पहले 1. क्योंकि समूह 1 इस विकल्प में मौजूद नहीं है, यह केवल पुनरावर्ती कॉल में मेल कर सकता है। पुनरावर्ती कॉल में यह खाली तारों से मेल खाता है।
(?R){2}पूरे रेगेक्स को दो बार पुनरावर्ती कहता है, जो ^\/()(?R){2}\/\z|\1\Qहर बार मेल खाता है ।
() समूह 1 में एक खाली स्ट्रिंग पर कब्जा करने के अलावा कुछ नहीं करता है, जो पुनरावर्ती कॉल में अन्य विकल्प को सक्षम करता है।
^\/()(?R){2}\/\z(?R){2}शुरू से अंत तक, सीमांकित के साथ मेल खाता है । \/इससे पहले कि पुनरावर्ती कॉल भी यकीन है कि इस विकल्प को ही पुनरावर्ती कॉल में से मेल नहीं खाता है, क्योंकि यह स्ट्रिंग की शुरुआत में नहीं होगा बनाया है।

बंद के साथ 51 बाइट्स \Q...\E:

/\QE\1|^\/(\\)Q(?R){2}z\/\E\1|^\/(\\)Q(?R){2}z\/\z/

इसे यहाँ आज़माएँ।

मूल संस्करण, 188 बाइट्स

लगभग 100 बाइट को बंद करने के लिए मार्टिन ब्यूटनर को धन्यवाद!

/^(?=.{173}\Q\2\)){2}.{11}$\E\/\z)((?=(.2.|))\2\/\2\^\2\(\2\?=\2\.\2\{173}\2\\Q\2\\2\2\\\2\)\2\)\2\{2}\2\.\2\{11}\2\$\2\\E\2\\\2\/\2\\z\2\)\2\(\2\(\2\?=\2\(\2\.2\2\.\2\|\2\)\2\)){2}.{11}$/

इसे यहाँ आज़माएँ।

या बिना 210 बाइट्स \Q...\E:

/^(?=.{194}\\2\\.\)\{2}\.\{12}\$\/D$)((?=(.2.|))\2\/\2\^\2\(\2\?=\2\.\2\{194}\2\\\2\\2\2\\\2\\\2\.\2\\\2\)\2\\\2\{2}\2\\\2\.\2\\\2\{12}\2\\\2\$\2\\\2\/D\2\$\2\)\2\(\2\(\2\?=\2\(\2\.2\2\.\2\|\2\)\2\)){2}.{12}$/D

इसे यहाँ आज़माएँ।

विस्तारित संस्करण:

/^(?=.{173}\Q\2\)){2}.{11}$\E\/\z)        # Match things near the end.
((?=(.2.|))                               # Capture an empty string or \2\ into group 2.
   \2\/\2\^\2\(\2\?=\2\.\2\{173}\2\\Q\2\\2\2\\\2\)\2\)\2\{2}\2\.
   \2\{11}\2\$\2\\E\2\\\2\/\2\\z\2\)      # 1st line escaped.
   \2\(\2\(\2\?=\2\(\2\.2\2\.\2\|\2\)\2\) # 2nd line escaped.
){2}
.{11}$/x

एक्सटेंशन्स जैसे (?=और \1तथाकथित "रेगुलर" एक्सप्रेशन को अब रेगुलर नहीं बनाते हैं, जिससे क्वीन भी संभव हो जाता है। बैकरेज नियमित नहीं है, लेकिन लुकहेड है।

स्पष्टीकरण:

मैं विशेष पात्रों से बचने \2\के \लिए जगह में उपयोग करता हूं । यदि \2रिक्त स्ट्रिंग से मेल खाता है, \2\x(जहां xएक विशेष चरित्र है) xस्वयं से मेल खाता है। अगर \2मैच होते हैं \2\, तो \2\xमैच बच जाता है। \2ग्रुप 1 के दो मैचों में रेगेक्स में अलग हो सकता है। पहली बार \2में खाली स्ट्रिंग, और दूसरी बार मेल खाना चाहिए \2\।
\Q\2\)){2}.{11}$\E\/\z(लाइन 1) अंत से 15 वर्णों से मेल खाता है। और .{11}$(पंक्ति 7) अंत से 11 पात्रों (या एक अनुगामी न्यूलाइन से पहले) से मेल खाती है। तो दूसरे पैटर्न से ठीक पहले वाला पैटर्न पहले पैटर्न में पहले 4 या 3 अक्षरों से \2\.\2\|\2\)\2\)मेल खाना चाहिए , इसलिए मैच होना चाहिए ...\2\)या ...\2\। कोई अनुवर्ती नई रेखा नहीं हो सकती क्योंकि अंतिम वर्ण होना चाहिए )। और मिलान किए गए पाठ )में सबसे सही एक से पहले दूसरा नहीं है , इसलिए अन्य सभी वर्णों में होना चाहिए \2। \2के रूप में परिभाषित किया गया है (.2.|), इसलिए यह केवल हो सकता है \2\।
पहली पंक्ति पूरी अभिव्यक्ति को 188 वर्णों से मेल खाती है क्योंकि हर चीज की एक निश्चित लंबाई होती है। समूह 1 के दो समय 45 * 2 अक्षर और 29 बार मेल खाते हैं \2। और समूह 1 के बाद की चीजें 11 वर्णों से मेल खाती हैं। तो दो बार की कुल लंबाई \2बिल्कुल 3 अक्षर होनी चाहिए। \2दूसरी बार जानना 3 वर्ण लंबा है, यह पहली बार खाली होना चाहिए।
लुकहेड को छोड़कर सब कुछ \2समूह 1 में शाब्दिक है। दो बार \2ज्ञात होने के साथ, और पहली पंक्ति से ज्ञात अंतिम कुछ अक्षर, यह रेग्ज बिल्कुल एक तार से मेल खाता है।
मार्टिन ब्युटनर समूह 2 पर कब्जा करने और इसे क्वीन भाग के साथ ओवरलैप बनाने के लिए लुकहेड का उपयोग करने के विचार के साथ आता है। इससे समूह 1 के दो बार के बीच सामान्य तरीके से बच गए वर्णों को हटा दिया गया, और उन्हें मेरे मूल संस्करण में मिलान करने के पैटर्न से बचने में मदद की, और रेगेक्स को बहुत सरल किया।

पुनरावृत्ति या पीछे हटने के बिना रेगेक्स, 85 बाइट्स

कोई यह तर्क दे सकता है कि पुनरावृत्ति या पश्चप्रदर्शन वाले भाव वास्तविक "नियमित" भाव नहीं हैं। लेकिन केवल लुकहैड के साथ अभिव्यक्तियाँ अभी भी केवल नियमित भाषाओं से मेल खा सकती हैं, हालांकि पारंपरिक नियमित अभिव्यक्तियों द्वारा व्यक्त किए जाने पर वे बहुत लंबे समय तक हो सकते हैं।

/(?=.*(\QE\\){2}z\/\z)^\/\(\?\=\.\*\(\\Q.{76}\E\\){2}z\/\z)^\/\(\?\=\.\*\(\\Q.{76}\z/

इसे यहाँ आज़माएँ।

610 बाइट्स बिना \Q...\E(गोल्फ होने के लिए):

/^(?=.{610}$)(?=.{71}(\(\.\{8\}\)\?\\.[^(]*){57}\)\{2\}\.\{12\}\$\/D$)((.{8})?\/(.{8})?\^(.{8})?\((.{8})?\?=(.{8})?\.(.{8})?\{610(.{8})?\}(.{8})?\$(.{8})?\)(.{8})?\((.{8})?\?=(.{8})?\.(.{8})?\{71(.{8})?\}(.{8})?\((.{8})?\\(.{8})?\((.{8})?\\(.{8})?\.(.{8})?\\(.{8})?\{8(.{8})?\\(.{8})?\}(.{8})?\\(.{8})?\)(.{8})?\\(.{8})?\?(.{8})?\\(.{8})?\\(.{8})?\.(.{8})?\[(.{8})?\^(.{8})?\((.{8})?\](.{8})?\*(.{8})?\)(.{8})?\{57(.{8})?\}(.{8})?\\(.{8})?\)(.{8})?\\(.{8})?\{2(.{8})?\\(.{8})?\}(.{8})?\\(.{8})?\.(.{8})?\\(.{8})?\{12(.{8})?\\(.{8})?\}(.{8})?\\(.{8})?\$(.{8})?\\(.{8})?\/D(.{8})?\$(.{8})?\)(.{8})?\(){2}.{12}$/D

इसे यहाँ आज़माएँ।

विचार समान है।

/^(?=.{610}$)(?=.{71}(\(\.\{8\}\)\?\\.[^(]*){57}\)\{2\}\.\{12\}\$\/D$)
((.{8})?\/(.{8})?\^(.{8})?\((.{8})?\?=(.{8})?\.(.{8})?\{610(.{8})?\}(.{8})?\$(.{8})?\)
(.{8})?\((.{8})?\?=(.{8})?\.(.{8})?\{71(.{8})?\}
  (.{8})?\((.{8})?\\(.{8})?\((.{8})?\\(.{8})?\.(.{8})?\\(.{8})?\{8(.{8})?\\(.{8})?\}
    (.{8})?\\(.{8})?\)(.{8})?\\(.{8})?\?(.{8})?\\(.{8})?\\
    (.{8})?\.(.{8})?\[(.{8})?\^(.{8})?\((.{8})?\](.{8})?\*(.{8})?\)(.{8})?\{57(.{8})?\}
  (.{8})?\\(.{8})?\)(.{8})?\\(.{8})?\{2(.{8})?\\(.{8})?\}
  (.{8})?\\(.{8})?\.(.{8})?\\(.{8})?\{12(.{8})?\\(.{8})?\}
  (.{8})?\\(.{8})?\$(.{8})?\\(.{8})?\/D(.{8})?\$(.{8})?\)(.{8})?\(){2}.{12}$/D

मूल नियमित अभिव्यक्ति

अगर लुकहेड की अनुमति नहीं है, तो अब मैं सबसे अच्छा कर सकता हूं:

/\\(\\\(\\\\){2}/

जो मेल खाता है

\\(\\\(\\

यदि {m,n}क्वांटिफायर की अनुमति नहीं है, तो यह असंभव है क्योंकि कुछ भी नहीं जो केवल एक स्ट्रिंग से मेल खा सकता है, एक स्ट्रिंग से अधिक लंबे समय तक मिलान कर सकता है। बेशक कोई अभी भी कुछ ऐसा आविष्कार कर सकता है \qजो केवल मेल खाता है /\q/, और अभी भी उस नियमित के साथ भाव कहता है। लेकिन स्पष्ट रूप से ऐसा कुछ भी प्रमुख कार्यान्वयन द्वारा समर्थित नहीं है।

— jimmy23013
स्रोत

प्रभावशाली। मैं कुछ समय के लिए इसे पाने की कोशिश कर रहा था, कोई सफलता नहीं मिली।

— प्रिमो

कैसे (नरक) एक मानव इस तरह का उत्पादन कर सकता है?

— xem

यह इस साइट पर सबसे अधिक मतदान का जवाब देने के योग्य है।

— क्रंचर

यह सबसे बेतुका, अविश्वसनीय चीज़ है जिसे मैंने कभी देखा है।

— एलेक्स ए।

किसी ने इस पोस्ट को ट्वीट किया तो मुझे एक दिन में 49

— अपवोट मिले