स्ट्रिंग एक सूची <string>

Question

मुझे लगता है मैं इस तरह अनदेखा करना चाहते शब्दों की एक सूची है का उपयोग कर की जगह:

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

एक दिया स्ट्रिंग के लिए, "14th Avenue North" कहते हैं कि मैं "उत्तर" भाग को दूर करने में सक्षम होना चाहते, इसलिए मूल रूप से एक फ़ंक्शन जो "14th Avenue " को कॉल करने पर वापस आ जाएगा।

मुझे लगता है कि मुझे LINQ, regex और प्रतिस्थापन के मिश्रण के साथ कुछ करने में सक्षम होना चाहिए, लेकिन मैं इसे समझ नहीं सकता।

बड़ी तस्वीर है, मैं एक एड्रेस मिलान एल्गोरिदम लिखने की कोशिश कर रहा हूं। मैं समानता का मूल्यांकन करने के लिए लेवेनशेटिन एल्गोरिदम का उपयोग करने से पहले "स्ट्रीट", "नॉर्थ", "बॉलवर्ड" इत्यादि जैसे शब्दों को फ़िल्टर करना चाहता हूं।

Answer 1

इस बारे में कैसे:

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

या नेट 3 के लिए:

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

नोट है कि इस विधि अलग-अलग शब्दों में स्ट्रिंग विभाजन तो यह केवल संपूर्ण शब्दों को निकाल देता है। इस तरह यह Northampton Way #123 जैसे पते के साथ ठीक से काम करेगा कि string.Replace संभाल नहीं सकता है।

Answer 2

कुछ इस तरह काम करना चाहिए:

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

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

के लिए अपडेट किया गया क्या पाश के लिए एक सरल के साथ गलत क्या है?

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

Answer 5

यदि आपके पास कोई सूची है, तो मुझे लगता है कि आपको सभी वस्तुओं को छूना होगा। आप अपने सभी अनदेखा कीवर्ड के साथ एक विशाल RegEx बना सकते हैं और String.Empty पर प्रतिस्थापित कर सकते हैं।

यहाँ एक शुरुआत है:

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

आप एक ही रेगुलर एक्सप्रेशन से है, तो शब्दों की उपेक्षा के लिए, आप एक ही प्रत्येक वाक्यांश आप कलन विधि को पारित करने के लिए चाहते हैं के लिए की जगह कर सकते हैं।

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

क्यों नहीं इसे आसान रखें?

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

सिर्फ हालांकि तार पाश और एक समय में एक की जगह अगर यह आपकी उदाहरण के रूप में एक छोटी स्ट्रिंग है, आप कर सकते हैं। यदि यह एक बड़ी स्ट्रिंग, कि धीमी गति से किया जाएगा है

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

: आप कल्पना प्राप्त करना चाहते हैं तो आप यह करने के लिए LINQ सकल विधि का उपयोग कर सकते हैं। इसके बजाय आप स्ट्रिंग के माध्यम से एक ही रन में सभी तारों को प्रतिस्थापित कर सकते हैं, जो बहुत तेज है। मैंने this answer में इसके लिए एक विधि बनाई है।

Answer 9

आप जानते हैं कि शब्द की सूची केवल अक्षर हैं जो एक नियमित अभिव्यक्ति के अंदर से बचने की जरूरत नहीं है तो आप ऐसा कर सकते हैं शामिल हैं:

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

परिणाम:

 
14th Avenue 

अगर वहाँ विशेष कर रहे हैं पात्रों को आपको दो चीजों को ठीक करने की आवश्यकता होगी:

• अनदेखा सूची के प्रत्येक तत्व पर Regex.Escape का उपयोग करें।
• शब्द-सीमा \b एक सफेद जगह से मेल नहीं खाती है जिसके बाद एक प्रतीक या इसके विपरीत होता है। इसके बजाय आपको व्हाट्स स्पेस (या विराम चिह्न जैसे अन्य अलग-अलग वर्णों) की जांच करने की आवश्यकता हो सकती है।

यहाँ इन दोनों समस्याओं को ठीक करने का तरीका देखें:

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

Answer 10

आप इस का उपयोग करते हुए और अभिव्यक्ति यदि आप चाहें तो कर सकते हैं, लेकिन यह एक सकल का उपयोग करने से चारों ओर इसे चालू करना आसान है। मैं ऐसा कुछ करूंगा:

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

Answer 11

LINQ यह आसान और पठनीय बनाता है। इसके लिए सामान्यीकृत डेटा की आवश्यकता होती है, विशेष रूप से यह केस-संवेदी है।

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