Espressione regolare per parole duplicate

Sono un principiante delle espressioni regolari e non riesco a capire come scrivere una singola espressione regolare che "corrisponda" a qualsiasi parola consecutiva duplicata come:

Parigi la la primavera.

Non che sia correlato.

Perché stai ridendo? Le mie espressioni regolari sono così cattive?

Esiste una singola espressione regolare che corrisponderà a TUTTE le stringhe in grassetto sopra?

Prova questa espressione regolare:

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

Ecco \bun confine di parola e fa \1riferimento alla corrispondenza acquisita del primo gruppo.

Credo che questa regex gestisca più situazioni:

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

Una buona selezione di stringhe di test può essere trovata qui: http://callumacrae.github.com/regex-tuesday/challenge1.html

Prova questo con sotto RE

• \ b inizio del confine parola parola
• \ W + qualsiasi carattere della parola
• \ 1 stessa parola già trovata
• \ b fine della parola

• () * Ripetendo di nuovo

  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 libreria PCRE ampiamente utilizzata può gestire tali situazioni (non otterrai lo stesso con i motori regex conformi a POSIX, però):

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

Questa è la regex che uso per rimuovere le frasi duplicate nel mio twitch bot:

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

(\S+\s*) cerca qualsiasi stringa di caratteri che non sia uno spazio bianco, seguito da uno spazio vuoto.

\1{2,}quindi cerca più di 2 istanze di quella frase nella stringa da abbinare. Se ci sono 3 frasi identiche, corrisponde.

L'espressione seguente dovrebbe funzionare correttamente per trovare un numero qualsiasi di parole consecutive. La corrispondenza può essere case insensitive.

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

Input di esempio: addio addio GooDbYe

Output di esempio: arrivederci

Spiegazione:

L'espressione regex:

\ b: Inizio di un confine di parola

\ w +: qualsiasi numero di caratteri alfanumerici

(\ s + \ 1 \ b) *: qualsiasi numero di spazio seguito da una parola che corrisponde alla parola precedente e termina il confine della parola. L'intera cosa racchiusa in * aiuta a trovare più di una ripetizione.

Raggruppamento:

m.group (0): conterrà il gruppo abbinato nel caso precedente Goodbye goodbye GooDbYe

m.group (1): conterrà la prima parola dello schema corrispondente nel caso precedente Goodbye

Il metodo di sostituzione sostituisce tutte le parole corrispondenti consecutive con la prima istanza della parola.

No. Questa è una grammatica irregolare. Potrebbero esserci espressioni regolari specifiche del motore / della lingua che puoi usare, ma non esiste un'espressione regolare universale che possa farlo.

Eccone uno che cattura più parole più volte:

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

Regex per eliminare 2 o più parole duplicate (parole consecutive / non consecutive)

Prova questa regex che può catturare 2 o più parole duplicate e lasciare solo una singola parola. E le parole duplicate non devono nemmeno essere consecutive .

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

Qui, \bviene utilizzato per il confine di parole, ?=viene utilizzato per un lookahead positivo e \1viene utilizzato per i riferimenti all'indietro.

Fonte di esempio

L'esempio in Javascript: The Good Parts può essere adattato per fare questo:

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

\ b usa \ w per i confini delle parole, dove \ w è equivalente a [0-9A-Z_a-z]. Se non ti dispiace questa limitazione, la risposta accettata va bene.

Poiché alcuni sviluppatori stanno arrivando su questa pagina alla ricerca di una soluzione che non solo elimini le sottostringhe duplicate consecutive non di spazi bianchi, ma anche triplicate e oltre, mostrerò il modello adattato.

Pattern: /(\b\S+)(?:\s+\1\b)+/( Pattern Demo )
Replace: $1(sostituisce la corrispondenza di stringa intera con il gruppo di cattura n. 1)

Questo modello corrisponde avidamente a una sottostringa "intera" senza spazi, quindi richiede una o più copie della sottostringa corrispondente che può essere delimitata da uno o più caratteri di spazio (spazio, tabulazione, nuova riga, ecc.).

In particolare:

• \b I caratteri (confine di parola) sono fondamentali per garantire che le parole parziali non siano abbinate.
• La seconda parentesi è un gruppo non di cattura, perché questa sottostringa di larghezza variabile non ha bisogno di essere catturata - solo abbinata / assorbita.
• il +(uno o più quantificatori) sul gruppo che non cattura è più appropriato che *perché *"infastidirà" il motore di regex per catturare e sostituire le occorrenze singleton - questo è uno spreco di design.

* nota se hai a che fare con frasi o stringhe di input con punteggiatura, il modello dovrà essere ulteriormente perfezionato.

Questa espressione (ispirata da Mike, sopra) sembra catturare tutti i duplicati, i triplicati, ecc., Compresi quelli alla fine della stringa, che la maggior parte degli altri non fa:

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

Conosco la domanda posta per abbinare solo i duplicati , ma un triplo è solo 2 duplicati uno accanto all'altro :)

Per prima cosa, mi (^|\s+)assicuro che inizi con una parola intera, altrimenti "bistecca di bambino" andrebbe a "bistecca di bambino" (le "s" corrisponderebbero). Quindi, trova tutte le parole complete ( (\b\S+\b)), seguite da una fine di stringa ( $) o da un numero di spazi ( \s+), il tutto ripetuto più di una volta.

L'ho provato in questo modo e ha funzionato bene:

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

Usalo nel caso in cui desideri controllare la presenza di parole duplicate senza distinzione tra maiuscole e minuscole.

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