पैटर्न: चरित्र वर्ग में मिलान किए गए चरित्र को कैसे घटाया जाए?

Question

क्या एक चरित्र वर्ग में मिलान किए गए चरित्र को घटा देना संभव है?

Java docs घटाव के साथ चरित्र वर्गों के बारे में उदाहरण कर रहे हैं:

1) "aaaa123" - should NOT match 
2) "aabb123" - should match "aabb" part 
3) "aa--123" - should NOT match 

मैं:

[a-z&&[^bc]] - a through z, except for b and c: [ad-z] (subtraction) 
[a-z&&[^m-p]] - a through z, and not m through p: [a-lq-z](subtraction) 

मैं पैटर्न है, जो शब्द पात्रों के दो जोड़े से मेल खाता है, जब जोड़े ही नहीं हैं लिखना चाहते हैं निम्नलिखित पैटर्न के साथ सफलता के करीब हूं:

([\w])\1([\w])\2 

लेकिन निश्चित रूप से यह 1 मामले में काम नहीं करता है, इसलिए मुझे पहले समूह के मैच को घटाना होगा। लेकिन जब मैं यह करने के लिए प्रयास करें:

Pattern p = Pattern.compile("([\\w])\\1([\\w&&[^\\1]])\\2"); 

मैं एक अपवाद हो रही है:

Exception in thread "main" java.util.regex.PatternSyntaxException: Illegal/unsupported escape sequence near index 17 
([\w])\1([\w&&[^\1]])\2 
       ^
    at java.util.regex.Pattern.error(Pattern.java:1713) 

तो यह समूहों के साथ काम नहीं करता है, लेकिन सिर्फ विशिष्ट वर्ण लिस्टिंग के साथ लगता है। बिना किसी समस्या के पैटर्न के संकलन:

Pattern p = Pattern.compile("([\\w])\\1([\\w&&[^a]])\\2"); 

क्या इस तरह के पैटर्न लिखने का कोई और तरीका है?

Answer 1

उपयोग

Pattern p = Pattern.compile("((\\w)\\2(?!\\2))((\\w)\\4)"); 

आपका वर्ण समूहों 1 और 3 में होगा।

यह एक नकारात्मक अग्रदर्शी का उपयोग कर, पहले वर्ण समूह में दूसरे चरित्र निम्नलिखित यकीन है कि चरित्र बनाने के लिए कर काम करता है एक अलग चरित्र है।

Answer 2

आप नौकरी के लिए गलत उपकरण का उपयोग कर रहे हैं। हर तरह से चरित्र जोड़े के जोड़े का पता लगाने के लिए रेगेक्स का उपयोग करें, लेकिन आप यह जांचने के लिए != का उपयोग कर सकते हैं कि जोड़े के भीतर वर्ण समान हैं या नहीं। गंभीरता से, नियमित अभिव्यक्ति में सब कुछ करने का कोई कारण नहीं है - यह अपठनीय, गैर-पोर्टेबल कोड बनाता है और आपको "शांत दिखने" के अलावा कोई लाभ नहीं देता है।

Answer 3

प्रयास करें इस

String regex = "(\\w)\\1(?!\\1)(\\w)\\2"; 
Pattern pattern = Pattern.compile(regex); 

(?!\\1) एक negative lookahead है, यह सुनिश्चित करता है कि \\1 की सामग्री का पालन नहीं कर रहा है

मेरे परीक्षण कोड

String s1 = "aaaa123"; 
String s2 = "aabb123"; 
String s3 = "aa--123"; 
String s4 = "123ccdd"; 

String[] s = { s1, s2, s3, s4 }; 
String regex = "(\\w)\\1(?!\\1)(\\w)\\2"; 

for(String a : s) { 
    Pattern pattern = Pattern.compile(regex); 
    Matcher matcher = pattern.matcher(a); 

    if (matcher.find()) 
     System.out.println(a + " ==> Success"); 
    else 
     System.out.println(a + " ==> Failure"); 
} 

उत्पादन

aaaa123 ==> विफलता
aabb123 ==> सफलता
आ - 123 ==> विफलता
123ccdd ==> सफलता