stringa di sostituire con un elenco <string>

Question

Ho una lista di parole che voglio ignorare come questo:

public List<String> ignoreList = new List<String>() 
     { 
      "North", 
      "South", 
      "East", 
      "West" 
     }; 

Per una data stringa, dire "14th Avenue North" voglio essere in grado di rimuovere la parte "Nord", quindi fondamentalmente una funzione che restituirebbe "14th Avenue " quando chiamato.

Mi sembra che ci sia qualcosa che dovrei essere in grado di fare con un mix di LINQ, regex e sostituzioni, ma non riesco a capirlo.

L'immagine più grande è, sto cercando di scrivere un algoritmo di corrispondenza degli indirizzi. Voglio filtrare parole come "Street", "North", "Boulevard", ecc. Prima di utilizzare l'algoritmo Levenshtein per valutare la similarità.

Answer 1

ne dite di questo:

string.Join(" ", text.Split().Where(w => !ignoreList.Contains(w))); 

o per .Net 3:

string.Join(" ", text.Split().Where(w => !ignoreList.Contains(w)).ToArray()); 

Nota che questo metodo divide la stringa in singole parole in modo che rimuove solo parole intere. In questo modo funzionerà correttamente con indirizzi come Northampton Way #123 che string.Replace non può gestire.

Answer 2

Qualcosa del genere dovrebbe funzionare:

string FilterAllValuesFromIgnoreList(string someStringToFilter) 
{ 
    return ignoreList.Aggregate(someStringToFilter, (str, filter)=>str.Replace(filter, "")); 
} 

Answer 3

public static string Trim(string text) 
{ 
    var rv = text; 
    foreach (var ignore in ignoreList) 
     rv = rv.Replace(ignore, ""); 
    return rv; 
} 

aggiornato per Gabe

---

public static string Trim(string text) 
{ 
    var rv = ""; 
    var words = text.Split(" "); 
    foreach (var word in words) 
    { 
     var present = false; 
     foreach (var ignore in ignoreList) 
     if (word == ignore) 
      present = true; 
     if (!present) 
     rv += word; 
    } 
    return rv; 
} 

Answer 4

Cosa c'è di sbagliato con un semplice ciclo for?

string street = "14th Avenue North"; 
foreach (string word in ignoreList) 
{ 
    street = street.Replace(word, string.Empty); 
} 

Answer 5

Se si dispone di un elenco, penso che si dovrà toccare tutti gli elementi. Puoi creare un imponente RegEx con tutte le parole chiave da ignorare e sostituirlo con String.Empty.

Ecco un inizio:

(^|\s+)(North|South|East|West){1,2}(ern)?(\s+|$) 

Se si dispone di un unico RegEx per ignorare le parole, si può fare una sola sostituzione per ogni frase che si desidera passare al algoritmo.

Answer 6

Regex r = new Regex(string.Join("|", ignoreList.Select(s => Regex.Escape(s)).ToArray())); 
string s = "14th Avenue North"; 
s = r.Replace(s, string.Empty); 

Answer 7

Perché non juts Mantenerlo semplice?

public static string Trim(string text) 
{ 
    var rv = text.trim(); 
    foreach (var ignore in ignoreList) { 
     if(tv.EndsWith(ignore) { 
     rv = rv.Replace(ignore, string.Empty); 
    } 
    } 
    return rv; 
} 

Answer 8

Se si tratta di una stringa breve come nell'esempio, è possibile eseguire il ciclo delle stringhe e sostituirle una alla volta. Se si desidera ottenere fantasia è possibile utilizzare il metodo LINQ aggregato per farlo:

address = ignoreList.Aggregate(address, (a, s) => a.Replace(s, String.Empty)); 

Se è una stringa di grandi dimensioni, che sarebbe lento. Invece è possibile sostituire tutte le stringhe in un'unica esecuzione attraverso la stringa, che è molto più veloce. Ho fatto un metodo per questo in this answer.

Answer 9

Se si sa che l'elenco di parola contiene solo i caratteri che non necessitano di fuga all'interno di un'espressione regolare, allora si può fare questo:

string s = "14th Avenue North"; 
Regex regex = new Regex(string.Format(@"\b({0})\b", 
         string.Join("|", ignoreList.ToArray()))); 
s = regex.Replace(s, ""); 

Risultato:

 
14th Avenue 

Se ci sono speciali caratteri dovrai correggere due cose:

• Utilizzare Regex.Escape su ogni elemento dell'elenco ignorato.
• La parola-confine \b non corrisponde a uno spazio seguito da un simbolo o viceversa. Potrebbe essere necessario verificare gli spazi bianchi (o altri caratteri di separazione come la punteggiatura) usando invece asserzioni di lookaround.

Ecco come risolvere questi due problemi:

Regex regex = new Regex(string.Format(@"(?<= |^)({0})(?= |$)", 
    string.Join("|", ignoreList.Select(x => Regex.Escape(x)).ToArray()))); 

Answer 10

È possibile eseguire questa operazione utilizzando e l'espressione, se volete, ma è più facile da girare intorno rispetto all'utilizzo di un aggregato. Vorrei fare qualcosa di simile:

string s = "14th Avenue North" 
ignoreList.ForEach(i => s = s.Replace(i, "")); 
//result is "14th Avenue " 

Answer 11

LINQ rende questo facile e leggibile. Ciò richiede tuttavia dati normalizzati, in particolare in quanto è sensibile alla distinzione tra maiuscole e minuscole.

List<string> ignoreList = new List<string>() 
{ 
    "North", 
    "South", 
    "East", 
    "West" 
};  

string s = "123 West 5th St" 
     .Split(' ') // Separate the words to an array 
     .ToList() // Convert array to TList<> 
     .Except(ignoreList) // Remove ignored keywords 
     .Aggregate((s1, s2) => s1 + " " + s2); // Reconstruct the string