Jak sprawdzić, czy ciąg zawiera część innego ciągu w C#?

Question

String1 = "12345" 
String2 = "12abc" 

Chcę wrócić true, jeśli String1 zawiera jakąś część String2. W tym przykładzie String2 ma "12", który istnieje w String1. Więc na przykład String1.Contains(String2) powinien zwrócić true.

Jak mogę wykonać taką funkcję 'Contains'?

Answer 1

Nie powiedziano nam minimalną długość łańcucha pasującego, więc będę zakładając minimalną długość 1.

Dlatego można napisać:

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

Answer 2

Możesz to zrobić.

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. 
} 

To jest ważny punkt (z komentarzy), nawet pojedynczy znak może się równać pomiędzy dwoma ciągami.

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

Answer 3

Inną alternatywą byłoby za pomocą przecinać. To pomoże Ci ustawić pewną "próg" liczby podobnych elementów:

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 

wystarczy zmienić> 0 do> N (N jest liczbą całkowitą dodatnią: 1, 2, 3, ... itd), aby ustawić próg.

Answer 4

Można użyć IndexOfAny:

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

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

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

Answer 5

Można sprawdzić odległości Levenshteina jak opisano tutaj: [http://social.technet.microsoft.com/wiki/contents/articles/26805.c-calculating-percentage-similarity-of-2-strings.aspx]

W zależności od tego, jak podobny chcesz struny będzie można zmienić Sprawdź na CalculateSimilarity.

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

Jeśli chcesz zmienić liczbę minimalnej liczby znaków, która musi znajdować się w obu ciągach, możesz zrobić coś takiego. Zmień stałą charsToCompare, aby była minimalną liczbą wspólnych wartości do działania.

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; 
    } 
} 

Można bawić się z nim na dotnetfiddle https://dotnetfiddle.net/Ie1eLx

Answer 7

można sprawdzić obecność wspólny podciąg między dwoma ciąg przy użyciu tego sposobu

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; 
      } 
     } 

Oto Przydatny link http://www.datavoila.com/projects/text/longest-common-substring-of-two-strings.html