C#: Dzielenie tablicy na n części

Question

Mam listę bajtów i chcę podzielić tę listę na mniejsze części.

var array = new List<byte> {10, 20, 30, 40, 50, 60}; 

Ta lista zawiera 6 komórek. Na przykład chcę podzielić go na 3 części zawierające każde 2 bajty.

Próbowałem napisać trochę dla pętli i wykorzystałem tablice 2D, aby osiągnąć mój cel, ale nie wiem, czy to właściwe podejście.

  byte[,] array2D = new byte[window, lst.Count/window]; 
      var current = 0; 
      for (int i = 0; i < rows; i++) 
      { 
       for (int j = 0; j < cols; j++) 
       { 
        array2D[i, j] = lst[current++]; 
       } 
      } 

Answer 1

Dobrym sposobem byłoby stworzenie ogólnej/rozszerzającej metody dzielenia dowolnej tablicy. To jest moje:

/// <summary> 
/// Splits an array into several smaller arrays. 
/// </summary> 
/// <typeparam name="T">The type of the array.</typeparam> 
/// <param name="array">The array to split.</param> 
/// <param name="size">The size of the smaller arrays.</param> 
/// <returns>An array containing smaller arrays.</returns> 
public static IEnumerable<IEnumerable<T>> Split<T>(this T[] array, int size) 
{ 
    for (var i = 0; i < (float)array.Length/size; i++) 
    { 
     yield return array.Skip(i * size).Take(size); 
    } 
} 

Co więcej, to rozwiązanie jest odłożone. Następnie po prostu zadzwoń pod numer split(size) w swojej tablicy.

var array = new byte[] {10, 20, 30, 40, 50}; 
var splitArray = array.Split(2); 

Zgodnie z wnioskiem, o to metoda rodzajowa/przedłużenie dostać kwadratowej macierzy 2D z tablicy:

public static T[,] ToSquare2D<T>(this T[] array, int size) 
{ 
    var buffer = new T[(int)Math.Ceiling((double)array.Length/size), size]; 
    for (var i = 0; i < (float)array.Length/size; i++) 
    { 
     for (var j = 0; j < size; j++) 
     { 
      buffer[i, j] = array[i + j]; 
     } 
    } 
    return buffer; 
} 

Baw :)

Answer 2

użyciu Linq

public List<List<byte>> SplitToSublists(List<byte> source) 
{ 
    return source 
      .Select((x, i) => new { Index = i, Value = x }) 
      .GroupBy(x => x.Index/100) 
      .Select(x => x.Select(v => v.Value).ToList()) 
      .ToList(); 
} 

Wystarczy użyć go

var sublists = SplitToSublists(lst); 

Answer 3

Czasami warto dać tę szansę.

var bytes = new List<byte>(10000); 
int size = 100; 
var lists = new List<List<byte>>(size); 
for (int i = 0; i < bytes.Count; i += size) 
{ 
     var list = new List<byte>(); 
     list.AddRange(bytes.GetRange(i, size)); 
     lists.Add(list); 
} 

Answer 4

Oto moje rozwiązanie naif:

public static string[] SplitArrey(string[] ArrInput, int n_column) 
    { 

     string[] OutPut = new string[n_column]; 
     int NItem = ArrInput.Length; // Numero elementi 
     int ItemsForColum = NItem/n_column; // Elementi per arrey 
     int _total = ItemsForColum * n_column; // Emelemti totali divisi 
     int MissElement = NItem - _total; // Elementi mancanti 

     int[] _Arr = new int[n_column]; 
     for (int i = 0; i < n_column; i++) 
     { 
      int AddOne = (i < MissElement) ? 1 : 0; 
      _Arr[i] = ItemsForColum + AddOne; 
     } 

     int offset = 0; 
     for (int Row = 0; Row < n_column; Row++) 
     { 
      for (int i = 0; i < _Arr[Row]; i++) 
      { 
       OutPut[Row] += ArrInput[i + offset] + " "; // <- Here to change how the strings are linked 
      } 
      offset += _Arr[Row]; 
     } 
     return OutPut; 
    }