Dividere una lista in elenchi più piccoli di dimensione N

Question

Sto tentando di dividere una lista in una serie di elenchi più piccoli.

Il mio problema: La mia funzione di dividere gli elenchi non li suddivide in elenchi di dimensioni corrette. Dovrebbe dividerli in elenchi di dimensioni 30 ma invece li divide in elenchi di dimensione 114?

Come posso rendere la mia funzione dividere un elenco in X numero di elenchi di dimensioni 30 o meno?

public static List<List<float[]>> splitList(List <float[]> locations, int nSize=30) 
{  
    List<List<float[]>> list = new List<List<float[]>>(); 

    for (int i=(int)(Math.Ceiling((decimal)(locations.Count/nSize))); i>=0; i--) { 
     List <float[]> subLocat = new List <float[]>(locations); 

     if (subLocat.Count >= ((i*nSize)+nSize)) 
      subLocat.RemoveRange(i*nSize, nSize); 
     else subLocat.RemoveRange(i*nSize, subLocat.Count-(i*nSize)); 

     Debug.Log ("Index: "+i.ToString()+", Size: "+subLocat.Count.ToString()); 
     list.Add (subLocat); 
    } 

    return list; 
} 

Se uso la funzione in un elenco di dimensioni 144 allora l'uscita è:

Index: 4, Dimensioni: 120
Index: 3, formato: 114
Index: 2 , Dimensione: 114
Index: 1, formato: Index 114
: 0, Dimensioni: 114

Answer 1

public static List<List<float[]>> splitList(List<float[]> locations, int nSize=30) 
{   
    var list = new List<List<float[]>>(); 

    for (int i=0; i < locations.Count; i+= nSize) 
    { 
     list.Add(locations.GetRange(i, Math.Min(nSize, locations.Count - i))); 
    } 

    return list; 
} 

versione generica:

public static IEnumerable<List<T>> splitList<T>(List<T> locations, int nSize=30) 
{   
    for (int i=0; i < locations.Count; i+= nSize) 
    { 
     yield return locations.GetRange(i, Math.Min(nSize, locations.Count - i)); 
    } 
} 

Answer 2

come circa:

while(locations.Any()) 
{  
    list.Add(locations.Take(nSize).ToList()); 
    locations= locations.Skip(nSize).ToList(); 
} 

Answer 3

Ho un metodo generico che avrebbe preso qualsiasi tipo comprendono galleggiante, ed è stato unità testato, la speranza aiuta:

/// <summary> 
    /// Breaks the list into groups with each group containing no more than the specified group size 
    /// </summary> 
    /// <typeparam name="T"></typeparam> 
    /// <param name="values">The values.</param> 
    /// <param name="groupSize">Size of the group.</param> 
    /// <returns></returns> 
    public static List<List<T>> SplitList<T>(IEnumerable<T> values, int groupSize, int? maxCount = null) 
    { 
     List<List<T>> result = new List<List<T>>(); 
     // Quick and special scenario 
     if (values.Count() <= groupSize) 
     { 
      result.Add(values.ToList()); 
     } 
     else 
     { 
      List<T> valueList = values.ToList(); 
      int startIndex = 0; 
      int count = valueList.Count; 
      int elementCount = 0; 

      while (startIndex < count && (!maxCount.HasValue || (maxCount.HasValue && startIndex < maxCount))) 
      { 
       elementCount = (startIndex + groupSize > count) ? count - startIndex : groupSize; 
       result.Add(valueList.GetRange(startIndex, elementCount)); 
       startIndex += elementCount; 
      } 
     } 


     return result; 
    } 

Answer 4

Vorrei suggerire di utilizzare questo metodo di estensione per ridurre l'elenco di sorgenti alle sotto-liste per dimensione del blocco specificato:

/// <summary> 
/// Helper methods for the lists. 
/// </summary> 
public static class ListExtensions 
{ 
    public static List<List<T>> ChunkBy<T>(this List<T> source, int chunkSize) 
    { 
     return source 
      .Select((x, i) => new { Index = i, Value = x }) 
      .GroupBy(x => x.Index/chunkSize) 
      .Select(x => x.Select(v => v.Value).ToList()) 
      .ToList(); 
    } 
} 

Ad esempio, se si esegue il chuck dell'elenco di 18 elementi per 5 elementi per blocco, viene fornito l'elenco di 4 sottoliste con i seguenti elementi all'interno: 5-5-5-3.

Answer 5

soluzione Serj-Tm va bene, anche questa è la versione generica come metodo di estensione per le liste (metterlo in una classe statica):

public static List<List<T>> Split<T>(this List<T> items, int sliceSize = 30) 
{ 
    List<List<T>> list = new List<List<T>>(); 
    for (int i = 0; i < items.Count; i += sliceSize) 
     list.Add(items.GetRange(i, Math.Min(sliceSize, items.Count - i))); 
    return list; 
} 

Answer 6

trovo risposta accettata (Serj-Tm) più robusto, ma mi piacerebbe suggerire una versione generica.

public static List<List<T>> splitList<T>(List<T> locations, int nSize = 30) 
    { 
     var list = new List<List<T>>(); 

     for (int i = 0; i < locations.Count; i += nSize) 
     { 
      list.Add(locations.GetRange(i, Math.Min(nSize, locations.Count - i))); 
     } 

     return list; 
    } 

Answer 7

Biblioteca MoreLinq hanno chiamato metodo Batch

List<int> ids = new List<int>() { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 }; // 10 elements 
int counter = 1; 
foreach(var batch in ids.Batch(2)) 
{ 
    foreach(var eachId in batch) 
    { 
     Console.WriteLine("Batch: {0}, Id: {1}", counter, eachId); 
    } 
    counter++; 
} 

risultato è

Batch: 1, Id: 1 
Batch: 1, Id: 2 
Batch: 2, Id: 3 
Batch: 2, Id: 4 
Batch: 3, Id: 5 
Batch: 3, Id: 6 
Batch: 4, Id: 7 
Batch: 4, Id: 8 
Batch: 5, Id: 9 
Batch: 5, Id: 0 

ids sono suddivisi in 5 pezzi con 2 elementi.

Answer 8

Anche se molte soluzioni potrebbero funzionare, penso che non siano molto efficienti. Supponiamo che tu voglia solo i primi elementi dei primi pezzi. Quindi non si desidera eseguire un'iterazione su tutti gli elementi (zillion) nella sequenza.

Il seguente numero verrà enumerato al massimo due volte: una volta per il Take e una volta per il Skip. E non conta più di qualsiasi più elementi di quanto si intende utilizzare:

public static IEnumerable<IEnumerable<TSource>> ChunkBy<TSource> 
    (this IEnumerable<TSource> source, int chunkSize) 
{ 
    while (source.Any())      // while there are elements left 
    { // still something to chunk: 
     yield return source.Take(chunkSize); // return a chunk of chunkSize 
     source = source.Skip(chunkSize);  // skip the returned chunk 
    } 
}