Expression régulière pour les mots en double

Je suis un débutant en expression régulière, et je n'arrive pas à comprendre comment écrire une seule expression régulière qui "correspondrait" à des mots consécutifs en double tels que:

Paris dans le le printemps.

Non pas que cela soit lié.

Pourquoi ris-tu? Sont mes mes expressions régulières mauvais ??

Existe-t-il une seule expression régulière qui correspond à TOUTES les chaînes en gras ci-dessus?

Essayez cette expression régulière:

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

Voici \bune limite de mot et fait \1référence à la correspondance capturée du premier groupe.

Je crois que cette regex gère plus de situations:

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

Une bonne sélection de chaînes de test peut être trouvée ici: http://callumacrae.github.com/regex-tuesday/challenge1.html

Essayez ceci avec ci-dessous RE

• \ b début du mot limite du mot
• \ W + n'importe quel caractère de mot
• \ 1 même mot correspondant déjà
• \ b fin de mot

• () * Répéter à nouveau

  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 bibliothèque PCRE largement utilisée peut gérer de telles situations (vous n'obtiendrez pas la même chose avec les moteurs de regex compatibles POSIX, cependant):

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

Voici le regex que j'utilise pour supprimer les phrases en double dans mon bot twitch:

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

(\S+\s*) recherche toute chaîne de caractères qui n'est pas un espace, suivie d'un espace.

\1{2,}recherche ensuite plus de 2 instances de cette phrase dans la chaîne pour correspondre. S'il y a 3 phrases identiques, cela correspond.

L'expression ci-dessous devrait fonctionner correctement pour trouver n'importe quel nombre de mots consécutifs. La correspondance peut être insensible à la casse.

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

Exemple d'entrée: au revoir au revoir GooDbYe

Exemple de sortie: au revoir

Explication:

L'expression regex:

\ b: Début d'une limite de mot

\ w +: N'importe quel nombre de caractères de mot

(\ s + \ 1 \ b) *: N'importe quel nombre d'espaces suivi d'un mot qui correspond au mot précédent et termine la limite du mot. Une chose entière enveloppée dans * aide à trouver plus d'une répétition.

Regroupement:

m.group (0): Contiendra le groupe correspondant dans le cas ci-dessus Au revoir au revoir GooDbYe

m.group (1): Contiendra le premier mot du motif correspondant dans le cas ci-dessus Au revoir

La méthode Replace remplacera tous les mots concordants consécutifs par la première instance du mot.

Non. C'est une grammaire irrégulière. Il peut y avoir des expressions régulières spécifiques au moteur / au langage que vous pouvez utiliser, mais aucune expression régulière universelle ne peut le faire.

En voici un qui capture plusieurs mots plusieurs fois:

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

Regex pour supprimer plus de 2 mots en double (mots consécutifs / non consécutifs)

Essayez cette expression régulière qui peut attraper 2 mots ou plus en double et ne laisser qu'un seul mot. Et les mots en double n'ont même pas besoin d'être consécutifs .

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

Ici, \best utilisé pour Word Boundary, ?=est utilisé pour une anticipation positive et \1est utilisé pour le back-référencement.

Exemple de source

L'exemple en Javascript: The Good Parts peut être adapté pour cela:

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

\ b utilise \ w pour les limites des mots, où \ w équivaut à [0-9A-Z_a-z]. Si cela ne vous dérange pas, la réponse acceptée est bonne.

Étant donné que certains développeurs viennent sur cette page à la recherche d'une solution qui élimine non seulement les sous-chaînes consécutives en double sans espace, mais également les triples et au-delà, je vais montrer le modèle adapté.

Pattern: /(\b\S+)(?:\s+\1\b)+/( Pattern Demo )
Replace: $1(remplace la correspondance de chaîne complète par le groupe de capture n ° 1)

Ce modèle correspond avec gourmandise à une sous-chaîne "entière" sans espace, puis nécessite une ou plusieurs copies de la sous-chaîne correspondante qui peut être délimitée par un ou plusieurs caractères d'espacement (espace, tabulation, nouvelle ligne, etc.).

Plus précisément:

• \b Les caractères (limite du mot) sont essentiels pour garantir que les mots partiels ne correspondent pas.
• La deuxième parenthèse est un groupe non capturant, car cette sous-chaîne de largeur variable n'a pas besoin d'être capturée - seulement mise en correspondance / absorbée.
• le +(un ou plusieurs quantificateurs) sur le groupe non capturant est plus approprié que *parce *qu'il "dérangera" le moteur d'expression régulière pour capturer et remplacer les occurrences singleton - c'est une conception de modèle inutile.

* notez que si vous avez affaire à des phrases ou à des chaînes d'entrée avec ponctuation, le modèle devra être affiné davantage.

Cette expression (inspirée de Mike, ci-dessus) semble attraper tous les doublons, triples, etc., y compris ceux à la fin de la chaîne, ce que la plupart des autres ne font pas:

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

Je connais la question posée pour faire correspondre uniquement les doublons , mais un triple n'est que 2 doublons l'un à côté de l'autre :)

D'abord, je mets (^|\s+)pour m'assurer qu'il commence par un mot complet, sinon «steak d'enfant» irait à «steak d'enfant» (les «s» correspondraient). Ensuite, il correspond à tous les mots complets ( (\b\S+\b)), suivis d'une fin de chaîne ( $) ou d'un certain nombre d'espaces ( \s+), le tout répété plusieurs fois.

Je l'ai essayé comme ça et ça a bien fonctionné:

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

Utilisez cette option au cas où vous souhaiteriez une vérification insensible à la casse pour les mots en double.

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