यह जांचने का सबसे तेज़ तरीका क्या है कि स्ट्रिंग में सी # में अपरकेस अक्षर है या नहीं?

Question

मेरी पहली कार्यान्वयन विचार बस करना है:

bool hasUpperCase (string str) { 
    if(string.IsNullOrEmpty(str)) 
     return false; 
    for (int i = 0; i < str.Length; i++) { 
     if (char.IsUpper (str[i])) 
      return true;      
    } 
    return false; 
} 

लेकिन शायद वहाँ ऐसा करने के लिए एक और तेज़ तरीका है?

Answer 1

आप

bool HasUpperCase (string str) { 
    return !string.IsNullOrEmpty(str) && str.Any(c => char.IsUpper(c)); 
} 

है कि कम कर सकता है LINQ का उपयोग कर।

Answer 2

Cheating from here:

bool hasUpperCase (string str) { 
if(string.IsNullOrEmpty(str)) 
    return false; 

    return str != str.ToLower(); 
} 

Answer 3

bool hasUpperCase(string str) { 
    if (string.IsNullOrEmpty(str)) 
     return false; 
    return Regex.IsMatch(str, "[A-Z]"); 
} 

अस्वीकरण: मैं कोई Regex विशेषज्ञ हूँ, लेकिन मैं तार Testing, testinG, and tesTing, जो सभी सच्चे के लिए मूल्यांकन के साथ इस परीक्षण किया गया। हालांकि, यह स्ट्रिंग TESTING स्ट्रिंग के साथ भी सही साबित हुआ, जिसे आप चाहें या नहीं।

Answer 4

कोड मुझे ठीक लग रहा है, क्योंकि आप प्रदर्शन के लिए पूछते हैं, आप रिवर्स साइड से सशर्त जांच जोड़कर ओ (एन) से ओ (एन/2 + ~ 1) से लूप को कम कर सकते हैं।

अन्यथा आप दो उप-अनुक्रम तत्वों की जांच कर सकते हैं और 2 तक बढ़ा सकते हैं। जाहिर है आपको दूसरे तर्क के लिए i < str.Length की जांच करनी चाहिए।

bool hasUpperCase (string str) { 
if(string.IsNullOrEmpty(str)) 
    return false; 
for (int i = 0; i < str.Length; i= i + 2) { 
    if (char.IsUpper (str[i])) 
     return true;      

    if ((i + 1) < str.Length && char.IsUpper (str[i+1])) 
     return true;      
} 
return false; 

}

IMHO, इस टिप बहुत प्रदर्शन नहीं मिलता है एल्गोरिथ्म साक्षात्कार जवाब देने के लिए मदद मिल सकती है।

Answer 5

ठीक है - नई सच्चाई के लिए समय!

यह एक स्ट्रिंग में किसी भी ऊपरी केस चरित्र के लिए एक परीक्षण था।

स्ट्रिंग की गारंटी थी कि पहले 60 के अक्षरों में कोई ऊपरी केस कैरेक्टर न हो। (मैंने random.org से स्ट्रिंग बनाई है)

मैंने संकलक में स्ट्रिंग प्रतिस्थापन ऑप्टिमाइज़ेशन को यादृच्छिक रूप से रोक दिया है जिसमें 64K वर्ण स्ट्रिंग को परीक्षण फ़ंक्शन में पास किया गया था।

सभी समय वास्तविक परीक्षण के आसपास बहुत सख्ती से थे, और इसमें फ़ंक्शन कॉलिंग समय शामिल नहीं था।

मैंने एक बार परीक्षण किया, 10 बार, और फिर 10,000 बार के लिए और प्रत्येक परीक्षण के लिए समय के प्रत्येक सेट औसत।

static bool testCaseOne(string str, out double ms) 
    { 
     bool result = false; 
     DateTime start = DateTime.Now; 

     result = !string.IsNullOrEmpty(str) && str.Any(c => char.IsUpper(c)); 
     ms = (DateTime.Now - start).TotalMilliseconds; 
     return result; 
    } 

परिणामस्वरूप औसत समय:

1. 1 एक्स = 3.000

   मैं एक 64 बिट पर परीक्षण 7 विन i3-2100 सीपीयू के साथ @ 3.1 Ghz

   टेस्ट केस 1 भाग गया एमएस

2. 10 x = 0.860 एमएस
3. 10,000 x = 0।821 एमएस

टेस्ट केस 2:

1. 1 एक्स = 2.000 एमएस
2. 10 एक्स = 1.597 एमएस
3. 10,000 एक्स = 1.603 एमएस:

   static bool testCaseTwo(string str, out double ms) 
       { 
        bool result = false; 
        DateTime start = DateTime.Now; 
   
        if (string.IsNullOrEmpty(str)) 
        { 
         ms = 0; 
         return false; 
        } 
        result = Regex.IsMatch(str, "[A-Z]"); 
   
        ms = (DateTime.Now - start).TotalMilliseconds; 
   
        return result; 
       } 
   

   औसत समय परिणामस्वरूप

टेस्ट केस 3:

static bool testCaseThree(string str, out double ms) 
    { 
     bool result = false; 
     DateTime start = DateTime.Now; 

     if (string.IsNullOrEmpty(str)) 
     { 
      ms = 0; 
      return false; 
     } 
     for (int i = 0; i < str.Length; i++) 
     { 
      if (char.IsUpper(str[i])) 
      { 
       result = true; 
       break; 
      } 
     } 
     ms = (DateTime.Now - start).TotalMilliseconds; 
     return result; 
    } 

औसत समय परिणामस्वरूप:

1. 1 एक्स = 1.000 एमएस
2. 10 एक्स = 0.357 एमएस
3. 10,000 एक्स = 0.298 एमएस

टेस्ट केस 4:

static bool testCaseFour(string str, out double ms) 
    { 
     bool result = false; 
     DateTime start = DateTime.Now; 

     if (string.IsNullOrEmpty(str)) 
     { 
      ms = 0; 
      return false; 
     } 
     for (int i = 0; i < str.Length; i++) 
     { 

      if (str[i] > 64 && str[i] < 91) 
      { 
       result = true; 
       break; 
      } 
     } 
     ms = (DateTime.Now - start).TotalMilliseconds; 
     return result; 
    } 

} 

औसत समय परिणामस्वरूप:

1. 1 एक्स = 0.000 एमएस
2. 10 एक्स = 0.137 एमएस
3. 10,000 एक्स = 0.184 एमएस

दिलचस्प।

मुझे आशा है कि इस statisfies श्री आर.के.;)

Answer 6

public static string Upper_To_Lower(string text) 
    { 
     if (Char.IsUpper(text[0]) == true) { text = text.Replace(text[0], char.ToLower(text[0])); return text; } 

     return text; 
    } 

    public static string Lower_To_Upper(string text) 
    { 
     if (Char.IsLower(text[0]) == true) { text = text.Replace(text[0], char.ToUpper(text[0])); return text; } 

     return text; 
    } 

यहाँ मैं 2 सरल तरीके, जो किसी भी स्ट्रिंग के पहले अक्षर की जाँच करें और ऊपरी से परिवर्तित virse verca कम और करने के लिए बनाया .... कि आशा आपकी सहायता करेगा।