संयोजन इन दो एक

Question

में रेगुलर एक्सप्रेशन मैं सी # में निम्नलिखित है:

public static bool IsAlphaAndNumeric(string s) 
{ 
    return Regex.IsMatch(s, @"[a-zA-Z]+") 
     && Regex.IsMatch(s, @"\d+"); 
} 

मैं अगर पैरामीटर s कम से कम एक अक्षर और एक अंक शामिल हैं जाँच करना चाहते हैं और मैं ऐसा करने उपरोक्त विधि लिखा था इसलिए।

लेकिन क्या कोई तरीका है कि मैं दो नियमित अभिव्यक्तियों ("[a-zA-Z]+" और "\d+") को एक साथ जोड़ सकता हूं?

Answer 1

@"^(?=.*[a-zA-Z])(?=.*\d)" 

^ # From the begining of the string 
(?=.*[a-zA-Z]) # look forward for any number of chars followed by a letter, don't advance pointer 
(?=.*\d) # look forward for any number of chars followed by a digit) 

यह एक पत्र है, और succeding से पहले एक संख्या पाता है सुनिश्चित करने के लिए दो positive lookaheads उपयोग करता है। स्ट्रिंग की शुरुआत से, आप केवल एक बार देखने की कोशिश करने के लिए ^ जोड़ें। अन्यथा, regexp इंजन स्ट्रिंग में हर बिंदु पर मिलान करने का प्रयास करेगा।

Answer 2

private static readonly Regex _regex = new Regex(
    @"^(?=.*[a-z])(?=.*[A-Z])(?=.*\d).+$", RegexOptions.Compiled); 

public static bool IsAlphaAndNumeric(string s) 
{ 
    return _regex.IsMatch(s); 
} 

यदि आप मामले को अनदेखा करना चाहते हैं तो आप RegexOptions.Compiled | RegexOptions.IgnoreCase का उपयोग कर सकते हैं।

Answer 3

आप [a-zA-Z].*[0-9]|[0-9].*[a-zA-Z] का उपयोग कर सकते हैं, लेकिन मैं केवल तभी अनुशंसा करता हूं यदि आप जिस सिस्टम का उपयोग कर रहे थे केवल एक ही रेगेक्स स्वीकार कर लिया गया हो। मैं कल्पना नहीं कर सकता कि यह बिना दो वैकल्पिक पैटर्न के दो सरल पैटर्न से अधिक कुशल होगा।

Answer 4

यह वही नहीं है जो आप चाहते हैं लेकिन कहें कि मेरे पास अधिक समय है। निम्नलिखित regex से तेजी से काम करना चाहिए।

static bool IsAlphaAndNumeric(string str) { 
     bool hasDigits = false; 
     bool hasLetters=false; 

     foreach (char c in str) { 
      bool isDigit = char.IsDigit(c); 
      bool isLetter = char.IsLetter(c); 
      if (!(isDigit | isLetter)) 
       return false; 
      hasDigits |= isDigit; 
      hasLetters |= isLetter; 
     } 
     return hasDigits && hasLetters; 
    } 

इसकी तेज़ी से इसकी जांच क्यों करें। परीक्षण स्ट्रिंग जेनरेटर निम्नलिखित है। यह 1/3 सेट पूरी तरह से सही स्ट्रिंग और 2/3 विज्ञापन गलत उत्पन्न करता है। 2/3 1/2 में सभी अल्फा और अन्य आधा सभी अंक हैं।

static IEnumerable<string> GenerateTest(int minChars, int maxChars, int setSize) { 
     string letters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"; 
     string numbers = "";    
     Random rnd = new Random(); 
     int maxStrLength = maxChars-minChars; 
     float probablityOfLetter = 0.0f; 
     float probablityInc = 1.0f/setSize; 
     for (int i = 0; i < setSize; i++) { 
      probablityOfLetter = probablityOfLetter + probablityInc; 
      int length = minChars + rnd.Next() % maxStrLength; 
      char[] str = new char[length]; 
      for (int w = 0; w < length; w++) { 
       if (probablityOfLetter < rnd.NextDouble()) 
        str[w] = letters[rnd.Next() % letters.Length]; 
       else 
        str[w] = numbers[rnd.Next() % numbers.Length];      
      } 
      yield return new string(str); 
     } 
    } 

डारिन दो समाधान निम्नलिखित है। एक संकलित है और दूसरा गैर संकलित संस्करण है।

class DarinDimitrovSolution 
{ 
    const string regExpression = @"^(?=.*[a-z])(?=.*[A-Z])(?=.*\d).+$"; 
    private static readonly Regex _regex = new Regex(
     regExpression, RegexOptions.Compiled); 

    public static bool IsAlphaAndNumeric_1(string s) { 
     return _regex.IsMatch(s); 
    } 
    public static bool IsAlphaAndNumeric_0(string s) { 
     return Regex.IsMatch(s, regExpression); 
    } 

पीछा कर रहा है परीक्षण पाश

static void Main(string[] args) { 

     int minChars = 3; 
     int maxChars = 13; 
     int testSetSize = 5000; 
     DateTime start = DateTime.Now; 
     foreach (string testStr in 
      GenerateTest(minChars, maxChars, testSetSize)) { 
      IsAlphaNumeric(testStr); 
     } 
     Console.WriteLine("My solution : {0}", (DateTime.Now - start).ToString()); 

     start = DateTime.Now; 
     foreach (string testStr in 
      GenerateTest(minChars, maxChars, testSetSize)) { 
      DarinDimitrovSolution.IsAlphaAndNumeric_0(testStr); 
     } 
     Console.WriteLine("DarinDimitrov 1 : {0}", (DateTime.Now - start).ToString()); 

     start = DateTime.Now; 
     foreach (string testStr in 
      GenerateTest(minChars, maxChars, testSetSize)) { 
      DarinDimitrovSolution.IsAlphaAndNumeric_1(testStr); 
     } 
     Console.WriteLine("DarinDimitrov(compiled) 2 : {0}", (DateTime.Now - start).ToString()); 

     Console.ReadKey(); 
    } 

के बाद का मुख्य है परिणाम

My solution : 00:00:00.0170017 (Gold) 
DarinDimitrov 1 : 00:00:00.0320032 (Silver medal) 
DarinDimitrov(compiled) 2 : 00:00:00.0440044 (Gold) 

तो सबसे पहले समाधान सबसे अच्छा था। कुछ और रिलीज़ मोड में परिणाम और कल्पना

int minChars = 20; 
    int maxChars = 50; 
    int testSetSize = 100000; 

My solution : 00:00:00.4060406 
DarinDimitrov 1 : 00:00:00.7400740 
DarinDimitrov(compiled) 2 : 00:00:00.3410341 (now that very fast) 

मैं RegexOptions.IgnoreCase ध्वज के साथ फिर से जाँच की निम्नलिखित। ऊपर

My solution : 00:00:00.4290429 (almost same as before) 
DarinDimitrov 1 : 00:00:00.9700970 (it have slowed down) 
DarinDimitrov(compiled) 2 : 00:00:00.8440844 (this as well still fast but look at .3 in last result) 

बाद gnarf मेरी algo यदि स्ट्रिंग केवल और अंक पत्र से मिलकर बनता है तो मैं इसे बदल उसकी जांच करने गया था के साथ एक समस्या थी कि उल्लेख और अब यह है कि स्ट्रिंग शो की जाँच के रूप में ही परम के बाकी कम से कम एक चार है और एक अंक।

static bool IsAlphaNumeric(string str) { 
     bool hasDigits = false; 
     bool hasLetters = false; 

     foreach (char c in str) { 
      hasDigits |= char.IsDigit(c); 
      hasLetters |= char.IsLetter(c); 
      if (hasDigits && hasLetters) 
       return true; 
     } 
     return false; 
    } 

परिणाम

My solution : 00:00:00.3900390 (Goody Gold Medal) 
DarinDimitrov 1 : 00:00:00.9740974 (Bronze Medal) 
DarinDimitrov(compiled) 2 : 00:00:00.8230823 (Silver) 

मेरा एक बड़ा पहलू से तेज है।

Answer 5

LINQ के साथ सी # के लिए:

return s.Any(Char.IsDigit) && s.Any(Char.IsLetter); 

Answer 6

निम्नलिखित यह भी है, न केवल अन्य अग्रदर्शी निर्माणों की तुलना में तेजी है (मेरी आँखों में) आवश्यकताओं के करीब:

[a-zA-Z\d]((?<=\d)[^a-zA-Z]*[a-zA-Z]|[^\d]*\d) 

पर मेरी (स्वीकार्य रूप से कच्चे परीक्षण) यह अन्य रेगेक्स समाधानों द्वारा आवश्यक आधा समय में चलता है, और इसका लाभ यह है कि यह इनपुट स्ट्रिंग में न्यूलाइन के बारे में परवाह नहीं करेगा। (और यदि किसी कारण से यह होना चाहिए, तो यह स्पष्ट है कि इसे कैसे शामिल किया जाए)।

चरण 1:: यह एक एक वर्ण (हमें यह ग कॉल) एक नंबर या एक पत्र है कि मेल खाता है

यहाँ कैसे (और क्यों) यह काम करता है है।
चरण 2: यह जांचने के लिए एक दृश्यमान है कि सी एक संख्या है। यदि ऐसा है:
चरण 2.1: यह असीमित संख्या में वर्णों की अनुमति देता है जो एक पत्र नहीं हैं, उसके बाद एक अक्षर के बाद। यदि यह मेल खाता है, तो हमारे पास एक पत्र के बाद एक संख्या (सी) है।
चरण 2.2: यदि सी कोई संख्या नहीं है, तो यह एक पत्र होना चाहिए (अन्यथा यह मिलान नहीं किया गया होगा)। इस मामले में हम एक अंक के बाद असीमित संख्या में गैर-अंकों की अनुमति देते हैं। इसका मतलब यह होगा कि हमारे पास एक पत्र है (सी) इसके बाद एक संख्या है।