正則表達式以匹配3個或更多個連續的連續字符和連續的相同字符

Question

我需要正則表達式來匹配下面的情況。

1. 3個或更多連續的連續字符/數字;例如123，abc，789，pqr等
2. 3個或更多連續相同的字符/數字;例如111，aaa，bbb，222等

Answer 1

我不認爲你可以在第一種情況下使用正則表達式。第二種情況是容易雖然：

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

由於\\1表示部分地由基團1這個匹配將匹配的是任一的範圍內a-z或是數字（\d）三個相同的字符的任何序列。

Answer 2

關於第二個問題：

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

解釋：

\\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

據我所知，第一種情況是確實不可能的。正則表達式引擎不知道任何關於自然數字或字母表的順序。但它至少是可能的3點或更多的數字和3個或多個字母來區分，例如：

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

這符合abcd，ABCDE或123但不匹配ab2d，A5c4或12z，例如。根據此，第二情況下，可以正確地在更短的版本給出：

(\w)\1{2,} 

Answer 4

如果有下限（3）和上界regexString可以如下

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"); 
     } 
    } 
} 

輸出生成

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個或更多個連續的順序字符/數字的前 - 123，ABC，789，PQR等c。

不適用於正則表達式。

3個或更多個連續相同的字符/數字ex - 111，aaa，bbb。 222等

使用(?i)(?:([a-z0-9])\\1{2,})*的pattern。

如果要檢查整個字符串，請使用Matcher.matches()。要查找字符串內的匹配項，請使用Matcher.find()。

下面是一些示例代碼：

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); 
    } 
} 

，輸出是：

***** 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

感謝所有幫助我。

對於第一種情況 - 3個或更多個連續的連續字符/數字;例如123，abc，789，pqr等我用下面的代碼邏輯。請分享你對此的評論。

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

正則表達式匹配三個連續的數字或字母是 「（[0-9] | [AA-ZZ]）\ 1 \ 1」

Answer 8

嘗試此爲第一個問題。

這將打印發現如果發現在val可變連續3個數字或字母：

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

我不同意，案例1是可能的正則表達式，但你必須告訴它匹配的序列......這是一種長而無聊的類型：

/(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

對於第一個問題，這個作品，如果你確定沒有正則表達式

  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; 
       } 
      } 
     }