Cụm từ thông dụng để khớp với 3 hoặc nhiều ký tự tuần tự liên tiếp và các ký tự liên tiếp giống nhau

Question

Tôi cần cụm từ thông dụng để khớp với các trường hợp bên dưới.

1. 3 hoặc nhiều ký tự/số liên tiếp liên tiếp; ví dụ. 123, abc, 789, pqr, v.v.
2. 3 hoặc nhiều ký tự/số giống nhau liên tiếp; ví dụ. 111, aaa, bbb, 222, v.v.

Answer 1

Tôi không nghĩ bạn có thể sử dụng regex cho trường hợp đầu tiên. Trường hợp thứ hai là dễ dàng mặc dù:

Pattern pattern = Pattern.compile("([a-z\\d])\\1\\1", Pattern.CASE_INSENSITIVE); 

Kể từ \\1 đại diện cho phần kết hợp bởi nhóm 1 này sẽ phù hợp với bất kỳ chuỗi ba nhân vật giống hệt nhau hoặc là trong phạm vi a-z hoặc là chữ số (\d).

Answer 2

cho câu hỏi thứ hai:

\\b([a-zA-Z0-9])\\1\\1+\\b 

giải thích:

\\b    : zero-length word boundary 
    (    : start capture group 1 
    [a-zA-Z0-9] : a letter or a digit 
)    : end group 
    \\1    : same character as group 1 
    \\1+   : same character as group 1 one or more times 
\\b    : zero-length word boundary 

Answer 3

Theo hiểu biết của tôi, trường hợp đầu tiên thực sự là không thể. Động cơ regex không biết gì về thứ tự của các số tự nhiên hoặc bảng chữ cái. Nhưng đó là ít nhất có thể để phân biệt giữa 3 hoặc nhiều số và 3 hoặc nhiều chữ cái, ví dụ:

[a-z]{3,}|[A-Z]{3,}|\d{3,} 

này phù hợp với abcd, ABCDE hoặc 123 nhưng không phù hợp với ab2d, A5c4 hoặc 12z, ví dụ. Theo đó, trường hợp thứ hai có thể được đưa ra một cách chính xác trong một phiên bản ngắn hơn như:

(\w)\1{2,} 

Answer 4

Nếu bạn có thấp hơn giới hạn (3) và regexString ràng buộc trên có thể được tạo ra như sau

public class RegexBuilder { 
    public static void main(String[] args) { 
     StringBuilder sb = new StringBuilder(); 

     int seqStart = 3; 
     int seqEnd = 5; 
     buildRegex(sb, seqStart, seqEnd); 
     System.out.println(sb); 
    } 

    private static void buildRegex(StringBuilder sb, int seqStart, int seqEnd) { 
     for (int i = seqStart; i <= seqEnd; i++) { 
      buildRegexCharGroup(sb, i, '0', '9'); 
      buildRegexCharGroup(sb, i, 'A', 'Z'); 
      buildRegexCharGroup(sb, i, 'a', 'z'); 
      buildRegexRepeatedString(sb, i); 
     } 
    } 

    private static void buildRegexCharGroup(StringBuilder sb, int seqLength, 
      char start, char end) { 
     for (char c = start; c <= end - seqLength + 1; c++) { 
      char ch = c; 
      if (sb.length() > 0) { 
       sb.append('|'); 
      } 
      for (int i = 0; i < seqLength; i++) { 
       sb.append(ch++); 
      } 
     } 
    } 

    private static void buildRegexRepeatedString(StringBuilder sb, int seqLength) { 
     sb.append('|'); 
     sb.append("([a-zA-Z\\d])"); 
     for (int i = 1; i < seqLength; i++) { 
      sb.append("\\1"); 
     } 
    } 
} 

Output

012|123|234|345|456|567|678|789|ABC|BCD|CDE|DEF|EFG|FGH|GHI|HIJ|IJK|JKL|KLM|LMN|MNO|NOP|OPQ|PQR|QRS|RST|STU|TUV|UVW|VWX|WXY|XYZ|abc|bcd|cde|def|efg|fgh|ghi|hij|ijk|jkl|klm|lmn|mno|nop|opq|pqr|qrs|rst|stu|tuv|uvw|vwx|wxy|xyz|([a-z\d])\1\1|0123|1234|2345|3456|4567|5678|6789|ABCD|BCDE|CDEF|DEFG|EFGH|FGHI|GHIJ|HIJK|IJKL|JKLM|KLMN|LMNO|MNOP|NOPQ|OPQR|PQRS|QRST|RSTU|STUV|TUVW|UVWX|VWXY|WXYZ|abcd|bcde|cdef|defg|efgh|fghi|ghij|hijk|ijkl|jklm|klmn|lmno|mnop|nopq|opqr|pqrs|qrst|rstu|stuv|tuvw|uvwx|vwxy|wxyz|([a-z\d])\1\1\1||12345|23456|34567|45678|56789|ABCDE|BCDEF|CDEFG|DEFGH|EFGHI|FGHIJ|GHIJK|HIJKL|IJKLM|JKLMN|KLMNO|LMNOP|MNOPQ|NOPQR|OPQRS|PQRST|QRSTU|RSTUV|STUVW|TUVWX|UVWXY|VWXYZ|abcde|bcdef|cdefg|defgh|efghi|fghij|ghijk|hijkl|ijklm|jklmn|klmno|lmnop|mnopq|nopqr|opqrs|pqrst|qrstu|rstuv|stuvw|tuvwx|uvwxy|vwxyz|([a-z\d])\1\1\1\1 

Answer 5

3 hoặc nhiều ký tự liên tiếp liên tiếp/số cũ - 123, abc, 789, pqr et c.

Không thể với biểu thức chính quy.

3 hoặc nhiều ký tự/số giống nhau liên tiếp cũ hơn - 111, aaa, bbb. 222 vv

Sử dụng số pattern của (?i)(?:([a-z0-9])\\1{2,})*.

Nếu bạn muốn kiểm tra toàn bộ chuỗi, hãy sử dụng Matcher.matches(). Để tìm các kết quả phù hợp trong chuỗi, hãy sử dụng Matcher.find().

Dưới đây là một số mẫu mã:

final String ps = "(?i)(?:([a-z0-9])\\1{2,})*"; 
final String psLong = 
     "(?i)\t\t\t# Case insensitive flag\n" 
       + "(?:\t\t\t\t# Begin non-capturing group\n" 
       + " (\t\t\t\t# Begin capturing group\n" 
       + " [a-z0-9]\t\t# Match an alpha or digit character\n" 
       + ")\t\t\t\t# End capturing group\n" 
       + " \\1\t\t\t\t# Back-reference first capturing group\n" 
       + " {2,}\t\t\t# Match previous atom 2 or more times\n" 
       + ")\t\t\t\t# End non-capturing group\n" 
       + "*\t\t\t\t# Match previous atom zero or more characters\n"; 
System.out.println("***** PATTERN *****\n" + ps + "\n" + psLong 
     + "\n"); 
final Pattern p = Pattern.compile(ps); 
for (final String s : new String[] {"aa", "11", "aaa", "111", 
     "aaaaaaaaa", "111111111", "aaa111bbb222ccc333", 
     "aaaaaa111111bbb222"}) 
{ 
    final Matcher m = p.matcher(s); 
    if (m.matches()) { 
     System.out.println("Success: " + s); 
    } else { 
     System.out.println("Fail: " + s); 
    } 
} 

Và kết quả là:

***** PATTERN ***** 
(?i)(?:([a-z0-9])\1{2,})* 
(?i)   # Case insensitive flag 
(?:    # Begin non-capturing group 
(    # Begin capturing group 
    [a-z0-9]  # Match an alpha or digit character 
)    # End capturing group 
\1    # Back-reference first capturing group 
{2,}   # Match previous atom 2 or more times 
)    # End non-capturing group 
*    # Match previous atom zero or more characters 


Fail: aa 
Fail: 11 
Success: aaa 
Success: 111 
Success: aaaaaaaaa 
Success: 111111111 
Success: aaa111bbb222ccc333 
Success: aaaaaa111111bbb222 

Answer 6

Cảm ơn tất cả đã giúp tôi.

Đối với trường hợp đầu tiên - 3 hoặc nhiều ký tự/số liên tiếp liên tục; ví dụ. 123, abc, 789, pqr, v.v. Tôi đã sử dụng mã logic bên dưới. Xin vui lòng chia sẻ ý kiến ​​của bạn về điều này.

public static boolean validateConsecutiveSeq(String epin) { 
    char epinCharArray[] = epin.toCharArray(); 
    int asciiCode = 0; 
    boolean isConSeq = false; 
    int previousAsciiCode = 0; 
    int numSeqcount = 0; 

    for (int i = 0; i < epinCharArray.length; i++) { 
     asciiCode = epinCharArray[i]; 
     if ((previousAsciiCode + 1) == asciiCode) { 
      numSeqcount++; 
      if (numSeqcount >= 2) { 
       isConSeq = true; 
       break; 
      } 
     } else { 
      numSeqcount = 0; 
     } 
     previousAsciiCode = asciiCode; 
    } 
    return isConSeq; 
} 

Answer 7

Regex để phù hợp với ba số liên tiếp hoặc bảng chữ cái là "([0-9] | [aA-zZ]) \ 1 \ 1"

Answer 8

Hãy thử điều này cho câu hỏi đầu tiên.

này sẽ in tìm thấy nếu nó tìm thấy 3 số liên tiếp hoặc bảng chữ cái trong val biến:

var val = 'Sh1ak@ki1r@100'; 
 

 
var matchfound = false; 
 
for (i = 0; i <= val.length - 3; i++) { 
 
    var s1 = val.charCodeAt(i); 
 
    var s2 = val.charCodeAt(i + 1); 
 
    var s3 = val.charCodeAt(i + 2); 
 
    if (Math.abs(s1 - s2) === 1 && s1 - s2 === s2 - s3) { 
 
    matchfound = true; 
 
    break; 
 
    } 
 
} 
 

 
if (!matchfound) { 
 
    console.log("not found"); 
 
}

Answer 9

tôi không đồng ý, trường hợp 1 có thể regex, nhưng bạn phải cho biết các chuỗi phù hợp ... dài và nhàm chán:

/(abc|bcd|cde|def|efg|fgh|ghi|hij|ijk|jkl|klm|lmn|mno|nop|opq|pqr|qrs|rst|stu|tuv|uvw|vwx|wxy|xyz|012|123|234|345|456|567|678|789)+/ig 

http://regexr.com/3dqln

Answer 10

cho câu hỏi đầu tiên này làm việc nếu bạn ok không có regex

  containsConsecutiveCharacters(str) { 
      for (let i = 0; i <= str.length - 3; i++) { 
       var allthree = str[i] + str[i + 1] + str[i + 2]; 
       let s1 = str.charCodeAt(i); 
       let s2 = str.charCodeAt(i + 1); 
       let s3 = str.charCodeAt(i + 2); 
       if (
        /[a-zA-Z]+$/.test(allthree) && 
        (s1 < s2 && s2 < s3 && s1+s2+s3-(3*s1) === 3) 
       ) { 
        return true; 
       } 
      } 
     }