संकलन (सामग्री प्रतिस्थापन द्वारा)

आपका काम रेगेक्स को संकलित करना है ... रेगेक्स में प्रत्येक चरित्र के लिए एक प्रतिस्थापन निर्दिष्ट करके।

regexes

रेग्जेस इनका समर्थन करते हैं

REGEX       = (LITERAL REGEX / GROUP REGEX / STAR REGEX / ALTERNATIVE)
LITERAL     = 1 / 0
GROUP       = '(' REGEX ')'
STAR        = (LITERAL / GROUP) '*'
ALTERNATIVE = '('REGEX ('|' REGEX)*')'

केवल 1 या 0 ही क्यों? यह सरलीकरण के लिए है। इस प्रकार regex में केवल निम्न वर्ण हैं:

*()|10

इसकी व्याख्या इस प्रकार है:

* क्लेन स्टार (बाएं समूह या शाब्दिक 0 या अधिक बार दोहराएं) है।
| प्रत्यावर्तन है (मिलान या तो बायीं ओर रेगीक्स या दायें मैचों के लिए रेग्क्स)।
() समूहीकरण कर रहा है।
1 मैच चरित्र 1।
0 मिलान वर्ण ०।

कैसे संकलित करें?

आप छह कोड स्निपेट निर्दिष्ट करते हैं: प्रत्येक रेगेक्स चरित्र को बदलने के लिए। उदाहरण के लिए, यदि आपका उत्तर है:

*: FSAGFSDVADFS
|: GSDGSAG
(: GSDG
): GDSIH
1: RGIHAIGH
0:GIHEBN

फिर आप प्रत्येक रेगेक्स को उसके संबंधित कोड स्निपेट से बदल देते हैं, इसलिए:

(0|11)*

में बदल दिया गया है:

GSDGGIHEBNGSDGSAGRGIHAIGHRGIHAIGHGDSIHFSAGFSDVADFS

परिणामी कार्यक्रम क्या करने वाला है?

आपका कार्यक्रम होगा:

इनपुट लें
अगर रेक्सक्स पूरे इनपुट से मेल खाता है, तो एक सत्य मूल्य का उत्पादन करें।
अतिरिक्त उत्पादन एक मिथ्या मूल्य है।

बाहर के इनपुट 01को अनिर्धारित व्यवहार के रूप में माना जाता है। इनपुट खाली हो सकता है।

अतिरिक्त नियम

किसी दिए गए रेगेक्स चरित्र के लिए, परिणामी स्निपेट हमेशा समान होनी चाहिए।
इसके बाद कोई उपसर्ग या प्रत्यय नहीं जोड़ा जाता है।
रेगेक्स को गैर-रिक्त होने की गारंटी है।

स्कोरिंग

सबसे कम संयुक्त स्निपेट विजेता है। तो उदाहरण के मामले के स्कोर की गणना इस प्रकार की जाएगी:

FSAGFSDVADFS+ GSDGSAG+ GSDG+ GDSIH+ RGIHAIGH+GIHEBN

१२ + 42 + ४ + ५ + 6 + ६ = ४२

code-golf source-layout regular-expression

— Akangka
स्रोत

क्या प्रत्येक स्निपेट कम से कम 1 वर्ण लंबा है?

— ट्राइकोप्लाक्स

स्निपेट की लंबाई शून्य हो सकती है। संपादन ठीक है।

— अकांगका

क्या भाषा RegEx इस चुनौती के लिए वैध है? : पी

— लोजो

मुझे लगता है कि RegEx के पास RegEx बिल्ड-इन है। मुझे ऐसा करने के लिए मजबूर किया जाता है। मैं रेटिना और रेगेक्स को बाहर करना चाहता हूं, हालांकि, मेगो के अनुसार, इसकी अनुमति नहीं है। फिर भी, मैं घोंघे और दोस्तों के बारे में नहीं जानता।

— अकांगका

@ChristianIrwan दिलचस्प बात यह है कि मुझे अभी भी यकीन नहीं है कि यह रेटिना में भी सॉल्व है, और यहां तक कि यह प्रतिस्पर्धी से भी दूर होगा।

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

जवाबों:

घोंघे , 48 बाइट्स

0 -> )0(\0!(l.)(~

1 -> )0(\1!(l.)(~

( -> )0({{(

) -> )0}}(~

| -> )0}|{(

* -> )0),(~

अगर हमें केवल पूर्ण इनपुट के मिलान के बजाय आंशिक मैचों की खोज करनी थी, तो यह बहुत आसान होगा। 0बन जाएगा \0, 1बन जाएगा \1, *बन जाएगा ,, और दूसरों को खुद को करने के लिए नक्शे होगा। इसके बजाय मैचों को शुरू से कहीं और शुरू करने या अंत के अलावा कहीं और समाप्त होने से रोकने के लिए बहुत सारे शीनिगान हैं। !(l.)एक जोर है कि विफल हो जाएगा अगर मैच की शुरुआत इनपुट की शुरुआत में नहीं है। ~इनपुट के बाहर एक सेल से मेल खाता है, इसलिए इसे उन सभी वर्णों में जोड़ा जाता है जिन्हें रेगेक्स के अंत में होने की अनुमति है। अगर वहाँ एक और regex चरित्र है, यह एक संख्यात्मक मात्रात्मक द्वारा रद्द कर दिया है0जो इसे आवश्यक रूप से टिप्पणी करते हुए 0 बार मिलान करने की आवश्यकता है। डमी आउट ऑफ सीमा परीक्षण के रास्ते में सही तरीके से काम करने के लिए अनुमति देने के लिए *( ,), भाषा के ब्रैकेट मिलान नियमों का भारी उपयोग किया जाता है। प्रलेखन से:

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

कीचड़ के रूप में स्पष्ट है, है ना?

— feersum
स्रोत

आह, मैं भूल गया कि रेगेक्स के बाहर भी मेल खाने वाली भाषा है। अच्छी नौकरी, लेकिन खेद है, कोई अपवोट (कोई

— डाउनवोट

@ChristianIrwan वास्तव में 2d मेल खाने वाली भाषाओं को विकसित करने के लिए इस साइट पर एक पूरी चुनौती है, जिनमें से अधिकांश में 1d degener का उपयोग होता है। codegolf.stackexchange.com/questions/47311/…

— 8

सीजेएम, 151 बाइट्स

{]Na/Saf+{:m*:sSf-~}%}:J{+:MU{]W=~Jea&,}|}:TM0sa`T
{]Na/Saf+{:m*:sSf-~}%}:J{+:MU{]W=~Jea&,}|}:TM1sa`T
M{{+:M];eas!}:T}|U):UM'[T
MN`T
U(:UM'JT
M\"S+ea`,m*\"T

लाइनें वर्णों के अनुरूप हैं 01(|)*(उस क्रम में)। इसे ऑनलाइन आज़माएं!

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

टेस्ट चलता है

निम्नलिखित एक प्रोग्राम का उपयोग करता है जो STDIN से एक नियमित अभिव्यक्ति पढ़ता है, अपने प्रत्येक वर्ण को उचित स्निपेट द्वारा प्रतिस्थापित करता है, और अंत में यह देखने के लिए कि यह कमांड लाइन तर्क में निर्दिष्ट इनपुट से मेल खाता है, उत्पन्न कोड का मूल्यांकन करता है।

$ cat regex.cjam
l"01(|)*""

{]Na/Saf+{:m*:sSf-~}%}:J{+:MU{]W=~Jea&,}|}:TM0sa`T
{]Na/Saf+{:m*:sSf-~}%}:J{+:MU{]W=~Jea&,}|}:TM1sa`T
M{{+:M];eas!}:T}|U):UM'[T
MN`T
U(:UM'JT
M\"S+ea`,m*\"T

"N%ers~
$ cjam regex.cjam '' <<< '(|)'
1
$ cjam regex.cjam '0' <<< '(|)'
0
$ cjam regex.cjam '' <<< '0(|)'
0
$ cjam regex.cjam '0' <<< '0(|)'
1
$ cjam regex.cjam '' <<< '(0|11)*'
1
$ cjam regex.cjam '0' <<< '(0|11)*'
1
$ cjam regex.cjam '11' <<< '(0|11)*'
1
$ cjam regex.cjam '011011000' <<< '(0|11)*'
1
$ cjam regex.cjam '1010' <<< '(0|11)*'
0

दुर्भाग्य से, यह विशेष रूप से तेज नहीं है। यदि इनपुट में 9 से अधिक अक्षर हैं या रेगेक्स में एकल क्लेनी स्टार से अधिक है तो यह जल्दी से चोक हो जाएगा।

5 अतिरिक्त बाइट्स की लागत पर - कुल 156 बाइट्स के लिए - हम संभावित इनपुट से मिलान करने और उन्हें कम करने के लिए छोटे तार उत्पन्न कर सकते हैं। यह नहीं बदलता है कि कोड कैसे काम करता है; यह सिर्फ इसे और अधिक कुशल बनाता है।

$ cat regex-fast.cjam 
l"01(|)*""

{]Na/Saf+{:m*:sSf-~}%}:J{+:MU{]W=~Jea&,}|}:TM0sa`T
{]Na/Saf+{:m*:sSf-~}%}:J{+:MU{]W=~Jea&,}|}:TM1sa`T
M{{+:M];eas!}:T}|U):UM'[T
MN`T
U(:UM'JT
M\"S+eas,)m*:sSf-L|\"T

"N%ers~
$ cjam regex-fast.cjam '0101001010' <<< '(01|10)*'
0
$ cjam regex-fast.cjam '011001101001' <<< '(01|10)*'
1
$ cjam regex-fast.cjam '0' <<< '(0*1)*'
0
$ time cjam regex-fast.cjam '101001' <<< '(0*1)*'
1

— डेनिस
स्रोत

मुझे अभी भी कुछ पता है कि मैं इसे कैसे छोटा और / या तेज बना सकता हूं। जब मैं परिणामों से संतुष्ट हो जाऊंगा तो एक स्पष्टीकरण जोड़ दूंगा।

— डेनिस

वहाँ के `-escaping of the लिए पैटर्न में एक शानदार "` प्रतीत होता है *। उस के बावजूद, मैं किसी भी इनपुट को स्वीकार करने के लिए इस कार्यक्रम को प्राप्त नहीं कर सका, यहां तक कि सबसे सरल मामले के लिए जहां रेगेक्स केवल एक 0( ऑनलाइन इंटरप्रेटर में परीक्षण देखें ) शामिल हैं। मैं गलत कर रहा हूँ?

— Matz

@matz मेरा कोड कमांड-लाइन तर्कों का उपयोग करता है, जो उस दुभाषिया में लागू नहीं होते हैं। इसके बजाय यह प्रयास करें ।

— डेनिस