उनके वैध संस्करण (टीआर) की तरह साथ अमान्य वर्ण की एक सूची बदलें

Question

मैं कुछ इस तरह सपना देखा .trReplace क्या करने की जरूरत:

str = str.trReplace("áéíüñ","aeiu&"); 

यह इस स्ट्रिंग बदलना चाहिए:

a stríng with inválid charactérs 

रहे हैं:

a string with invalid characters 

मेरे वर्तमान विचार हैं:

str = str.Replace("á","a").Replace("é","e").Replace("í","ï"... 

और:

sb = new StringBuilder(str) 
sb.Replace("á","a"). 
sb.Replace("é","e") 
sb.Replace("í","ï"... 

लेकिन मुझे नहीं लगता कि वे लंबे तार के लिए कुशल हैं है।

Answer 1

रिचर्ड का अच्छा जवाब है, लेकिन प्रदर्शन लंबे तारों पर थोड़ा पीड़ित हो सकता है (प्रश्न में दिखाए गए अनुसार सीधे स्ट्रिंग प्रतिस्थापन की तुलना में लगभग 25% धीमी)। मुझे थोड़ा और आगे देखने के लिए पूरा महसूस हुआ। वहाँ वास्तव में नीचे के रूप में कब्जा कर लिया कई अच्छे संबंधित जवाब पहले से ही StackOverflow पर हैं:

Fastest way to remove chars from string

C# Stripping/converting one or more characters

भी CodeProject पर एक अच्छा लेख विभिन्न विकल्पों पर चर्चा नहीं है।

http://www.codeproject.com/KB/string/fastestcscaseinsstringrep.aspx

व्याख्या करने के लिए क्यों रिचर्ड्स जवाब में प्रदान की जाती समारोह हो जाता है लंबे समय तक तार के साथ धीमी तथ्य यह है कि प्रतिस्थापन एक समय में एक चरित्र हो रही हैं की वजह से है; इस प्रकार यदि आपके पास गैर-मैप किए गए वर्णों के बड़े अनुक्रम हैं, तो आप स्ट्रिंग को एक साथ जोड़ते समय अतिरिक्त चक्र बर्बाद कर रहे हैं।

private static readonly Char[] ReplacementChars = new[] { 'á', 'é', 'í', 'ü', 'ñ' }; 
private static readonly Dictionary<Char, Char> ReplacementMappings = new Dictionary<Char, Char> 
                   { 
                   { 'á', 'a'}, 
                   { 'é', 'e'}, 
                   { 'í', 'i'}, 
                   { 'ü', 'u'}, 
                   { 'ñ', '&'} 
                   }; 

private static string Translate(String source) 
{ 
    var startIndex = 0; 
    var currentIndex = 0; 
    var result = new StringBuilder(source.Length); 

    while ((currentIndex = source.IndexOfAny(ReplacementChars, startIndex)) != -1) 
    { 
    result.Append(source.Substring(startIndex, currentIndex - startIndex)); 
    result.Append(ReplacementMappings[source[currentIndex]]); 

    startIndex = currentIndex + 1; 
    } 

    if (startIndex == 0) 
    return source; 

    result.Append(source.Substring(startIndex)); 

    return result.ToString(); 
} 

नोट नहीं सभी किनारे मामलों परीक्षण किया गया है: इस तरह के रूप में, यदि आप CodePlex अनुच्छेद से कुछ बिंदुओं ले जाना चाहते हैं तो आप ऐसा दिखता है जैसे रिचर्ड्स जवाब का एक थोड़ा संशोधित संस्करण के साथ खत्म।

नोट प्रतिस्थापन मैप्स के साथ प्रतिस्थापनChars को प्रतिस्थापित कर सकता है। थोड़ी सी लागत के लिए Keys.ToArray()।

मानते हैं कि प्रत्येक चरित्र एक प्रतिस्थापन चार नहीं है, तो यह वास्तव में स्ट्रिंग स्ट्रिंग प्रतिस्थापन (फिर से लगभग 20%) की तुलना में थोड़ा तेज़ होगा।

कहा जा रहा है कि, प्रदर्शन लागत पर विचार करते समय याद रखें, हम वास्तव में किस बारे में बात कर रहे हैं ... इस मामले में ... अनुकूलित समाधान और मूल समाधान के बीच का अंतर 1000 वर्ण स्ट्रिंग पर 100,000 से अधिक पुनरावृत्तियों के बारे में 1 सेकंड है ।

किसी भी तरह से, बस इस प्रश्न के उत्तर में कुछ जानकारी जोड़ना चाहता था।

Answer 2

आप जो चाहते हैं वह एक बार स्ट्रिंग के माध्यम से जाने और सभी प्रतिस्थापन करने का एक तरीका है। मुझे यकीन नहीं है कि अगर आप दक्षता चाहते हैं तो रेगेक्स ऐसा करने का सबसे अच्छा तरीका है। यह बहुत अच्छी तरह से हो सकता है कि प्रत्येक चरित्र का परीक्षण करने के लिए एक लूप में एक केस स्विच (उन सभी पात्रों के लिए जिन्हें आप प्रतिस्थापित करना चाहते हैं) तेज़ है। मैं दो दृष्टिकोणों को प्रोफाइल करूंगा।

Answer 3

मैंने आईसीएओ पासपोर्ट के लिए कुछ ऐसा ही किया। नामों को 'लिप्यंतरित' होना था। असल में मेरे पास char to char mappings का एक शब्दकोश था।

Dictionary<char, char> mappings; 

static public string Translate(string s) 
{ 
    var t = new StringBuilder(s.Length); 
    foreach (char c in s) 
    { 
     char to; 
     if (mappings.TryGetValue(c, out to)) 
     t.Append(to); 
     else 
     t.Append(c); 
    } 
    return t.ToString(); 
}