Expresión regular para palabras duplicadas

Soy un novato en expresiones regulares, y no puedo entender cómo escribir una sola expresión regular que "coincida" con cualquier palabra consecutiva duplicada, como:

París en la primavera.

No es que eso esté relacionado.

¿Por qué te ríes? ¿ Mis expresiones regulares son TAN malas?

¿Existe una sola expresión regular que coincida con TODAS las cadenas en negrita anteriores?

Prueba esta expresión regular:

\b(\w+)\s+\1\b

Aquí \bhay un límite de palabras y hace \1referencia a la coincidencia capturada del primer grupo.

Creo que esta expresión regular maneja más situaciones:

/(\b\S+\b)\s+\b\1\b/

Puede encontrar una buena selección de cadenas de prueba aquí: http://callumacrae.github.com/regex-tuesday/challenge1.html

Prueba esto con RE a continuación

• \ b inicio de palabra límite de palabra
• \ W + cualquier carácter de palabra
• \ 1 misma palabra ya coincide
• \ b fin de palabra

• () * Repitiendo de nuevo

  public static void main(String[] args) {
  
      String regex = "\\b(\\w+)(\\b\\W+\\b\\1\\b)*";//  "/* Write a RegEx matching repeated words here. */";
      Pattern p = Pattern.compile(regex, Pattern.CASE_INSENSITIVE/* Insert the correct Pattern flag here.*/);
  
      Scanner in = new Scanner(System.in);
  
      int numSentences = Integer.parseInt(in.nextLine());
  
      while (numSentences-- > 0) {
          String input = in.nextLine();
  
          Matcher m = p.matcher(input);
  
          // Check for subsequences of input that match the compiled pattern
          while (m.find()) {
              input = input.replaceAll(m.group(0),m.group(1));
          }
  
          // Prints the modified sentence.
          System.out.println(input);
      }
  
      in.close();
  }
  

La biblioteca PCRE ampliamente utilizada puede manejar tales situaciones (sin embargo, no logrará lo mismo con los motores de expresiones regulares compatibles con POSIX):

(\b\w+\b)\W+\1

Esta es la expresión regular que utilizo para eliminar frases duplicadas en mi bot de twitch:

(\S+\s*)\1{2,}

(\S+\s*) busca cualquier cadena de caracteres que no sea un espacio en blanco, seguido de un espacio en blanco.

\1{2,}luego busca más de 2 instancias de esa frase en la cadena para que coincida. Si hay 3 frases idénticas, coincide.

La siguiente expresión debería funcionar correctamente para encontrar cualquier número de palabras consecutivas. La coincidencia puede ser insensible a mayúsculas y minúsculas.

String regex = "\\b(\\w+)(\\s+\\1\\b)*";
Pattern p = Pattern.compile(regex, Pattern.CASE_INSENSITIVE);

Matcher m = p.matcher(input);

// Check for subsequences of input that match the compiled pattern
while (m.find()) {
     input = input.replaceAll(m.group(0), m.group(1));
}

Entrada de muestra: Adiós, adiós GooDbYe

Salida de muestra: Adiós

Explicación:

La expresión regex:

\ b: Inicio de un límite de palabras

\ w +: cualquier número de caracteres de palabra

(\ s + \ 1 \ b) *: Cualquier número de espacio seguido de una palabra que coincida con la palabra anterior y finalice el límite de la palabra. Todo envuelto en * ayuda a encontrar más de una repetición.

Agrupación:

m.group (0): Debe contener el grupo correspondiente en el caso anterior Adiós, adiós GooDbYe

m.group (1): Debe contener la primera palabra del patrón coincidente en el caso anterior Adiós

El método de reemplazo reemplazará todas las palabras coincidentes consecutivas con la primera instancia de la palabra.

No. Esa es una gramática irregular. Puede haber expresiones regulares específicas del lenguaje / motor que puede usar, pero no existe una expresión regular universal que pueda hacer eso.

Aquí hay uno que captura varias palabras varias veces:

(\b\w+\b)(\s+\1)+

Regex to Strip 2+ palabras duplicadas (palabras consecutivas / no consecutivas)

Pruebe esta expresión regular que puede capturar 2 o más palabras duplicadas y solo dejar una sola palabra. Y las palabras duplicadas ni siquiera necesitan ser consecutivas .

/\b(\w+)\b(?=.*?\b\1\b)/ig

Aquí, \bse usa para Word Boundary, ?=se usa para una búsqueda anticipada positiva y \1se usa para referencias hacia atrás.

Fuente de ejemplo

El ejemplo en Javascript: The Good Parts se puede adaptar para hacer esto:

var doubled_words = /([A-Za-z\u00C0-\u1FFF\u2800-\uFFFD]+)\s+\1(?:\s|$)/gi;

\ b usa \ w para los límites de las palabras, donde \ w es equivalente a [0-9A-Z_a-z]. Si no le importa esa limitación, la respuesta aceptada está bien.

Dado que algunos desarrolladores están llegando a esta página en busca de una solución que no solo elimine las subcadenas consecutivas duplicadas que no sean espacios en blanco, sino también las triplicadas y más, mostraré el patrón adaptado.

Patrón: /(\b\S+)(?:\s+\1\b)+/( Demostración de patrón )
Reemplazar: $1(reemplaza la coincidencia de cadena completa con el grupo de captura n. ° 1)

Este patrón coincide codiciosamente con una subcadena "completa" que no es un espacio en blanco, luego requiere una o más copias de la subcadena coincidente que puede estar delimitada por uno o más caracteres de espacio en blanco (espacio, tabulación, nueva línea, etc.).

Específicamente:

• \b Los caracteres (límite de palabras) son vitales para garantizar que las palabras parciales no coincidan.
• El segundo paréntesis es un grupo que no captura, porque esta subcadena de ancho variable no necesita ser capturada, solo emparejada / absorbida.
• el +(uno o más cuantificadores) en el grupo de no captura es más apropiado *porque *"molestará" al motor de expresiones regulares para capturar y reemplazar ocurrencias de singleton - este es un diseño de patrón derrochador.

* tenga en cuenta que si se trata de frases o cadenas de entrada con puntuación, el patrón deberá perfeccionarse aún más.

Esta expresión (inspirada en Mike, arriba) parece capturar todos los duplicados, triplicados, etc., incluidos los que están al final de la cadena, lo que la mayoría de los demás no hacen:

/(^|\s+)(\S+)(($|\s+)\2)+/g, "$1$2")

Sé que la pregunta se hace para hacer coincidir solo los duplicados , pero un triplicado son solo 2 duplicados uno al lado del otro :)

Primero, me (^|\s+)aseguro de que comience con una palabra completa, de lo contrario "filete de niño" iría a "filete de niño" (las "s" coincidirían). Luego, coincide con todas las palabras completas ( (\b\S+\b)), seguidas de un final de cadena ( $) o varios espacios ( \s+), el conjunto se repite más de una vez.

Lo probé así y funcionó bien:

var s = "here here here     here is ahi-ahi ahi-ahi ahi-ahi joe's joe's joe's joe's joe's the result result     result";
print( s.replace( /(\b\S+\b)(($|\s+)\1)+/g, "$1"))         
--> here is ahi-ahi joe's the result

Use esto en caso de que desee una verificación que no distinga entre mayúsculas y minúsculas para detectar palabras duplicadas.

(?i)\\b(\\w+)\\s+\\1\\b