c＃ - 使用另一個字符串數組中的字符串搜索字符串數組

Question

就像在標題中一樣。我得到了一個字符串數組和第二個字符串數組。我想在這種模式下顯示結果：第一個數組的第一個元素 - 然後是第一個數組的第一個元素中出現的第二個數組中的所有元素。在第一個數組的第二個元素和第二個數組的第二個元素中出現的所有元素之後。等等。 例如：

string[] arrayA = {"Lorem ipsum dolor sit amet, justo", "notgin like good cold beer"}; 
string[] arrayB = {"justo","beer","lorem"} 
for (int i = 0; i < arrayA.Length; i++) 
    { 
     Console.WriteLine(arrayA[i]); 

     for (int j = 0; j < arrayB.Length; j++) 
     { 
      int controlIndex = arrayA[i].IndexOf(arrayB[j]); 
      if (controlIndex != -1) 
      { 
       Console.Write(" :--contains-->" + arrayB[j]); 
      } 

    } 

}

所以結果應該是這樣的：

• Lorem存有悲坐阿梅德，胡斯托： - 包含 - >胡斯托，LOREM
• 喜歡好的冷啤酒： - 包含 - >啤酒。

但我的結果是： - Lorem存有悲坐阿梅德，胡斯托： - 包含 - >胡斯托 - notgin想好冰鎮啤酒： - 包含 - >啤酒。

因此，大家可以看到有沒有LOREM上市

Answer 1

這並不難，如果你打破你的問題一些。首先，遠離處理數組和索引的問題。只需使用IEnumerable<T>，它會讓你的生活更輕鬆。

我是這樣看的：

首先，你要找到一個數組needles的所有字符串，是一個字符串，haystack的一部分。

public static IEnumerable<string> MatchingStrings(string haystack, IEnumerable<string> needles) 
{ 
    return needles.Where(needle => haystack.Contains(needle)); 
} 

這將從needles是的haystack的一部分返回所有字符串的IEnumerable。

然後，你只需遍歷所有的搜索字符串，我會打電話給haystacks。

static void Main(string[] args) 
    { 
     var haystacks = new[] { 
      "Lorem ipsum dolor sit amet, justo", 
      "notgin like good cold beer" 
     }; 

     var needles = new[] {"justo", "beer", "lorem"}; 

     foreach (var haystack in haystacks) { 
      Console.Write(haystack + " contains --> "); 
      var matches = MatchingStrings(haystack, needles); 

      Console.WriteLine(String.Join(",", matches)); 
     } 

     Console.ReadLine(); 
    } 

注意String.Contains()是區分大小寫。所以「Lorem」不會匹配「lorem」。如果你想要這種行爲，你必須先將它們轉換爲小寫。

public static IEnumerable<string> MatchingStringsCaseInsensitive(string haystack, IEnumerable<string> needles) 
{ 
    var h = haystack.ToLower(); 
    return needles.Where(needle => h.Contains(needle.ToLower())); 
} 

Answer 2

string[] arrayA = {"Lorem ipsum dolor sit amet, justo", "notgin like good cold beer"}; 
string[] arrayB = {"justo","beer","lorem"}; 

foreach (var s in arrayA) 
{ 
    Console.Write(s + " contains: " + 
        string.Join(",", arrayB.Where(s.Contains))); 
} 

如果你想忽略大小寫：

foreach (var s in arrayA) 
{ 
    Console.Write(s + " contains: " + 
        string.Join(",", arrayB.Where(x => 
         s.IndexOf(x, StringComparison.OrdinalIgnoreCase) != -1))); 
} 

Answer 3

foreach(var a in arrayA) 
{ 
    Console.WriteLine("a: " + a); 
    Console.WriteLine("bs: " + 
     String.Join(", ", arrayB.Where(b => a.IndexOf(b) > -1))); 
} 

此外，如果你的意思是不關心的情況下，a.IndexOf(b)將是a.IndexOf(b, StringComparison.OrdinalIgnoreCase)。

Answer 4

這是Linq的解決方案：

var result = arrayA.Select(a => new{ 
    A = a, 
    bContains = arrayB.Where(b => a.IndexOf(b, 0, StringComparison.CurrentCultureIgnoreCase) > -1)    
}); 

foreach(var x in result) 
{ 
    Console.WriteLine("{0}:--contains-->{1}", x.A, string.Join(",", x.bContains)); 
} 

這裏有一個演示：http://ideone.com/wxl6I

Answer 5

這是我嘗試

string[] arrayA = {"lorem ipsum dolor sit amet, justo", "notgin like good cold beer"}; 
string[] arrayB = {"justo", "beer", "lorem"}; 

foreach (var item in from a in arrayA from b in arrayB where a.Contains(b) select new {a, b}) 
{ 
    Console.WriteLine(item.a); 
    Console.WriteLine(item.b); 
} 

注：Contains是敏感的情況下，比較和你」你需要編寫一個自定義比較器（其他答案已經完成）

Answer 6

Lorem是大寫。嘗試使用不區分大小寫的搜索：.indexOf(string, StringComparison.CurrentCultureIgnoreCase)

Answer 7

我已經給你所有可能的答案，但包含方法將創建一個問題，它也將在下面提到的情況下返回true。

reference_string = "Hello Stack Overflow" 
test_string = "Over" 

所以儘量避免含有因爲contains方法將

「返回指示是否在此字符串中出現指定的System.String對象的值」

注：StringComparer.OrdinalIgnoreCase爲不區分大小寫而添加。

/// <summary> 
     /// Compares using binary search 
     /// </summary> 
     /// <param name="input"> search input</param> 
     /// <param name="reference"> reference string</param> 
     /// <returns> returns true or false</returns> 
     public bool FatMan(string input, string reference) 
     { 
      string[] temp = reference.Split(); 
      Array.Sort(temp); 
      List<string> refe = new List<string> { }; 
      refe.AddRange(temp); 

      string[] subip = input.Split(); 
      foreach (string str in subip) 
      { 
       if (refe.BinarySearch(str, StringComparer.OrdinalIgnoreCase) < 0) 
       { 
        return false; 
       } 
      } 

      return true; 
     } 

     /// <summary> 
     /// compares using contains method 
     /// </summary> 
     /// <param name="input"> search input</param> 
     /// <param name="reference"> reference string</param> 
     /// <returns> returns true or false</returns> 
     public bool Hiroshima(string input, string reference) 
     { 
      string[] temp = reference.Split(); 
      Array.Sort(temp); 
      List<string> refe = new List<string> { }; 
      refe.AddRange(temp); 
      string[] subip = input.Split(); 

      foreach (string str in subip) 
      { 
       if (!refe.Contains(str, StringComparer.OrdinalIgnoreCase)) 
       { 
        return false; 
       } 
      } 

      return true; 
     } 


     public bool Nakashaki(string input, string reference) 
     { 
      string[] temp = reference.Split(); 
      Array.Sort(temp); 
      List<string> refe = new List<string> { }; 
      refe.AddRange(temp); 
      string[] subip = input.Split(); 

      int result = (from st in subip where temp.Contains(st, StringComparer.OrdinalIgnoreCase) select st).Count(); 

      if (result <= 0) 
      { 
       return false; 
      } 

      return true; 
     } 

     /// <summary> 
     /// compares using contains method 
     /// </summary> 
     /// <param name="input"> search input</param> 
     /// <param name="reference"> reference string</param> 
     /// <returns> returns true or false</returns> 
     public bool LittleBoy(string input, string reference) 
     { 
      string[] subip = input.Split(); 
      foreach (string str in subip) 
      { 
       if (!reference.Contains(str)) 
       { 
        return false; 
       } 
      } 

      return true; 
     } 

Answer 8

bool oupt ; 
string[] strarray1 = new string[3]{"abc","def","ghi" }; 
string[] strarray2 = new string[4] { "648", "888", "999", "654" }; 
if (strarray1.All(strarray.Contains)) 
    oupt = true; 
else 
    oupt = false;