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 ipsum dolor sit amet，justo： - contains - ＆gt;的斯托，LOREM
喜欢好的冰镇啤酒： - 包含 - ＆gt;的啤酒即可。

但我的结果是： - Lorem ipsum dolor sit amet，justo： - contains - ＆gt;的斯托 - 喜欢好的冰镇啤酒： - 包含 - ＆gt;的啤酒

因此，您可以看到没有列出 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

我已经给了你所有可能的答案，但是contains方法会产生一个问题，如下所述，它也会返回true。

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

所以尽量避免包含因为包含方法

“返回一个值，指示指定的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;

c＃ - 使用另一个字符串数组中的字符串搜索字符串数组

8 个答案: