सी #: एन भागों में एक सरणी को विभाजित करना

Question

मेरे पास बाइट्स की एक सूची है और मैं इस सूची को छोटे भागों में विभाजित करना चाहता हूं।

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

इस सूची में 6 सेल्स हैं। उदाहरण के लिए, मैं इसे प्रत्येक 3 बाइट युक्त 3 भागों में विभाजित करना चाहता हूं।

मैंने कुछ उद्देश्यों को लिखने की कोशिश की है और मेरे उद्देश्य को प्राप्त करने के लिए 2 डी सरणी का उपयोग किया है, लेकिन मुझे नहीं पता कि यह एक सही दृष्टिकोण है।

  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

किसी भी सरणी को विभाजित करने के लिए एक सामान्य/विस्तार विधि बनाने का एक अच्छा तरीका होगा। यह मेरा है:

/// <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); 
    } 
} 

इसके अलावा, यह समाधान स्थगित कर दिया गया है। फिर, बस अपने सरणी पर split(size) पर कॉल करें।

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

के रूप में अनुरोध किया है, यहाँ एक सरणी से एक वर्ग 2 डी सरणियों प्राप्त करने के लिए एक सामान्य/विस्तार विधि है:

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; 
} 

है मज़ा :)

Answer 2

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(); 
} 

का उपयोग कर, बस का उपयोग यह

var sublists = SplitToSublists(lst); 

Answer 3

आप इस एक कोशिश देने के लिए चाहते हो सकता है।

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

यहाँ मेरी नैफ समाधान:

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; 
    }