Question

我有两个数组对象

int[] arr1= new int[] {1,2,5,6,7,9,3,5,6,7}
int[] arr2 = new int[] {5,6,7}

现在，如何在arr1中找到arr2的出现次数？

Answer 1

您可以使用arr2.Intersect(arr1).Count()

因此，在您的情况下，它会返回3，因为arr2中的arr1中有3个元素。

如果这不是您要求的，请澄清。

Answer 2

使用相交。此代码段将解决您的问题并打印所有重复项，并在arr1中显示每个重复项的计数。请注意，我也在使用Linq Distinct（），因此在循环常见事件时，我只检查一次而不是更多。

            int[] arr1= new int[] {1,2,5,6,7,9,3,5,6,7};
            int[] arr2 = new int[] {5,6,7};
            var listCommon = arr1.AsEnumerable().Where(arr2.AsEnumerable().Contains);

            foreach (var x in listCommon.Distinct()) {
                var numberOfOccurencesInArr1 = arr1.Where(y => y == x).Count();
                Console.WriteLine(x + " is : " + numberOfOccurencesInArr1.ToString() + " times in arr1");
            }

            Console.ReadLine();

有关详细信息，请参阅MSDN; http://msdn.microsoft.com/en-us/library/system.linq.enumerable.intersect(v=vs.110).aspx

listCommon将是两个数组中常见项的数量。

Answer 3

也许不是很优雅，但应该有效。这将选择a中具有相同b长度的所有子阵列，并检查有多少子阵列等于b。

int[] a = {1, 2, 3, 4, 5};
int[] b = {2, 3};

int count = 0;
int bl = b.Length;
for (int i = 0; i <= a.Length - bl; i++)
{
    var suba = a.Skip(i).Take(bl);
    if (suba.SequenceEqual(b))
    count++;
}

N.B。：此解决方案考虑重叠的子阵列，因此，如果a = {2, 2, 2}和b = {2, 2}，则计数将为2。

Answer 4

试试这个：

var results = (from a1 in arr1
              join a2 in arr2
              on a1 equals a2
              group arr1 by a1 into Group
              select new
              {
                  Number = Group.Key,
                  Times = Group.Count()
              });

foreach(var result in results)
    Console.WriteLine(result.Number+" "+result.Times);

请使用以下小提琴.NET fiddle

检查此解决方案

Answer 5

试试这个

    string result = string.Empty; ;
    int[] arr1 = new int[] { 1, 2, 5, 6, 7, 9, 3, 5, 6, 7 };
    int[] arr2 = new int[] { 5, 6, 7 };


    int count = arr2.Intersect(arr1).Count();

    if (count == arr2.Length)
    {
        result = "Found";
    }
    else
    {
        result = "Not Found";
    }

Answer 6

如果要计算第一个数组中第二个数组的整数出现次数，那么你可以编写

int[] arr1 = new int[] {1,2,5,6,7,9,3,5,6,7};
int[] arr2 = new int[] {5,6,7};

Dictionary<int, int> counter = new Dictionary<int, int>();
foreach(int x in arr1)
{
    if(arr2.Contains(x))
    {
        if(counter.ContainsKey(x))
          counter[x]++;
        else
          counter[x] = 1;
     }     
}

foreach(KeyValuePair<int, int> kvp in counter)
   Console.WriteLine("Key=" + kvp.Key.ToString() + " is present " + kvp.Value.ToString() + " times");

Answer 7

int[] arr1 = new int[] { 1, 2, 5, 6, 7, 9, 3, 5, 6, 7 };
int[] arr2 = new int[] { 5, 6, 7 };

如何在arr1中找到arr2的出现次数？
如果您期望结果为2。由于5,6,7在arr1中出现两次

试试这个

 var res = arr1.Where(x => arr2.Contains(x)).Count()/arr2.Count();

Answer 8

当您输入数组时，您可以使用索引来有效地计算主数组中子数组的出现次数：

var count = 0;
for (var i = 0; i < arr1.Length - arr2.Length + 1; i += 1) {
  if (arr1[i] != arr2[0])
    continue;
  var isSubarray = true;
  for (var j = 0; j < arr2.Length; ++j)
    if (arr1[i + j] != arr2[j]) {
      isSubarray = false;
      break;
    }
  if (isSubarray)
    count += 1;
}

结果为2，因为在1256793567中发现了567次。

如果子阵列本身可以“重叠”（例如111中的11），则将计算所有“重叠”（例如，对于该示例，结果将是2）。如果这不是意图，您只需要在主循环结束时推进索引i以跳过找到的子数组。

Answer 9

您可以在第一个计数中的ToLookup上使用int，这也是第二个数组中的var subsetGroups = arr1.Where(i1 => arr2.Contains(i1)).ToLookup(i => i); int minGroupCount = 0; // check if all integers from the array are in the first at all if(arr2.All(i => subsetGroups.Contains(i))) { minGroupCount = subsetGroups.Min(g => g.Count()); // 2 }。然后你只需要取所有组的最小计数，因为那是最大的交集：

{{1}}

请注意，此方法不关心顺序，也不关心第二个数组中的重复数。这可能是你想要的。

将一个数组的序列查找到另一个数组中

9 个答案: