सी # स्ट्रिंग तुलना विधि पहले गैर मैच

Question

की इंडेक्स लौटने वाली इंडेक्स क्या एक एक्सस्टिंग स्ट्रिंग तुलना विधि है जो दो तारों के बीच एक गैर मिलान वाले चरित्र के पहले अवसर के आधार पर एक मान वापस कर देगी?

यानी

string A = "1234567890" 

string B = "1234567880" 

मैं एक मूल्य वापस कि मुझे देखने के लिए अनुमति होगी प्राप्त करना चाहते हैं कि एक मिलान को तोड़ने के पहले घटना एक [8]

Answer 1

/// <summary> 
/// Gets a first different char occurence index 
/// </summary> 
/// <param name="a">First string</param> 
/// <param name="b">Second string</param> 
/// <param name="handleLengthDifference"> 
/// If true will return index of first occurence even strings are of different length 
/// and same-length parts are equals otherwise -1 
/// </param> 
/// <returns> 
/// Returns first difference index or -1 if no difference is found 
/// </returns> 
public int GetFirstBreakIndex(string a, string b, bool handleLengthDifference) 
{ 
    int equalsReturnCode = -1; 
    if (String.IsNullOrEmpty(a) || String.IsNullOrEmpty(b)) 
    { 
     return handleLengthDifference ? 0 : equalsReturnCode; 
    } 

    string longest = b.Length > a.Length ? b : a; 
    string shorten = b.Length > a.Length ? a : b;  
    for (int i = 0; i < shorten.Length; i++) 
    { 
     if (shorten[i] != longest[i]) 
     { 
      return i; 
     } 
    } 

    // Handles cases when length is different (a="1234", b="123") 
    // index=3 would be returned for this case 
    // If you do not need such behaviour - just remove this 
    if (handleLengthDifference && a.Length != b.Length) 
    { 
     return shorten.Length; 
    } 

    return equalsReturnCode; 
} 

Answer 2

की तर्ज पर एक विस्तार विधि है नीचे काम करना होगा:

public static int Your_Name_Here(this string s, string other) 
{ 
    string first = s.Length < other.Length ? s : other; 
    string second = s.Length > other.Length ? s : other; 

    for (int counter = 0; counter < first.Length; counter++) 
    { 
     if (first[counter] != second[counter]) 
     { 
      return counter; 
     } 
    } 
    return -1; 
} 

Answer 3

ऐसा नहीं है कि मैं के बारे में पता है, लेकिन यह बहुत तुच्छ है:

public static int FirstUnmatchedIndex(this string x, string y) 
{ 
    if(x == null || y == null) 
    throw new ArgumentNullException(); 
    int count = x.Length; 
    if(count > y.Length) 
    return FirstUnmatchedIndex(y, x); 
    if(ReferenceEquals(x, y)) 
    return -1; 
    for(idx = 0; idx != count; ++idx) 
    if(x[idx] != y[idx]) 
     return idx; 
    return count == y.Length? -1 : count; 
} 

यह एक साधारण साधारण तुलना है। मामूली मामला-असंवेदनशील तुलना एक आसान परिवर्तन है, लेकिन संस्कृति-आधार परिभाषित करना मुश्किल है; "Weißbier" दूसरी स्ट्रिंग में अंतिम एस पर "WEISSBIERS" विसंगतियां, लेकिन क्या यह स्थिति 8 या स्थिति 9 के रूप में गिना जाता है?

Answer 4

आप 4.0 स्थापित शुद्ध है, तो यह एक तरीका हो सकता है:

string A = "1234567890"; 
    string B = "1234567880"; 

    char? firstocurrence = A.Zip(B, (p, q) => new { A = p, B = q }) 
     .Where(p => p.A != p.B) 
     .Select(p => p.A) 
     .FirstOrDefault(); 

संपादित करें:

हालांकि, आप स्थिति की जरूरत है:

int? firstocurrence = A.Zip(B, (p, q) => new { A = p, B = q }) 
      .Where(p => p.A != p.B) 
      .Select((p, i) => i) 
      .FirstOrDefault(); 

Answer 5

यह संभव स्ट्रिंग एक्सटेंशन लिखने के लिए

public static class MyExtensions 
{ 
    public static IList<char> Mismatch(this string str1, string str2) 
    { 
     var char1 = str1.ToCharArray(); 
     var char2 = str2.ToCharArray(); 
     IList<Char> Resultchar= new List<char>(); 
     for (int i = 0; i < char2.Length;i++) 
     { 
      if (i >= char1.Length || char1[i] != char2[i]) 
       Resultchar.Add(char2[i]); 
     } 
     return Resultchar; 
    } 
} 

तरह

var r = "1234567890".Mismatch("1234567880"); 

यह बेमेल को खोजने के लिए एक अनुकूलित एल्गोरिथ्म नहीं है, यह प्रयोग करें।

आप पहली बार बेमेल को खोजने के लिए केवल चाहते हैं, तो

public static Char FirstMismatch(this string str1, string str2) 
     { 
      var char1 = str1.ToCharArray(); 
      var char2 = str2.ToCharArray();    
      for (int i = 0; i < char2.Length;i++) 
      { 
       if (i >= char1.Length || char1[i] != char2[i]) 
        return char2[i]; 
      } 
      return ''c; 
     } 

Answer 6

यह विषय Comparing strings and get the first place where they vary from eachother का डुप्लिकेट है, जो एक बेहतर है, एक पंक्ति है, समाधान Linq