java - rango - validar expresiones regulares c#
Expresión regular para hacer coincidir 3 o más caracteres consecutivos consecutivos y caracteres idénticos consecutivos (13)
Necesito expresiones regulares para que coincida con los siguientes casos.
- 3 o más caracteres / números secuenciales consecutivos; por ejemplo, 123, abc, 789, pqr, etc.
- 3 o más caracteres / números idénticos consecutivos; por ejemplo, 111, aaa, bbb, 222, etc.
3 o más caracteres / números secuenciales consecutivos ex - 123, abc, 789, pqr, etc.
No es posible con expresiones regulares.
3 o más caracteres / números idénticos consecutivos ex - 111, aaa, bbb. 222 etc.
Use un pattern de (?i)(?:([a-z0-9])//1{2,})* .
Si desea verificar toda la cadena, use Matcher.matches() . Para encontrar coincidencias dentro de una cadena, use Matcher.find() .
Aquí hay un código de ejemplo:
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);
}
}
Y la salida es:
***** 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
Gracias a todos por ayudarme.
Para el primer caso - 3 o más caracteres / números consecutivos consecutivos; por ejemplo, 123, abc, 789, pqr, etc. Usé la lógica de código a continuación. Por favor comparta sus comentarios sobre esto.
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;
}
Intenta esto para la primera pregunta.
devuelve verdadero si encuentra 3 números consecutivos o alfabetos en el argumento
function check(value){
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) {
return true;
}
}
return false;
}
console.log(check(''Sh1ak@ki1r@100''));
La expresión regular para hacer coincidir tres números consecutivos o alfabetos es "([0-9] | [aA-zZ]) / 1 / 1"
No creo que puedas usar expresiones regulares para el primer caso. El segundo caso es fácil aunque:
Pattern pattern = Pattern.compile("([a-z//d])//1//1", Pattern.CASE_INSENSITIVE);
Como //1 representa la parte coincidente por el grupo 1 esto coincidirá con cualquier secuencia de tres caracteres idénticos que estén dentro del rango az o sean dígitos ( /d ).
No estoy de acuerdo, el caso 1 es posible de expresión regular, pero tienes que decirle las secuencias para que coincidan ... lo que es un poco largo y aburrido:
/(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
Para la primera pregunta, esto funciona si estás bien con menos expresiones regulares.
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;
}
}
}
Que yo sepa, el primer caso no es posible. El motor de expresiones regulares no sabe nada sobre el orden de los números naturales o el alfabeto. Pero al menos es posible diferenciar entre 3 o más números y 3 o más letras, por ejemplo:
[a-z]{3,}|[A-Z]{3,}|/d{3,}
Esto coincide con abcd , ABCDE o 123 pero no coincide con ab2d , A5c4 o 12z , por ejemplo. De acuerdo con esto, el segundo caso se puede dar correctamente en una versión más corta como:
(/w)/1{2,}
Si tiene un límite inferior (3) y un límite superior, las expresiones regulares se pueden generar de la siguiente manera
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");
}
}
}
Salida
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|01234|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
Todos juntos
([a-zA-Z0-9]) / 1 / 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) +
3 o más caracteres / números secuenciales consecutivos; por ejemplo, 123, abc, 789, pqr, etc.
(abc | bcd | cde | cde | def | ef | fg | pqr | qq | | | | | | 123 | 234 | 345 | 456 | 567 | 678 | 789) +
3 o más caracteres / números idénticos consecutivos; por ejemplo, 111, aaa, bbb, 222, etc.
([a-zA-Z0-9]) / 1 / 1+
Todos juntos
([a-zA-Z0-9]) / 1 / 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) +
3 o más caracteres / números secuenciales consecutivos; por ejemplo, 123, abc, 789, pqr, etc.
(abc | bcd | cde | cde | def | ef | fg | pqr | qq | | | | | | 123 | 234 | 345 | 456 | 567 | 678 | 789) +
3 o más caracteres / números idénticos consecutivos; por ejemplo, 111, aaa, bbb, 222, etc.
([a-zA-Z0-9]) / 1 / 1+
Esto también funciona:
(? :( ?: 0 (? = 1) | 1 (? = 2) | 2 (? = 3) | 3 (? = 4) | 4 (? = 5) | 5 (? = 6) | 6 ( ? = 7) | 7 (? = 8) | 8 (? = 9)) {2,} / d | (?: A (? = B) | b (? = C) | c (? = D) | d (? = e) | e (? = f) | f (? = g) | g (? = h) | h (? = i) | i (? = j) | j (? = k) | k (? = l) | l (? = m) | m (? = n) | n (? = o) | o (? = p) | p (? = q) | q (? = r) | r ( ? = s) | s (? = t) | t (? = u) | u (? = v) | v (? = w) | w (? = x) | x (? = y) | y (? = z)) {2,} [[: alpha:]]) | ([a-zA-Z0-9]) / 1 / 1+
para la segunda pregunta:
//b([a-zA-Z0-9])//1//1+//b
explicación:
//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
3 o más caracteres / números secuenciales consecutivos; por ejemplo, 123, abc, 789, pqr, etc.
(?:(?:0(?=1)|1(?=2)|2(?=3)|3(?=4)|4(?=5)|5(?=6)|6(?=7)|7(?=8)|8(?=9)){2,}/d|(?:a(?=b)|b(?=c)|c(?=d)|d(?=e)|e(?=f)|f(?=g)|g(?=h)|h(?=i)|i(?=j)|j(?=k)|k(?=l)|l(?=m)|m(?=n)|n(?=o)|o(?=p)|p(?=q)|q(?=r)|r(?=s)|s(?=t)|t(?=u)|u(?=v)|v(?=w)|w(?=x)|x(?=y)|y(?=z)){2,}[/p{Alpha}])3 o más caracteres / números idénticos consecutivos; por ejemplo, 111, aaa, bbb, 222, etc.
([/p{Alnum}])/1{2,}