查找元素的最常见的组合在多个阵列

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中。

UPDATE 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 

---

更新

鉴于你更新的问题，就像这样d工作：

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(); 

这里的逻辑是：

1. 首先发现任何阵列
2. 然后找出每对项目的搜索
3. 让每一个对所有不同的项目，分组通过列表列出哪些阵列包含该对
4. 按组排列数量排序包含每对，降序
5. 返回第一对

Answer 2

使用字典将一个元素存储为一个索引，并且出现计数作为值迭代每个列表并计数出现

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

你的问题不清楚，你还没有明确的规定，你在找什么。一般来说，您可以将所有数组组合到一个大数组中并计算不同的元素。然后通过订购元素，您可以对“最常见”做任何打算。

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