Expression régulière pour les mots consécutifs 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 “correspond” à des mots consécutifs en double tels que:

Paris au spring.

Pas que ça soit lié.

Pourquoi ris-tu? Mes expressions régulières sont-elles si mauvaises ??

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

Essayez cette expression régulière:

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

Ici, \b est une limite de mot et \1 ré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

La bibliothèque PCRE, largement utilisée, peut gérer de telles situations (vous n’obtiendrez pas la même chose avec les moteurs regex compatibles POSIX):

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

Non, c’est une grammaire irrégulière. Vous pouvez utiliser des expressions régulières spécifiques à un moteur / langage, mais aucune expression régulière universelle ne peut le faire.

Essayez ceci avec ci-dessous RE

  • \ b début du mot limite de mot
  • \ W + n’importe quel caractère de mot
  • \ 1 même mot correspond déjà
  • \ b fin du mot
  • () * Répétant à nouveau

     public static void main(Ssortingng[] args) { Ssortingng regex = "\\b(\\w+)(\\b\\W+\\b\\1\\b)*";// "/* Write a RegEx matching repeated words here. */"; Pattern p = Pattern.comstack(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) { Ssortingng input = in.nextLine(); Matcher m = p.matcher(input); // Check for subsequences of input that match the comstackd pattern while (m.find()) { input = input.replaceAll(m.group(0),m.group(1)); } // Prints the modified sentence. System.out.println(input); } in.close(); } 

L’exemple en Javascript: Les bonnes parties peuvent être adaptées pour ce faire:

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

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

C’est la regex que j’utilise pour supprimer les phrases en double dans mon bot twitch:

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

(\S+\s*) recherche toutes les chaînes de caractères qui ne sont pas des espaces, suivies des espaces.

\1{2,} recherche ensuite plus de 2 instances de cette phrase dans la chaîne à rechercher. S’il y a 3 phrases identiques, elles correspondent.

Cette expression (inspirée de Mike ci-dessus) semble attraper tous les doublons, sortingples, 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 sais que la question a été posée pour correspondre uniquement aux doublons , mais un sortingplicata est juste deux copies l’une à côté de l’autre 🙂

Premièrement, je mets (^|\s+) pour s’assurer qu’il commence par un mot entier, sinon “le steak de l’enfant” irait à “child’steak” (le “s” correspondrait). Ensuite, il correspond à tous les mots entiers ( (\b\S+\b) ), suivis d’une fin de chaîne ( $ ) ou d’un nombre d’espaces ( \s+ ), le tout répété plus d’une 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 

Comme certains développeurs viennent sur cette page à la recherche d’une solution qui non seulement élimine les sous-chaînes consécutives sans espace blanc, mais en sortingple et au-delà, je montrerai le modèle adapté.

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

Ce modèle correspond avidement à une sous-chaîne “entière” sans espace, puis nécessite une ou plusieurs copies de la sous-chaîne correspondante qui peuvent être délimitées par un ou plusieurs caractères d’espacement (espace, tabulation, nouvelle ligne, etc.).

Plus précisément:

  • \b (limite de mot) sont essentiels pour garantir que les mots partiels ne correspondent pas.
  • La seconde parenthèse est un groupe non capturé, car il n’est pas nécessaire de capturer cette sous-chaîne à largeur variable – uniquement pour correspondre / absorber.
  • le + (un ou plusieurs quantificateurs) sur le groupe non capturé est plus approprié que * car * va “déranger” le moteur d’expression régulière pour capturer et remplacer les occurrences de singleton – ceci est une conception de modèle inutile.

* Notez que si vous traitez des phrases ou des chaînes d’entrée avec des signes de ponctuation, alors le motif devra être affiné.

Utilisez cette option au cas où vous souhaiteriez vérifier la casse des mots en double.

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

En voici un qui attrape plusieurs mots plusieurs fois:

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

Regex to Ssortingp 2+ mots dupliqués (mots consécutifs / non consécutifs)

Essayez cette regex qui peut intercepter deux mots en double ou plus et ne laisser qu’un mot. Et les mots en double ne doivent même pas être consécutifs .

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

Ici, \b est utilisé pour Word Boundary,? ?= Est utilisé pour le lookahead positif et \1 est utilisé pour le back-référencement.

Exemple de source