Wie überprüft man, ob eine Zeichenfolge in C# einen Teil einer anderen Zeichenfolge enthält?

Question

String1 = "12345" 
String2 = "12abc" 

Ich möchte true zurückgeben, wenn String1 einen Teil von String2 enthält. In diesem Beispiel hat String2 "12", was in String1 existiert. So zum Beispiel String1.Contains(String2) sollte true zurückgeben.

Wie kann ich eine solche 'Contains' Funktion machen?

Answer 1

Sie haben gesagt, nicht uns, die Mindestlänge des passenden String, so vorausgesetzt, ich werde die Mindestlänge 1 ist.

Daher können Sie schreiben:

String1.Any(c => String2.Contains(c)) 

Answer 2

Sie könnten dies tun.

string String1 = "12345"; 
string String2 = "12abc"; 

var subs = from i in Enumerable.Range(0, String2.Length) 
    from l in Enumerable.Range(1, String2.Length - i) 
    let part = String2.Substring(i, l) 
    select part; 

if(subs.Any(s=> String1.Contains(s))) 
{ 
    // contains. 
} 

Das ist gültiger Punkt (von den Anmerkungen), sogar einzelnes Zeichen kann zwischen zwei Zeichenketten zusammenbringen.

if(String1.Any(s=>String2.Contains(s))) 
{ 
    // contains 
} 

Answer 3

Eine weitere Alternative wäre Intersect werden. Dies wird Ihnen helfen bestimmte "Schwelle" der Anzahl ähnlicher Elemente einzustellen:

string String1 = "12345" 
string String2 = "12abc" 

var result = String1.ToCharArray().Intersect(String2.ToCharArray()).ToList(); 

if (result.Count > 0) //to check if there is any intersect 

Gerade> 0 ändern> N (N ist positive ganze Zahl: 1, 2, 3, ... usw.) zu setzen der Grenzbereich.

Answer 4

Sie können IndexOfAny verwenden:

string string1 = "12345"; 
string string2 = "12abc"; 

var isFound = string1.IndexOfAny(string2.ToCharArray()) >= 0; 

var firstOccurrenceIdx = string1.IndexOfAny(string2.ToCharArray()); 

Answer 5

Sie für die levenshtein Abstand überprüfen könnten, wie hier beschrieben: [http://social.technet.microsoft.com/wiki/contents/articles/26805.c-calculating-percentage-similarity-of-2-strings.aspx]

Je nachdem, wie ähnlich Sie die Saiten Sie sein können die Prüfung auf die ändern BerechnenSimilarität.

bool AreSimilar(string a, string b) 
{ 
    return CalculateSimilarity(a, b) > .25; 
} 

/// <summary> 
/// Calculate percentage similarity of two strings 
/// <param name="source">Source String to Compare with</param> 
/// <param name="target">Targeted String to Compare</param> 
/// <returns>Return Similarity between two strings from 0 to 1.0</returns> 
/// </summary> 
double CalculateSimilarity(string source, string target) 
{ 
    if ((source == null) || (target == null)) return 0.0; 
    if ((source.Length == 0) || (target.Length == 0)) return 0.0; 
    if (source == target) return 1.0; 

    int stepsToSame = ComputeLevenshteinDistance(source, target); 
    return (1.0 - ((double)stepsToSame/(double)Math.Max(source.Length, target.Length))); 
} 

/// <summary> 
/// Returns the number of steps required to transform the source string 
/// into the target string. 
/// </summary> 
int ComputeLevenshteinDistance(string source, string target) 
{ 
    if ((source == null) || (target == null)) return 0; 
    if ((source.Length == 0) || (target.Length == 0)) return 0; 
    if (source == target) return source.Length; 

    int sourceWordCount = source.Length; 
    int targetWordCount = target.Length; 

    // Step 1 
    if (sourceWordCount == 0) 
     return targetWordCount; 

    if (targetWordCount == 0) 
     return sourceWordCount; 

    int[,] distance = new int[sourceWordCount + 1, targetWordCount + 1]; 

    // Step 2 
    for (int i = 0; i <= sourceWordCount; distance[i, 0] = i++) ; 
    for (int j = 0; j <= targetWordCount; distance[0, j] = j++) ; 

    for (int i = 1; i <= sourceWordCount; i++) 
    { 
     for (int j = 1; j <= targetWordCount; j++) 
     { 
      // Step 3 
      int cost = (target[j - 1] == source[i - 1]) ? 0 : 1; 

      // Step 4 
      distance[i, j] = Math.Min(Math.Min(distance[i - 1, j] + 1, distance[i, j - 1] + 1), distance[i - 1, j - 1] + cost); 
     } 
    } 

    return distance[sourceWordCount, targetWordCount]; 
} 

Answer 6

Wenn Sie die Anzahl der Mindestanzahl von Zeichen ändern müssen, die in beiden Zeichenfolgen sein müssen, können Sie etwas wie folgt tun. Ändern Sie die charsToCompare-Konstante so, dass sie so klein wie möglich ist, damit die gemeinsamen Werte funktionieren.

using System; 

public class Program 
{ 
    public static void Main() 
    { 
     Console.WriteLine("Hello World".ContainsSubstring("Henry")); 
     Console.WriteLine("Hello World".ContainsSubstring("Hank")); 
     Console.WriteLine("12345".ContainsSubstring("12abc")); 
    } 
} 

public static class MyExtensions 
{ 
    public static bool ContainsSubstring(this string str, string compareValue) 
    { 
     const int charsToCompare = 2; 
     var subString = compareValue.Substring(0, Math.Min(charsToCompare, compareValue.Length)); 
     if (str.Contains(subString)) 
     { 
     return true; 
     } 
     else if (compareValue.Length > charsToCompare) 
     { 
     return str.ContainsSubstring(compareValue.Substring(1)); 
     } 
     return false; 
    } 
} 

Sie können dotnetfiddle auf mit ihm spielen, um https://dotnetfiddle.net/Ie1eLx

Answer 7

Sie Vorhandensein von gemeinsamen Teilzeichen zwischen zwei Zeichenfolge überprüfen können mit dieser Art und Weise

public static bool IsPresent(string str1, string str2) 
     { 

      int[,] num = new int[str1.Length, str2.Length]; 
      int maxLen = 0; 
      int lastSubsBegin = 0; 
      StringBuilder sequenceBuilder = new StringBuilder(); 

      for (int i = 0; i < str1.Length; i++) 
      { 
       for (int j = 0; j < str2.Length; j++) 
       { 
        if (str1[i] != str2[j]) 
         num[i, j] = 0; 
        else 
        { 
         if (i == 0 || j == 0) 
          num[i, j] = 1; 
         else 
          num[i, j] = 1 + num[i - 1, j - 1]; 

         if (num[i, j] > maxLen) 
         { 
          maxLen = num[i, j]; 
          int thisSubsBegin = i - num[i, j] + 1; 
          if (lastSubsBegin == thisSubsBegin) 
          { 
           // If the current LCS is the same as the last time this block ran 
           sequenceBuilder.Append(str1[i]); 
          } 
          else 
          { 
           // Reset the string builder if a different LCS is found 
           lastSubsBegin = thisSubsBegin; 
           sequenceBuilder.Length = 0; 
           sequenceBuilder.Append(str1.Substring(lastSubsBegin, (i + 1) - lastSubsBegin)); 
          } 
         } 
        } 
       } 
      } 

      if (sequenceBuilder.Length != 0) 
      { 
       return true; 
      } 
      else 
      { 
       return false; 
      } 
     } 

Hier ist nützlich Link http://www.datavoila.com/projects/text/longest-common-substring-of-two-strings.html