प्रत्येक सरणी के समूह में किसी सरणी को कैसे विभाजित करें?

Question

क्या समूह का सबसे अच्छा तरीका n तत्वों प्रत्येक की सरणी की एक सूची में एक सरणी सी # में 4.

उदा

string[] testArray = { "s1", "s2", "s3", "s4", "s5", "s6", "s7", "s8" }; 

अगर हम n = 3 लेने में विभाजित किया जाना चाहिए।

string[] A1 = {"s1", "s2", "s3"}; 
string[] A2 = {"s4", "s5", "s6"}; 
string[] A3 = {"s7", "s8"}; 

LINQ का उपयोग करके एक आसान तरीका हो सकता है?

Answer 1

यह 3 तत्वों होने स्ट्रिंग सरणियों की एक सरणी उत्पन्न करेगा: यदि यह वास्तव में सरणियों है कि आप के साथ नहीं बल्कि सामान्य IEnumerables से, और विशेष रूप से अगर सरणियों बहुत बड़े हैं काम कर रहे हैं है

int i = 0; 
var query = from s in testArray 
      let num = i++ 
      group s by num/3 into g 
      select g.ToArray(); 
var results = query.ToArray(); 

Answer 2

मुझे नहीं लगता कि इसके लिए एक महान अंतर्निहित विधि है लेकिन आप निम्न में से एक लिख सकते हैं।

public static IEnumerable<IEnumerable<T>> GroupInto<T>(
    this IEnumerable<T> source, 
    int count) { 

    using (var e = source.GetEnumerator()) { 
    while (e.MoveNext()) { 
     yield return GroupIntoHelper(e, count); 
    } 
    }  
} 

private static IEnumerable<T> GroupIntoHelper<T>(
    IEnumerator<T> e, 
    int count) { 

    do { 
    yield return e.Current; 
    count--; 
    } while (count > 0 && e.MoveNext()); 
} 

Answer 3

, तो यह विधि इसे करने के लिए एक बहुत तेज़ और स्मृति प्रभावशाली तरीका है। यदि आप वास्तव में केवल एक LINQ कथन चाहते हैं, तो कभी नहीं।

private static T[][] SliceArray<T>(T[] source, int maxResultElements) 
    { 
     int numberOfArrays = source.Length/maxResultElements; 
     if (maxResultElements * numberOfArrays < source.Length) 
      numberOfArrays++; 
     T[][] target = new T[numberOfArrays][]; 
     for (int index = 0; index < numberOfArrays; index++) 
     { 
      int elementsInThisArray = Math.Min(maxResultElements, source.Length - index * maxResultElements); 
      target[index] = new T[elementsInThisArray]; 
      Array.Copy(source, index * maxResultElements, target[index], 0, elementsInThisArray); 
     } 
     return target; 
    } 

Answer 4

int size = 3; 
var results = testArray.Select((x, i) => new { Key = i/size, Value = x }) 
         .GroupBy(x => x.Key, x => x.Value, (k, g) => g.ToArray()) 
         .ToArray(); 

आप कोई आपत्ति नहीं है के रूप में IEnumerable<IEnumerable<T>> बजाय T[][] तो आप पूरी तरह ToArray कॉल को छोड़ सकते हैं परिणाम टाइप किया जा रहा है:

int size = 3; 
var results = testArray.Select((x, i) => new { Key = i/size, Value = x }) 
         .GroupBy(x => x.Key, x => x.Value); 

Answer 5

MoreLinq प्रदान करता है Batch विस्तार विधि

Answer 6

आप इस एक्सटेंशन का उपयोग कर सकते हैं

public static class Extension 
{ 
    private static IEnumerable<TList> Split<TList, T>(this TList value, int countOfEachPart) where TList : IEnumerable<T> 
    { 
     int cnt = value.Count()/countOfEachPart; 
     List<IEnumerable<T>> result = new List<IEnumerable<T>>(); 
     for (int i = 0; i <= cnt; i++) 
     { 
      IEnumerable<T> newPart = value.Skip(i * countOfEachPart).Take(countOfEachPart).ToArray(); 
      if (newPart.Any()) 
       result.Add(newPart); 
      else 
       break; 
     } 

     return result.Cast<TList>(); 
    } 

    public static IEnumerable<IDictionary<TKey, TValue>> Split<TKey, TValue>(this IDictionary<TKey, TValue> value, int countOfEachPart) 
    { 
     IEnumerable<Dictionary<TKey, TValue>> result = value.ToArray() 
                  .Split(countOfEachPart) 
                  .Select(p => p.ToDictionary(k => k.Key, v => v.Value)); 
     return result; 
    } 

    public static IEnumerable<IList<T>> Split<T>(this IList<T> value, int countOfEachPart) 
    { 
     return value.Split<IList<T>, T>(countOfEachPart); 
    } 

    public static IEnumerable<T[]> Split<T>(this T[] value, int countOfEachPart) 
    { 
     return value.Split<T[], T>(countOfEachPart); 
    } 

    public static IEnumerable<IEnumerable<T>> Split<T>(this IEnumerable<T> value, int countOfEachPart) 
    { 
     return value.Split<IEnumerable<T>, T>(countOfEachPart); 
    } 
}