Valori contigui del gruppo usando linq

Question

Ho un elenco ordinato di valori int e desidero creare valori vicini ai gruppi. I valori, dove next value è nextvalue> = prevValue + 1 sono vicini.

Ad esempio: listino:

{1,2,3,5,6,8,9,10} 

Gruppi saranno:

{1,2,3} 
{5,6} 
{8,9,10} 

Questo potrebbe essere fatto utilizzando LINQ?

Questo può essere fatto facilmente senza linq - iterando l'elenco, ma mi chiedo se linq abbia una soluzione per questo.

Answer 1

questo ha funzionato per me:

private static void GroupToNeighboursTest() 
{ 
    var numbers = new List<int> { 1, 2, 3, 5, 6, 8, 9, 10 }; 
    var neighbours = numbers 
     .Zip(numbers.Skip(1), Tuple.Create) 
     .Aggregate(new List<List<int>> { new List<int> { numbers.First() } }, (result, i) => 
     { 
      if (i.Item1 == i.Item2 - 1) 
      { 
       result.Last().Add(i.Item2); 
      } 
      else 
      { 
       result.Add(new List<int> { }); 
       result.Last().Add(i.Item2); 
      } 

      return result; 
     }); 
} 

Answer 2

Ho solo una soluzione non linq per questo (se ho capito bene il problema). Spero che sia d'aiuto.

void Main() 
{ 
    var list = new List<int>{1,2,3,5,6,8,9,10}; 
    GetData(list).Dump(); 
} 

public IEnumerable<List<int>> GetData(IEnumerable<int> data) 
{ 
    int prev = 0; 
    var g = new List<int>(); 
    foreach (var item in data) 
    { 
     if(item - prev > 1 && g.Count > 0) 
     { 
      yield return g; 
      g = new List<int>(); 
     } 
     g.Add(item); 
     prev = item; 
    } 
    yield return g; 
} 

Answer 3

Se è necessario utilizzare LINQ, si potrebbe prendere in considerazione il metodo Aggregate.

x.Aggregate(new List<List<int>> { new List<int>() }, (soFar, next) => { 
    if (soFar.Last().Contains(next - 1)) { 
     soFar.Last().Add(next); 
    } else { 
     soFar.Add(new List<int> { next }); 
    } 
    return soFar; 
}); 

Answer 4

questo funziona per me:

var result = 
    items 
     .Skip(1) 
     .Aggregate(
      new [] { items.Take(1).ToList() }.ToList(), 
      (acc, item) => 
      { 
       if (acc.Last().Last() == item - 1) 
       { 
        acc.Last().Add(item); 
       } 
       else 
       { 
        acc.Add(new [] { item }.ToList()); 
       } 
       return acc; 
      }); 

ottengo questo risultato:

Come nota a margine, mi piace prendere l'abitudine di creare elenchi come questo new [] { item }.ToList() in quanto consente di compilare elenchi di tipi anonimi. Molto utile in molte query LINQ.