क्रमपरिवर्तन मैच!

Question

आपकी चुनौती एक रेगेक्स बनाने की है जो स्वयं के हर स्ट्रिंग क्रमांकन से मेल खाता है, और कुछ नहीं। मैच भी केस-संवेदी होना चाहिए।

इसलिए, उदाहरण के लिए, यदि आपका regex है:

ABC

यह (और केवल मैच) इन तारों से मेल खाना चाहिए:

ABC
ACB
BAC
BCA
CAB
CBA

यह चीजों से मेल नहीं खाना चाहिए:

AABC (contains an extra A)
ABCD (contains an extra D)
AC   (no B)
AAA  (no B and C, extra 2 A's)
abc  (case-sensitive)

नियम:

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

Comments

संबंधित: रेगेक्स जो केवल खुद से मेल खाता है

— xnor

इसके अलावा संबंधित: चरित्र स्रोत कोड में गिना जाता है

— jimmy23013

मैंने सोचा था (ABC|ACB|BAC|BCA|CAB|CBA)लेकिन आप एक सामान्यीकृत उत्तर चाहते थे।

— स्टीफन क्वान

Answer 1

जावास्क्रिप्ट, 64 57 बाइट्स

4 बाइट्स मार्टिन एंडर के लिए धन्यवाद हटा दिया।

^(?!.*([^])(.*\1){3}]?)[$$[-^?!!.'''-*11{33}5577\\-]{57}$

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

स्पष्टीकरण (पुराना)

^                                  # Beginning of the string.
(?!.*                              # Match only the strings that don't contain...
  (.)(.*\1){4}                     #     5 occurrences of the same character.
  [^1]?[^1]?                       #     Something that doesn't matter.
)
[]zzz^(?!!!.**[)\\1{{44}}666]{64}  # 64 occurrences of these 16 characters.
                                   # Some are duplicated to make sure the regex
                                   # contains 4 occurrences of each character.
\z                                 # End of the string.

Comments

मुझे लगता है कि यह 60 के लिए काम करता है: ^(?!.*(\S)(.*\1){3}[^1]?)[]zzSS[-^?!!.'''-*1{33}0066-]{60}\z regex101

— मार्टिन

यह लगभग .NET में काम करता है:^(?'4'(?!(.*\4){3})[]$$[\\^^?!!..'-*{}33-5-]){54}$[5]*

— jimmy23013

क्या काम नहीं करता है? ट्रेलिंग लाइनफीड्स?

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

@MartinEnder हां।

— jimmy23013

Answer 2

पर्ल और पीसीआरई रेगेक्स, 280 बाइट्स

^(?=(.*z){2})(?=(.*\(){43})(?=(.*\)){43})(?=(.*\*){22})(?=(.*\.){23})(?=(.*0){2})(?=(.*1){6})(?=(.*2){16})(?=(.*3){7})(?=(.*4){4})(?=(.*5){1})(?=(.*6){3})(?=(.*7){2})(?=(.*8){2})(?=(.*9){1})(?=(.*=){22})(?=(.*\?){22})(?=(.*\\){11})(?=(.*\^){2})(?=(.*\{){23})(?=(.*\}){23}).{280}\z

(थोड़ा) अधिक पठनीय:

^
(?=(.*z){2})
(?=(.*\(){43})
(?=(.*\)){43})
(?=(.*\*){22})
(?=(.*\.){23})
(?=(.*0){2})
(?=(.*1){6})
(?=(.*2){16})
(?=(.*3){7})
(?=(.*4){4})
(?=(.*5){1})
(?=(.*6){3})
(?=(.*7){2})
(?=(.*8){2})
(?=(.*9){1})
(?=(.*=){22})
(?=(.*\?){22})
(?=(.*\\){11})
(?=(.*\^){2})
(?=(.*\{){23})
(?=(.*\}){23})
.{280}\z

लिखित रूप में यह O (2 ^ n) समय में चलता है, इसलिए अविश्वसनीय रूप से अक्षम है। इसका परीक्षण करने का सबसे आसान तरीका हर घटना को बदलना है.* किया जाए .*?, जो उस मामले का कारण बनता है जहां यह पहले जाँच की जाती है (जिसका अर्थ है कि यह रैखिक समय में मेल खाता है, लेकिन फिर भी अगर मिलान करने में विफल रहता है तो यह घातीय समय लेता है)।

मूल विचार यह है कि हम regex की लंबाई को बराबर 280 तक लागू करते हैं, और reahx में प्रत्येक वर्ण को कम से कम एक निश्चित संख्या में प्रकट होने के लिए बाध्य करने के लिए लुकहेड अभिकथन का उपयोग करते हैं, जैसे कि (?=(.*z){2})बलz वर्ण को कम से कम दो बार प्रदर्शित करने के । 2+43+43+22+23+2+6+16+7+4+1+3+2+2+1+22+22+11+2+23+23280 है, इसलिए हमारे पास किसी भी वर्ण की "अतिरिक्त" घटनाएं नहीं हो सकती हैं।

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

मार्टिन एंडर के सहयोग से पर्ल और पीसीआरई रेगेक्स, 253 बाइट्स

मैंने अनुमान लगाया कि कुछ समाधान हो सकते हैं जो कुछ अंकों (सबसे अधिक संभावना 9, 8, या 7) को छोड़ते हैं। मार्टिन एंडर को एक मिला, जो नीचे दिखाया गया है:

^(?=(.*z){2})(?=(.*\(){39})(?=(.*\)){39})(?=(.*\*){20})(?=(.*\.){21})(?=(.*0){4})(?=(.*1){6})(?=(.*2){11})(?=(.*3){6})(?=(.*4){3})(?=(.*5){2})(?=(.*6){3})(?=(.*9){4})(?=(.*=){20})(?=(.*\?){20})(?=(.*\\){9})(?=(.*\^){2})(?=(.*{){21})(?=(.*}){21}).{253}\z

पठनीय संस्करण:

^
(? = (। * जेड) {2})
(? = (। * \ () {39})
(? = (। * \)) {39})
(? = (। * \ *) {20})
(? = (। * \।) {21})
(? = (। * 0) {4})
(? = (। * 1) {6})
(? = (। * 2) {11})
(? = (। * 3) {6})
(? = (। * 4) {3})
(? = (। * 5) {2})
(? = (। * 6) {3})
(? = (। * 9) {4})
(? = (। * =) {20})
(? = (। * \?) {20})
(? = (। * \\) {9})
(? = (। * \ ^) {2})
(? = (। * {) {21})
(? = (। *}) {21})
। {253} \ z

Comments

मुझे नहीं लगता कि आपको {}आखिरी दो लुकहेड्स में भागने की जरूरत है । तुम भी चीजों को जोड़ने की जरूरत नहीं है (?=(.*5){1})क्योंकि वहाँ नहीं होगा 5अगर तुम उस lookahead नहीं था। एक समस्या यह है कि $एक अनुगामी लाइनफीड की अनुमति देता है, इसलिए आपको \zवहां की $तरह उपयोग करने की आवश्यकता होगी जैसे कि जिम्मी ने किया, लेकिन इससे आपको एक बाइट खर्च नहीं होगी, मुझे लगता है कि जब से आप \पहली नज़र में बचाते हैं ।

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

मुझे पता है कि अंकों जैसी चीजों को छोड़ना संभव है। हालाँकि, वे वहाँ ऑटोग्राम का काम करने के लिए हैं। कार्यक्रम के किसी भी हिस्से को हटाने से बाकी सभी टूट जाएंगे, क्योंकि यह अब प्रोग्राम को सही ढंग से वर्णित नहीं करता है। (प्रत्येक पंक्ति के लिए मायने रखता है प्रत्येक पंक्ति के लिए मायने रखता है! इस प्रकार यह मूल रूप से कार्यक्रम को बदलने के लिए मूल रूप से असंभव है।) $स्ट्रिंग के अंत में एक नई रेखा की अनुमति देने के रूप में , यह आमतौर पर निर्भर करता है कि आसपास के द्वारा रेगेक्स को कैसे बुलाया जाता है। कार्यक्रम (वे आम तौर पर कोड पर चलाए जाते हैं जो पहले से ही लाइनों में पार्स हो चुके हैं)।

या अधिक सटीक होने के लिए: मुझे (?=(.*5){1})इस मामले में आवश्यकता है । अगर मैंने इसे हटा दिया, तो कार्यक्रम में एक 5 होगा , क्योंकि (?=(.*1){6})रेखा को अब पढ़ना होगा (?=(.*1){5})।

अनुगामी लाइनफीड के रूप में आपके रेगेक्स के लिए इनपुट के प्रकार पर चुनौती में कोई प्रतिबंध नहीं लगता है, इसलिए आमतौर पर इसका मतलब है कि यह किसी भी स्ट्रिंग के लिए काम करना चाहिए, और किसी भी नुकसान के $लिए बदलना \zनहीं है (और doesn 'ऑटोग्राम को तोड़ना नहीं)।

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

ओह मैं समझा; आप बदलना \$... $करने के लिए z... \z। यह काम करता है; मैं इसे बदल दूँगा।