solo - probar expresiones regulares java
Dada una cadena, genere una expresión regular que pueda analizar*cadenas*similares (11)
Además de alimentar el algoritmo de aprendizaje con ejemplos de entrada "buena", puede darle entrada "mala" para que sepa qué no buscar. No hay letras en un número de teléfono, por ejemplo.
Por ejemplo, dada la cadena "2009/11/12" quiero obtener la expresión regular ("/ d {2} / d {2} / d {4}"), así que podré coincidir con "2001 / 01/02 "también.
¿Hay algo que hace eso? ¿Algo parecido? ¿Alguna idea de cómo hacerlo?
Disculpe, pero lo que todos llaman imposible es claramente una tarea alcanzable. No podrá dar resultados para TODOS los ejemplos, y quizás no sean los mejores resultados, pero puede darle varios consejos, y le facilitará la vida. Algunos ejemplos seguirán.
También sería muy útil una salida legible traduciendo el resultado. Algo como:
- "Buscar: una palabra que comienza con una letra no numérica y termina con la cadena:" ing ".
- o: Buscar: texto que tiene bbb en él, seguido de zzz
- o: * Buscar: un patrón que se vea tan "aa / bbbb / cccc" donde "/" es un separador, "aa" tiene dos dígitos, "bbbb" es una palabra de cualquier longitud y "cccc" tiene cuatro dígitos entre 1900 y 2020 *
Tal vez podríamos hacer un "traductor inverso" con un tipo de lenguaje SQL para crear expresiones regulares, en lugar de crearlo en geek.
Aquí hay algunos ejemplos que son factibles:
class Hint:
Properties: HintType, HintString
enum HintType { Separator, ParamDescription, NumberOfParameters }
enum SampleType { FreeText, DateOrTime, Formatted, ... }
public string RegexBySamples( List<T> samples,
List<SampleType> sampleTypes,
List<Hint> hints,
out string GeneralRegExp, out string description,
out string generalDescription)...
regex = RegExpBySamples( {"11/November/1999", "2/January/2003"},
SampleType.DateOrTime,
new HintList( HintType.NumberOfParameters, 3 ));
regex = RegExpBySamples( "123-aaaaJ-1444",
SampleType.Format, HintType.Seperator, "-" );
También sería posible una GUI en la que marque el texto de muestra o lo ingrese, agregando a la expresión regular. Primero marque una fecha (la "muestra") y elija si este texto ya tiene formato, o si está creando un formato, también cuál es el tipo de formato: texto libre, texto con formato, fecha, GUID o Elegir ... a partir de formatos existentes (que puedes almacenar en la biblioteca).
Permite diseñar una especificación para esto, y hacer que sea de código abierto ... ¿Alguien quiere unirse?
Existe text2re , un text2re gratuito de "expresiones regulares por ejemplo" basado en la web.
Sin embargo, no creo que esté disponible en el código fuente. Me atrevo a decir que no hay un generador de expresiones regulares automático que funcione correctamente sin la intervención del usuario, ya que esto requeriría que la máquina sepa lo que quiere.
Tenga en cuenta que text2re utiliza un enfoque basado en plantillas, modularizado y muy generalizado para la generación de expresiones regulares. Las expresiones que genera funcionan, pero son mucho más complejas que la expresión artesanal equivalente. No es una buena herramienta para aprender expresiones regulares porque hace un trabajo bastante malo en la configuración de ejemplos.
Por ejemplo, la cadena "2009/11/12" sería reconocida como un patrón yyyymmdd , lo cual es útil. La herramienta lo transforma en este monstruo de 125 caracteres:
((?:(?:[1]{1}/d{1}/d{1}/d{1})|(?:[2]{1}/d{3}))[-://.](?:[0]?[1-9]|[1][012])[-://.](?:(?:[0-2]?/d{1})|(?:[3][01]{1})))(?![/d])
El equivalente hecho a mano tomaría solo dos quintas partes de eso (50 caracteres):
([12]/d{3})[-:/.](0?/d|1[0-2])[-:/.]([0-2]?/d|3[01])/b
He intentado un enfoque muy ingenuo:
class RegexpGenerator {
public static Pattern generateRegexp(String prototype) {
return Pattern.compile(generateRegexpFrom(prototype));
}
private static String generateRegexpFrom(String prototype) {
StringBuilder stringBuilder = new StringBuilder();
for (int i = 0; i < prototype.length(); i++) {
char c = prototype.charAt(i);
if (Character.isDigit(c)) {
stringBuilder.append("//d");
} else if (Character.isLetter(c)) {
stringBuilder.append("//w");
} else { // falltrought: literal
stringBuilder.append(c);
}
}
return stringBuilder.toString();
}
private static void test(String prototype) {
Pattern pattern = generateRegexp(prototype);
System.out.println(String.format("%s -> %s", prototype, pattern));
if (!pattern.matcher(prototype).matches()) {
throw new AssertionError();
}
}
public static void main(String[] args) {
String[] prototypes = {
"2009/11/12",
"I''m a test",
"me too!!!",
"124.323.232.112",
"ISBN 332212"
};
for (String prototype : prototypes) {
test(prototype);
}
}
}
salida:
2009/11/12 -> / d / d / d / d / / d / d / / d / d
Soy una prueba -> / w ''/ w / w / w / w / w / w
¡¡¡yo también!!! -> / w / w / w / w / w !!!
124.323.232.112 -> / d / d / d. / D / d / d. / D / d / d. / D / d / d
ISBN 332212 -> / w / w / w / w / d / d / d / d / d / d
Como ya esbozado por otros, una solución general a este problema es imposible. Esta clase es aplicable solo en pocos contextos.
No es posible escribir una solución general para su problema. El problema es que cualquier generador probablemente no sabría lo que quiere verificar, por ejemplo, ¿debería permitirse también "2312/45/67"? ¿Qué hay de "2009.11.12"?
Lo que podría hacer es escribir un generador de este tipo que sea adecuado para su problema exacto, pero no será posible una solución general.
No estoy seguro de si esto es posible, al menos no sin muchas cadenas de muestra y algún algoritmo de aprendizaje.
Hay muchas expresiones regulares que coincidirían y no es posible que un algoritmo simple seleccione el correcto. Tendría que darle algunos delimitadores u otras cosas para buscar, por lo que también podría escribir el regex usted mismo.
No he encontrado nada que lo haga, pero como el dominio del problema es relativamente pequeño (te sorprendería saber cuánta gente usa los formatos de fecha más extraños), he podido escribir algún tipo de "generador de expresiones regulares de fecha" . Una vez que esté satisfecho con las pruebas unitarias, lo publicaré, en caso de que alguien necesite algo de ese tipo.
Gracias a todos los que respondieron (el chico con (. *) Excluido - las bromas son geniales, pero esta fue sssssssssoooo cojo :))
No recuerdo el nombre, pero si mi teoría de las células de computación me funciona bien, es imposible en teoría :)
No, no puede obtener una expresión regular que coincida con lo que desea de manera confiable, ya que la expresión regular no contendría información semántica sobre la entrada (es decir, debería saber que está generando una expresión regular para las fechas). Si el problema es solo con las fechas, recomendaría probar varias expresiones regulares y ver si una de ellas coincide con todas.
Suena como un problema de aprendizaje automático. Tendrá que tener más de un ejemplo a la mano (muchos más) y una indicación de si cada ejemplo se considera una coincidencia o no.
Loreto casi todo esto. Es una implementación de código abierto que utiliza las subcadenas más largas comunes para generar las expresiones regulares. Sin embargo, necesita múltiples ejemplos, por supuesto.