Question

我有几个数组，例如：

var arr1 = new[] { "A", "B", "C", "D" };
var arr2 = new[] { "A", "D" };
var arr3 = new[] { "A", "B", };
var arr4 = new[] { "C", "D" };
var arr5 = new[] { "B", "C", "D" };
var arr6 = new[] { "B", "A", };

......等等。

如何在所有阵列中获得最常见的组合元素？

在这种情况下它是A和B，因为它们出现在arr1，arr3和arr6以及C和D中，因为它们出现在数组arr1，arr4和arr5中。

提到元素可以是任何类型的集合，即。在ArrayLists中也是。

更新 uuhhh，我还不够清楚......数组中两个元素的最常见组合。这就是我试图在示例中展示的内容，但在我的问题中没有提及。

对不起： - （（

Answer 1

如果您确定每个项目在每个数组中只出现一次，您可以将它们连接在一起并获取计数，例如：

var arrs = new[] { arr1, arr2, arr3, arr4, arr5, arr6 };
var intermediate = arrs.SelectMany(a => a)
                       .GroupBy(x => x)
                       .Select(g => new { g.Key, Count = g.Count() })
                       .OrderByDescending(x => x.Count);
var maxCount = intermediate.First().Count;
var results = intermediate.TakeWhile(x => x.Count == maxCount);

或者如果您更喜欢查询语法，那就是：

var arrs = new[] { arr1, arr2, arr3, arr4, arr5, arr6 };
var intermediate = 
    from a in arrs.SelectMany(a => a)
    group a by a into g
    orderby g.Count() descending
    select new { g.Key, Count = g.Count() };
var maxCount = intermediate.First().Count;
var results = intermediate.TakeWhile(x => x.Count == maxCount);

结果集将包含3个项目：

Key, Count
"A", 4 
"B", 4 
"D", 4

更新

鉴于您的更新问题，这样的事情应该有效：

var items = arrs.SelectMany(a => a).Distinct();
var pairs =
    from a in items
    from b in items
    where a.CompareTo(b) < 0
    select new { a, b };
var results = 
    (from arr in arrs
     from p in pairs 
     where arr.Contains(p.a) && arr.Contains(p.b)
     group arr by p into g
     orderby g.Count() descending
     select g.Key)
    .First();

这里的逻辑是：

首先查找任何数组中的所有不同项目
然后找到每对要搜索的项目
获取每一对，按照包含该对的数组列表进行分组
按组排序，包含每对的数组，降序
返回第一对

Answer 2

使用一个Dictionary，它将元素存储为索引，并将出现次数存储为值。迭代每个列表并计算出现次数。

Answer 3

var arr1 = new[] { "A", "B", "C", "D" };
var arr2 = new[] { "A", "D" };
var arr3 = new[] { "A", "B", };
var arr4 = new[] { "C", "D" };
var arr5 = new[] { "B", "C", "D" };
var arr6 = new[] { "B", "A", };

var results = new List<IEnumerable<string>>() { arr1, arr2, arr3, arr4, arr5, arr6 }
                                .Select(arr => arr.Distinct())
                                .SelectMany(s => s)
                                .GroupBy(s => s)
                                .Select(grp => new { Text = grp.Key, Count = grp.Count() })
                                .OrderByDescending(t => t.Count)
                                .ToList();

给你{A，4}，{B，4}，{D，4}，{C，3}

Answer 4

var result = new IEnumerable<String>[] {arr1, arr2, arr3, arr4, arr5, arr6}
                .SelectMany(a => a)
                .GroupBy(s => s)
                .GroupBy(g => g.Count())
                .OrderByDescending(g => g.Key)
                .FirstOrDefault()
                .SelectMany(g => g.Key);

Answer 5

您的问题不明确，因为您尚未明确定义您要查找的内容。通常，您可以将所有数组合并为一个大数组并计算不同的元素。然后订购元素，你可以做任何你想做的事情＆＃34;最常见的＆＃34;。

static void Main()
{
    var arr1 = new[] { "A", "B", "C", "D" };
    var arr2 = new[] { "A", "D" };
    var arr3 = new[] { "A", "B", };
    var arr4 = new[] { "C", "D" };
    var arr5 = new[] { "B", "C", "D" };
    var arr6 = new[] { "B", "A", };
    List<string> combined = Combine(arr1, arr2, arr3, arr4, arr5, arr6);

    var ordered = combined.OrderBy(i => i);//sorted list will probably help other functions work more quickly such as distinct
    var distinct = ordered.Distinct();

    var counts = new Dictionary<string, int>();

    foreach (var element in distinct)
    {
        var count = ordered.Count(i => i == element);
        counts.Add(element, count);
    }

    var orderedCount = counts.OrderByDescending(c => c.Value);

    foreach (var count in orderedCount)
    {
        Console.WriteLine("{0} : {1}", count.Key, count.Value);
    }
    Console.ReadLine();
}

private static List<string> Combine(string[] arr1, string[] arr2, string[] arr3, string[] arr4, string[] arr5, string[] arr6)
{
    List<string> combined = new List<string>();
    combined.AddRange(arr1);
    combined.AddRange(arr2);
    combined.AddRange(arr3);
    combined.AddRange(arr4);
    combined.AddRange(arr5);
    combined.AddRange(arr6);
    return combined;
}

输出：A：4，B：4，D：4，C：3

找到几个数组中最常见的元素组合

5 个答案: