Expressão regular para palavras duplicadas

Sou um novato em expressões regulares e não consigo descobrir como escrever uma única expressão regular que "corresponda" a quaisquer palavras consecutivas duplicadas, como:

Paris em a da primavera.

Não que isso esteja relacionado.

Por que você está rindo? São minhas minhas expressões regulares que ruim ??

Existe uma única expressão regular que corresponderá a TODAS as strings em negrito acima?

Experimente esta expressão regular:

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

Aqui \bestá um limite de palavra e faz \1referência à correspondência capturada do primeiro grupo.

Acredito que esta regex lida com mais situações:

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

Uma boa seleção de strings de teste pode ser encontrada aqui: http://callumacrae.github.com/regex-tuesday/challenge1.html

Tente isso com RE abaixo

• \ b início da palavra limite da palavra
• \ W + qualquer caractere de palavra
• \ 1 mesma palavra já combinada
• \ b fim da palavra

• () * Repetindo novamente

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

A biblioteca PCRE amplamente usada pode lidar com tais situações (você não conseguirá o mesmo com motores regex compatíveis com POSIX, no entanto):

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

Este é o regex que uso para remover frases duplicadas em meu bot do twitch:

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

(\S+\s*) procura por qualquer sequência de caracteres que não seja um espaço em branco, seguido de um espaço em branco.

\1{2,}em seguida, procura mais de 2 ocorrências dessa frase na string para corresponder. Se houver 3 frases idênticas, ela corresponde.

A expressão abaixo deve funcionar corretamente para encontrar qualquer número de palavras consecutivas. A correspondência pode não fazer distinção entre maiúsculas e 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));
}

Amostra de entrada: Goodbye goodbye GooDbYe

Saída de amostra: adeus

Explicação:

A expressão regex:

\ b: Início de um limite de palavra

\ w +: qualquer número de caracteres de palavras

(\ s + \ 1 \ b) *: Qualquer número de espaço seguido pela palavra que corresponda à palavra anterior e termine o limite da palavra. Tudo envolvido em * ajuda a encontrar mais de uma repetição.

Agrupamento:

m.group (0): Deve conter o grupo combinado no caso acima Goodbye goodbye GooDbYe

m.group (1): Deve conter a primeira palavra do padrão correspondente no caso acima. Adeus

O método Replace deve substituir todas as palavras consecutivas correspondidas pela primeira instância da palavra.

Não. Essa é uma gramática irregular. Pode haver expressões regulares específicas do mecanismo / linguagem que você pode usar, mas não há nenhuma expressão regular universal que possa fazer isso.

Aqui está um que captura várias palavras várias vezes:

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

Regex para remover 2+ palavras duplicadas (palavras consecutivas / não consecutivas)

Experimente esta regex que pode capturar 2 ou mais palavras duplicadas e deixar apenas uma única palavra. E as palavras duplicadas nem precisam ser consecutivas .

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

Aqui, \bé usado para Limite de palavras, ?=é usado para antecipação positiva e \1é usado para referência inversa.

Fonte de exemplo

O exemplo em Javascript: As boas partes podem ser adaptadas para fazer isso:

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

\ b usa \ w para limites de palavras, onde \ w é equivalente a [0-9A-Z_a-z]. Se você não se importa com essa limitação, a resposta aceita está bem.

Como alguns desenvolvedores estão vindo para esta página em busca de uma solução que não apenas elimine substrings duplicados consecutivos sem espaço em branco, mas triplicados e além, vou mostrar o padrão adaptado.

Padrão: /(\b\S+)(?:\s+\1\b)+/( Demonstração de padrão )
Substituir: $1(substitui a correspondência de string inteira pelo grupo de captura # 1)

Este padrão corresponde avidamente a uma substring "inteira" sem espaço em branco, então requer uma ou mais cópias da substring correspondida que pode ser delimitada por um ou mais caracteres de espaço em branco (espaço, tabulação, nova linha, etc).

Especificamente:

• \b (limite de palavra) caracteres são vitais para garantir que palavras parciais não sejam correspondidas.
• O segundo parênteses é um grupo de não captura, porque essa substring de largura variável não precisa ser capturada - apenas correspondida / absorvida.
• o +(um ou mais quantificadores) no grupo de não captura é mais apropriado do que *porque *"incomodará" o mecanismo de regex para capturar e substituir ocorrências de singleton - isso é um desperdício de design de padrão.

* observe que se você estiver lidando com sentenças ou strings de entrada com pontuação, o padrão precisará ser mais refinado.

Esta expressão (inspirada em Mike, acima) parece capturar todas as duplicatas, triplicatas, etc, incluindo aquelas no final da string, o que a maioria das outras não:

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

Eu sei que a pergunta feita para coincidir com duplicatas apenas, mas um triplicado é apenas 2 duplicatas lado a lado :)

Primeiro, eu coloco (^|\s+)para ter certeza de que começa com uma palavra completa, caso contrário, "bife de criança" iria para "bife de criança" (o "s" iria corresponder). Em seguida, ele corresponde a todas as palavras completas ( (\b\S+\b)), seguidas por um final de string ( $) ou um número de espaços ( \s+), o todo repetido mais de uma vez.

Eu tentei assim e funcionou bem:

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 isto caso você queira uma verificação sem distinção entre maiúsculas e minúsculas para palavras duplicadas.

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