Espressione regolare per abbinare 3 o più caratteri sequenziali consecutivi e caratteri identici consecutivi

Question

Ho bisogno di espressioni regolari per abbinare i casi seguenti.

1. 3 o più caratteri/numeri sequenziali consecutivi; per esempio. 123, abc, 789, pqr, ecc.
2. 3 o più caratteri/numeri identici consecutivi; per esempio. 111, aaa, bbb, 222, ecc.

Answer 1

Non penso che sia possibile utilizzare regex per il primo caso. Il secondo caso è facile però:

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

Da \\1 rappresenta una parte corrispondente al gruppo 1 questo corrisponderà qualsiasi sequenza di tre caratteri identici che sono o nell'intervallo a-z o sono cifre (\d).

Answer 2

per la seconda domanda:

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

spiegazione:

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

Per quanto ne so, il primo caso, non è davvero possibile. Il motore regex non sa nulla sull'ordine dei numeri naturali o dell'alfabeto. Ma è almeno possibile distinguere tra 3 o più numeri e 3 o più lettere, per esempio:

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

Questo corrisponde abcd, ABCDE o 123 ma non corrisponde ab2d, A5c4 o 12z, per esempio. In base a questo, il secondo caso può essere correttamente determinato in una versione più breve come:

(\w)\1{2,} 

Answer 4

Se si dispone di limite inferiore (3) e regexString limite superiore possono essere generati come segue

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

uscita

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 o più caratteri sequenziali consecutivi/numeri ex - 123, abc, 789, pqr et

Non possibile con espressioni regolari.

3 o più caratteri identici consecutivi/numeri ex - 111, aaa, bbb. 222 ecc.

Utilizzare uno pattern di (?i)(?:([a-z0-9])\\1{2,})*.

Se si desidera controllare l'intera stringa, utilizzare Matcher.matches(). Per trovare le corrispondenze all'interno di una stringa, utilizzare Matcher.find().

Ecco alcuni esempi di codice:

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

e l'uscita è:

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

Grazie a tutti per avermi aiutato.

Per il primo caso - 3 o più caratteri/numeri sequenziali consecutivi; per esempio. 123, abc, 789, pqr, ecc. Ho usato sotto la logica del codice. Pls condividi i tuoi commenti su questo.

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 per abbinare tre numeri consecutivi o alfabeti è "([0-9] | [aA-zZ]) \ 1 \ 1"

Answer 8

Prova questo per la prima domanda.

Questo stamperà trovato se trova 3 numeri consecutivi o alfabeti nella val variabile:

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

Non sono d'accordo, caso 1 è possibile regex, ma si deve dillo alle sequenze corrispondenti ... il che è abbastanza lungo e noioso:

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

per la prima domanda a questo funziona se sei ok con nessuna espressione regolare

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