come trovare i membri che esistono in almeno due liste in una lista di liste

Question

mi hanno una serie di liste:

var stringLists = new List<string>[] 
{ 
    new List<string>(){ "a", "b", "c" }, 
    new List<string>(){ "d", "b", "c" }, 
    new List<string>(){ "a", "d", "c" } 
}; 

Voglio estrarre tutti gli elementi che sono comuni in almeno 2 liste. Quindi, per questo esempio, dovrei ottenere tutti gli elementi ["a", "b", "c", "d"]. So come trovare elementi comuni a tutti ma non riesco a pensare ad alcun modo per risolvere questo problema.

Answer 1

Si potrebbe usare qualcosa di simile:

var result = stringLists.SelectMany(l => l.Distinct()) 
         .GroupBy(e => e) 
         .Where(g => g.Count() >= 2) 
         .Select(g => g.Key); 

---

solo per divertimento alcune soluzioni iterative:

var seen = new HashSet<string>(); 
var current = new HashSet<string>(); 
var result = new HashSet<string>(); 
foreach (var list in stringLists) 
{ 
    foreach(var element in list) 
     if(current.Add(element) && !seen.Add(element)) 
      result.Add(element); 

    current.Clear(); 
} 

o:

var already_seen = new Dictionary<string, bool>(); 
foreach(var list in stringLists) 
    foreach(var element in list.Distinct()) 
     already_seen[element] = already_seen.ContainsKey(element); 

var result = already_seen.Where(kvp => kvp.Value).Select(kvp => kvp.Key); 

o (ispirato Tim's answer) :

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

foreach(var str in stringLists.SelectMany(l => l.Distinct())) 
{ 
    items.TryGetValue(str, out tmp); 
    items[str] = tmp + 1; 
} 

var result = items.Where(kv => kv.Value >= 2).Select(kv => kv.Key); 

Answer 2

le seguenti operazioni:

1. Creare un elemento Dizionario -> Elenco degli indici
2. loop su tutte le liste
3. per numero di lista i: elemento foreach nella lista: aggiungere i to l'elenco nel dizionario in posizione: dictionary[element].Add(i) (se non già presente)
4. Conta quante liste nel dizionario hanno due voci

Answer 3

È possibile utilizzare SelectMany per appiattire la lista e poi raccogliere tutti elemeents che si verificano due o più volte:

var singleList = stringLists.SelectMany(p => p); 
var results = singleList.Where(p => singleList.Count(q => p == q) >= 2).Distinct(); 

Answer 4

si potrebbe usare una Dictionary<string, int>, la chiave è la stringa e il valore è il conteggio:

Dictionary<string, int> itemCounts = new Dictionary<string,int>(); 
for(int i = 0; i < stringLists.Length; i++) 
{ 
    List<string> list = stringLists[i]; 
    foreach(string str in list.Distinct()) 
    { 
     if(itemCounts.ContainsKey(str)) 
      itemCounts[str] += 1; 
     else 
      itemCounts.Add(str, 1); 
    } 
} 
var result = itemCounts.Where(kv => kv.Value >= 2); 

Io uso list.Distinct() poiché si desidera contare le occorrenze in elenchi diversi.

Come richiesto, ecco un metodo di estensione che è possibile riutilizzare con qualsiasi tipo:

public static IEnumerable<T> GetItemsWhichOccurAtLeastIn<T>(this IEnumerable<IEnumerable<T>> seq, int minCount, IEqualityComparer<T> comparer = null) 
{ 
    if (comparer == null) comparer = EqualityComparer<T>.Default; 
    Dictionary<T, int> itemCounts = new Dictionary<T, int>(comparer); 

    foreach (IEnumerable<T> subSeq in seq) 
    { 
     foreach (T x in subSeq.Distinct(comparer)) 
     { 
      if (itemCounts.ContainsKey(x)) 
       itemCounts[x] += 1; 
      else 
       itemCounts.Add(x, 1); 
     } 
    } 
    foreach(var kv in itemCounts.Where(kv => kv.Value >= minCount)) 
     yield return kv.Key; 
} 

L'uso è semplice:

string result = String.Join(",", stringLists.GetItemsWhichOccurAtLeastIn(2)); // a,b,c,d