Espressione regolare per trovare e rimuovere parole duplicate

Question

Utilizzando le espressioni regolari in C#, esiste un modo per trovare e rimuovere parole o simboli duplicati in una stringa contenente una varietà di parole e simboli?

Es.

stringa iniziale di parole:

". Mi piace l'ambiente L'ambiente è buono"

stringa desiderata:

"Mi piace l'ambiente è buono"

duplicati rimossi: "il", "ambiente", ""

Answer 1

Come detto da altri, è necessario più di una regex per tenere traccia di parole:

var words = new HashSet<string>(); 
string text = "I like the environment. The environment is good."; 
text = Regex.Replace(text, "\\w+", m => 
        words.Add(m.Value.ToUpperInvariant()) 
         ? m.Value 
         : String.Empty); 

Answer 2

Bene, Jeff mi ha mostrato come utilizzare la magia delle backreferenze in-expression e il modificatore globale per far sì che questo accada, quindi la mia risposta originale non è operativa. Dovresti votare tutti per la risposta di Jeff. Tuttavia, per i posteri ti faccio notare che c'è un piccolo problema di sensibilità motore regex difficile in questo, e se si stesse usando regex Perl al gusto, si avrebbe bisogno di fare questo:

\b(\S+)\b(?=.*\b\1\b.*) 

invece di risposta di Jeff, poiché la regex di C# acquisirà effettivamente \b in \1 ma PCRE no.

Answer 3

Dai un'occhiata alla backreference:
http://msdn.microsoft.com/en-us/library/thwdfzxy(VS.71).aspx

Questa una regex che troverà le parole raddoppiati. Ma corrisponderà solo una parola per partita. Quindi devi usarlo più di una volta.

Ovviamente questa non è la soluzione migliore (vedere altre risposte, che propongono di non utilizzare una regex affatto). Ma hai chiesto una regex - eccone uno. Forse solo l'idea ti aiuta ...

Answer 4

Regex non è adatto a tutto. Qualcosa come il tuo problema rientra in quella categoria. Ti consiglierei di usare un parser invece.

Answer 5

Come altri hanno sottolineato, questo è fattibile con backreferences. Vedi http://msdn.microsoft.com/nb-no/library/thwdfzxy(en-us).aspx per i dettagli su come utilizzare i riferimenti remoti in .Net.

Il tuo problema particolare per rimuovere la punteggiatura e lo rende un po 'più complicato, ma credo che il codice in questo senso (gli spazi non è significativo in quanto regex) dovrebbe fare il trucco:

(\b\w+(?:\s+\w+)*)\s+\1 

ho non è stata testata la regex, ma dovrebbe corrispondere a una o più parole separate da spazi bianchi che vengono ripetute. Dovrai aggiungere un po 'di logica per consentire la punteggiatura e così via.

Answer 6

Non sarà in grado di utilizzare le espressioni regolari per questo problema, in quanto espressione regolare corrisponde solo linguaggi regolari.Lo schema a cui stai cercando di corrispondere è sensibile al contesto e, quindi, non "regolare".

Fortunatamente, è abbastanza facile scrivere un parser. Dai un'occhiata al codice di Per Erik Stendahl.

Answer 7

Le espressioni regolari sarebbero una scelta scadente di "strumenti" per risolvere questo problema. Forse il seguente potrebbe funzionare:

HashSet<string> corpus = new HashSet<string>(); 
char[] split = new char[] { ' ', '\t', '\r', '\n', '.', ';', ',', ':', ... }; 

foreach (string line in inputLines) 
{ 
    string[] parts = line.Split(split, StringSplitOptions.RemoveEmptyEntries); 
    foreach (string part in parts) 
    { 
     corpus.Add(part.ToUpperInvariant()); 
    } 
} 

// 'corpus' now contains all of the unique tokens 

EDIT: Questo sono io fare un grande presupposto che sei "lexing" per una sorta di analisi come la ricerca.

Answer 8

Questo sembra funzionare per me

(\b\S+\b)(?=.*\1) 

Partite in questo modo

 
apple apple orange 
orange red bluegreen orange green blue 
piratesninjas cowboys ninjas pirates 

Answer 9

Some people, when confronted with a problem, think “I know, I'll use regular expressions.” Now they have two problems.

Vedi When not to use Regex in C# (or Java, C++ etc)

Ovviamente l'uso di un'espressione regolare per suddividere la stringa in parole può essere un primo passo utile, tuttavia String.Split() è chiaro e fa in modo che tutto funzioni.