Confronta dimensioni (numero) di molte liste

Question

Mi chiedevo se posso confrontare le dimensioni di molte liste in modo elegante e veloce.

Fondamentalmente questo è il mio problema, ho bisogno di affermare che 6 liste hanno le stesse dimensioni. Quindi il solito modo è qualcosa di simile (avviso brutto codice ..):

if (list1.Count == list2.Count && list1.Count == list3.Count && .....) { 
    //ok, so here they have same size. 
} 

Alcune alternative Jedi qui?

Answer 1

Il metodo all() dovrebbe fare il trucco: http://msdn.microsoft.com/en-us/library/bb548541.aspx.

codice dovrebbe assomigliare a questo, penso:

(new[] {list1, list2, list3, list4, list5, list6}). 
All(list => list.Count == list1.Count); 

Answer 2

ne dite con LINQ:

bool allSameSize = new[] { list1, list2, list3, list4, list5, list6 } 
         .Select(list => list.Count) 
         .Distinct() 
         .Take(2) // Optimization, not strictly necessary 
         .Count() == 1; 

Questa idea funziona per qualsiasi tipo di sequenza (non solo le liste), e sarà rapida rifiutare non appena si trovano due conteggi distinti.

In un'altra nota, c'è qualche ragione per cui gli elenchi non fanno parte di una raccolta di "elenchi di elenchi"?

Answer 3

Usando Enumerable.All è possibile verificare che tutte le liste corrispondono gli stessi criteri:

var allLists = new[] { list1, list2, list3 }; 
bool result = allLists.All(l => l.Count == allLists[0].Count); 

O come un one-liner, ma si farebbe quindi necessario fare riferimento ad una particolare lista:

bool result = (new[] { list1, list2, list3 }).All(l => l.Count == list1.Count); 

Answer 4

var lists = new [] { list1, list2, list3 ... }; 

bool diffLengths = lists.Select(list => list.Count).Distinct().Skip(1).Any(); 

O

bool sameLen = new HashSet<int>(lists.Select(list => list.Count)).Count <= 1; 

Answer 5

Se si effettua questo tipo di confronto in un solo luogo, allora non è probabilmente vale la pena provare per renderlo più breve (soprattutto se ha un impatto la performance).

Tuttavia, se si confrontano le lunghezze lista in più di un luogo, è forse la pena metterlo in una funzione, allora riutilizzare molte volte:

static bool SameLength<T>(params IList<T>[] lists) { 
    int len = -1; 
    foreach (var list in lists) { 
     int list_len = list.Count; 
     if (len >= 0 && len != list_len) 
      return false; 
     len = list_len; 
    } 
    return true; 
} 

static void Main(string[] args) { 

    // All of these lists have same length (2): 
    var list1 = new List<int> { 1, 2 }; 
    var list2 = new List<int> { 3, 4 }; 
    var list3 = new List<int> { 5, 6 }; 
    var list4 = new List<int> { 7, 8 }; 
    var list5 = new List<int> { 9, 10 }; 
    var list6 = new List<int> { 11, 12 }; 

    if (SameLength(list1, list2, list3, list4, list5, list6)) { 
     // Executed. 
    } 

    // But this one is different (length 3): 
    var list7 = new List<int> { 11, 22, 33 }; 

    if (SameLength(list1, list2, list3, list7, list4, list5, list6)) { 
     // Not executed. 
    } 

} 

--- EDIT ---

sulla base Dean Barnes' idea, si potrebbe anche fare questo per extra-corta implementazione:

static bool SameLength<T>(params IList<T>[] lists) { 
    return lists.All(list => list.Count == lists[0].Count); 
}