लिंक का उपयोग एरेज़ में डेटा विभाजित करने के लिए

Question

मेरे पास तत्वों की एक सरणी है जहां तत्व के पास एक ध्वजांकित बूलियन मान है।

1 flagged 
2 not flagged 
3 not flagged 
4 flagged 
5 not flagged 
6 not flagged 
7 not flagged 
8 flagged 
9 not flagged 

मैं चिह्नित किये सूचक के आधार पर

उत्पादन विन्यास में, इसे तोड़ने के लिए चाहते हैं>

array 1 {1,2,3} 
array 2 {4,5,6,7} 
array 3 {8,9} 

Answer 1

मुझे नहीं लगता कि LINQ बहुत अच्छी तरह से इस के लिए अनुकूल है है। यह कुल() के साथ किया जा सकता है, लेकिन मुझे लगता है कि आप परिणाम को बनाने के लिए केवल एक foreach() के साथ लूपिंग बेहतर होगा।

Answer 2

Linq इस के लिए एक ऑपरेटर नहीं है, लेकिन मैं एक विस्तार विधि है कि आप उपयोग करने में सक्षम हो सकता है (MoreLinq, को भेजने की प्रक्रिया में जो आप भी जांच करनी चाहिए) लिखा है:

ऑपरेटर नीचे का उपयोग करना, आप लिखते हैं:

public static IEnumerable<IEnumerable<T>> Segment<T>(IEnumerable<T> sequence, Func<T, T, int, bool> newSegmentIdentifier) 
    { 
     var index = -1; 
     using (var iter = sequence.GetEnumerator()) 
     { 
      var segment = new List<T>(); 
      var prevItem = default(T); 

      // ensure that the first item is always part 
      // of the first segment. This is an intentional 
      // behavior. Segmentation always begins with 
      // the second element in the sequence. 
      if (iter.MoveNext()) 
      { 
       ++index; 
       segment.Add(iter.Current); 
       prevItem = iter.Current; 
      } 

      while (iter.MoveNext()) 
      { 
       ++index; 
       // check if the item represents the start of a new segment 
       var isNewSegment = newSegmentIdentifier(iter.Current, prevItem, index); 
       prevItem = iter.Current; 

       if (!isNewSegment) 
       { 
        // if not a new segment, append and continue 
        segment.Add(iter.Current); 
        continue; 
       } 
       yield return segment; // yield the completed segment 

       // start a new segment... 
       segment = new List<T> { iter.Current }; 
      } 
      // handle the case of the sequence ending before new segment is detected 
      if (segment.Count > 0) 
       yield return segment; 
     } 
    } 

Answer 3

मुझे नहीं लगता कि LINQ थी के लिए सही उपकरण है है:

var result = 
    items.Segment((item,prevItem,idx) => item.Flagged) 
     .Select(seq => seq.ToArray()) // converts each sequence to an array 
     .ToList(); 

यहाँ विस्तार विधि का कोड है एस कार्य क्या इस बारे में:

public static List<List<T>> PartitionData<T>(T[] arr, Func<T, bool> flagSelector){ 
    List<List<T>> output = new List<List<T>>(); 
    List<T> partition = null; 
    bool first = true; 

    foreach(T obj in arr){ 
     if(flagSelector(obj) || first){ 
      partition = new List<T>(); 
      output.Add(partition); 
      first = false; 
     } 
     partition.Add(obj); 
    } 

    return output; 
} 

एक छोटा सा उदाहरण, Fábio Batistas पद से डाटा के साथ:

var arrayOfElements = new[] { 
    new { Id = 1, Flagged = true }, 
    new { Id = 2, Flagged = false }, 
    new { Id = 3, Flagged = false }, 
    new { Id = 4, Flagged = true }, 
    new { Id = 5, Flagged = false }, 
    new { Id = 6, Flagged = false }, 
    new { Id = 7, Flagged = false }, 
    new { Id = 8, Flagged = true }, 
    new { Id = 9, Flagged = false } 
}; 

var partitioned = PartitionData(arrayOfElements, x => x.Flagged); 

Answer 4

को ध्यान में रखते:

var arrayOfElements = new[] { 
    new { Id = 1, Flagged = true }, 
    new { Id = 2, Flagged = false }, 
    new { Id = 3, Flagged = false }, 
    new { Id = 4, Flagged = true }, 
    new { Id = 5, Flagged = false }, 
    new { Id = 6, Flagged = false }, 
    new { Id = 7, Flagged = false }, 
    new { Id = 8, Flagged = true }, 
    new { Id = 9, Flagged = false } 
}; 

आप लिख सकते हैं:

var grouped = 
    from i in arrayOfElements 
    where i.Flagged 
    select 
     (new[] { i.Id }) 
     .Union(arrayOfElements.Where(i2 => i2.Id > i.Id).TakeWhile(i2 => !i2.Flagged).Select(i2 => i2.Id)) 
     .ToArray(); 

यह काम करता है अगर आपके तत्व ordere हैं आईडी विशेषता द्वारा डी। यदि वे नहीं करते हैं, तो आपको अपनी मूल सरणी पर अनुक्रमित करना होगा, जो कि linq के साथ भी करना आसान होना चाहिए, इसलिए आपको अनुक्रम मिलेगा।

इसके अलावा, एक बेहतर विकल्प होना चाहिए:

// for each flagged element, slice the array, 
// starting on the flagged element until the next flagged element 
var grouped = 
    from i in arrayOfElements 
    where i.Flagged 
    select 
     arrayOfElements 
      .SkipWhile(i2 => i2 != i) 
      .TakeWhile(i2 => i2 == i || !i2.Flagged) 
      .Select(i2 => i2.Id) 
      .ToArray(); 

ध्यान दें कि उन जवाब शुद्ध LINQ का उपयोग कर रहे हैं।

Answer 5

मैं इस के साथ एक समान समस्या थी, और GroupBy और बंद का उपयोग कर इसे हल।

//sample data 
var arrayOfElements = new[] { 
    new { Id = 1, Flagged = true }, 
    new { Id = 2, Flagged = false }, 
    new { Id = 3, Flagged = false }, 
    new { Id = 4, Flagged = true }, 
    new { Id = 5, Flagged = false }, 
    new { Id = 6, Flagged = false }, 
    new { Id = 7, Flagged = false }, 
    new { Id = 8, Flagged = true }, 
    new { Id = 9, Flagged = false } 
}; 

//this is the closure which will increase each time I see a flagged 
int flagCounter = 0; 

var query = 
    arrayOfElements.GroupBy(e => 
     { 
      if (e.Flagged) 
       flagCounter++; 
      return flagCounter; 
     }); 

यह क्या करता है एक पूर्णांक (flagCounter) है, जो हर बार एक फ्लैग किए गए तत्व पाया जाता है बढ़ जाती है पर समूहीकरण है।
कृपया ध्यान दें कि यह AsParallel() के साथ काम नहीं करेगा।

परीक्षण के परिणाम:

foreach(var group in query) 
{ 
    Console.Write("\r\nGroup: "); 
    foreach (var element in group) 
     Console.Write(element.Id); 
} 

आउटपुट:

समूह: 123
समूह: 4567
समूह: 89