ग्रोवी में बराबर आकार की सूचियों में सूची को कैसे विभाजित करें?

Question

मैं इस हों:

array.split(2) 

और मिलती है::

[[1,2],[3,4],[5,6]] 

def array = [1,2,3,4,5,6] 

कुछ बिल्ट-इन जो मुझे इस (या कुछ इसी तरह) करने की अनुमति देता है कि वहाँ है?

Answer 1

मैं क्रिस से सहमत है कि इस संभाल करने ग्रूवी में निर्मित कुछ भी नहीं है कि (कम से कम 2 से अधिक विभाजन के लिए), लेकिन मैंने आपके प्रश्न का अर्थ कुछ अलग करने के लिए किया था।

def partition(array, size) { 
    def partitions = [] 
    int partitionCount = array.size()/size 

    partitionCount.times { partitionNumber -> 
     def start = partitionNumber * size 
     def end = start + size - 1 
     partitions << array[start..end]  
    } 

    if (array.size() % size) partitions << array[partitionCount * size..-1] 
    return partitions  
} 


def origList = [1, 2, 3, 4, 5, 6] 
assert [[1], [2], [3], [4], [5], [6]] == partition(origList, 1) 
assert [[1, 2], [3, 4], [5, 6]] == partition(origList, 2) 
assert [[1, 2, 3], [4, 5, 6]] == partition(origList, 3) 
assert [[1, 2, 3, 4], [5, 6]] == partition(origList, 4) 
assert [[1, 2, 3, 4, 5], [6]] == partition(origList, 5) 
assert [[1, 2, 3, 4, 5, 6]] == partition(origList, 6) 

Answer 2

ऐसा करने के लिए builtin कुछ भी नहीं है, लेकिन यह लिखने के लिए कठिन नहीं है:

def array = [1,2,3,4,5,6] 
int mid = (int) (array.size()/2) 
def left = array[0..mid-1] 
def right = array[mid..array.size()-1] 

println left 
println right 

Answer 3

यहाँ एक वैकल्पिक संस्करण, ग्रूवी की गतिशील सुविधाओं का उपयोग करता है सूची वर्ग के लिए एक विभाजन विधि जोड़ने के लिए करता है कि आप क्या उम्मीद है,:: यहाँ एक कार्यान्वयन करता है कि मैं क्या लगता है कि आप पूछ रहे हैं के लिए है

List.metaClass.split << { size -> 
    def result = [] 
    def max = delegate.size() - 1 
    def regions = (0..max).step(size) 

    regions.each { start -> 
    end = Math.min(start + size - 1, max) 
    result << delegate[start..end] 
    } 

    return result 
} 

def original = [1, 2, 3, 4, 5, 6] 
assert [[1, 2], [3, 4], [5, 6]] == original.split(2) 

Answer 4

संपादित ग्रूवी 1.8.6 के रूप में आप सूची में collate विधि का उपयोग कर सकते हैं

def origList = [1, 2, 3, 4, 5, 6, 7, 8, 9] 
assert [[1, 2, 3, 4], [5, 6, 7, 8], [9]] == origList.collate(4) 

---

एक अन्य विधि इंजेक्षन और metaClasses

List.metaClass.partition = { size -> 
    def rslt = delegate.inject([ [] ]) { ret, elem -> 
    (ret.last() << elem).size() >= size ? ret << [] : ret 
    } 
    if(rslt.last()?.size() == 0) rslt.pop() 
    rslt 
} 

def origList = [1, 2, 3, 4, 5, 6] 

assert [ [1], [2], [3], [4], [5], [6] ] == origList.partition(1) 
assert [ [1, 2], [3, 4], [5, 6] ]  == origList.partition(2) 
assert [ [1, 2, 3], [4, 5, 6] ]   == origList.partition(3) 
assert [ [1, 2, 3, 4], [5, 6] ]   == origList.partition(4) 
assert [ [1, 2, 3, 4, 5], [6] ]   == origList.partition(5) 
assert [ [1, 2, 3, 4, 5, 6] ]   == origList.partition(6) 
assert [ ]        == [ ].partition(2) 

संपादित करें का उपयोग कर: एक मुद्दा रिक्त सूची से

Answer 5

चेक बाहर ग्रूवी 1.8.6 तय की। सूची पर एक नई कोलेट विधि है। क्योंकि वहाँ अन्य पैरामीटर है कि आप शेष छोड़ने सहित कुछ अन्य विकल्प देने के एक जोड़े हैं

def list = [1, 2, 3, 4] 
assert list.collate(4) == [[1, 2, 3, 4]] // gets you everything 
assert list.collate(2) == [[1, 2], [3, 4]] //splits evenly 
assert list.collate(3) == [[1, 2, 3], [4]] // won't split evenly, remainder in last list. 

अधिक जानकारी के लिए Groovy List documentation पर एक नजर डालें।

Answer 6

List.metaClass.split << { step -> 
    def result = [], max = delegate.size(), min = 0 

    while(min+step < max){  
     result.add delegate.subList(min,min+=step) 
    } 
    result.add delegate.subList(min, max) 

    result 
} 

Answer 7

यह सवाल पुराना है, लेकिन मैं साझा करने के लिए वैसे भी क्या मैं बराबर आकार सूचियों में एक सूची को विभाजित करने के साथ आया था चाहते हैं।

list.collate बहुत अच्छा है, लेकिन मेरे लिए काम नहीं किया, क्योंकि मुझे सूचियों को समान रूप से विभाजित करने की आवश्यकता थी।

कहाँ मैं क्या कर रहा है:

class PartitionCategory { 

    static evenlyPartitionWithCount(Collection self, int count) { 
     def indexes = 0..<self.size() 
     def sizes = indexes.countBy({ i -> i % count }).values() 
     def ranges = sizes.inject([]) { a, v -> a << (a ? (a.last().last() + 1)..(a.last().last() + v) : 0..<v) } 
     ranges.collect { r -> self[r] } 
    } 

    static evenlyPartitionWithSize(Collection self, int size) { 
     self.evenlyPartitionWithCount((int) Math.ceil(self.size()/size)) 
    } 

} 

def array = [1, 2, 3, 4, 5, 6, 7] 

use (PartitionCategory) { 
assert [[1], [2], [3], [4], [5], [6], [7]] == array.evenlyPartitionWithSize(1) 
assert [[1, 2], [3, 4], [5, 6], [7]] == array.evenlyPartitionWithSize(2) 
assert [[1, 2, 3], [4, 5], [6, 7]] == array.evenlyPartitionWithSize(3) 
assert [[1, 2, 3, 4], [5, 6, 7]] == array.evenlyPartitionWithSize(4) 
assert [[1, 2, 3, 4], [5, 6, 7]] == array.evenlyPartitionWithSize(5) 
assert [[1, 2, 3, 4], [5, 6, 7]] == array.evenlyPartitionWithSize(6) 
assert [[1, 2, 3, 4, 5, 6, 7]] == array.evenlyPartitionWithSize(7) 
} 

Answer 8

मैं जानता हूँ कि इस सुपर पुराना है - लेकिन बराबर विभाजनों में एक सूची विभाजित करने के लिए (शेष) के साथ उन लोगों के लिए है, और आप मूल पोस्ट पर टिम टिप्पणी याद आती है, सबसे हालिया ग्रोवी तरीका सूची वस्तुओं के लिए कोलेट() विधि है जो ग्रोवी 1.8.6 के बाद उपलब्ध है।

def array = [1, 2, 3, 4, 5, 6, 7] 

assert [[1], [2], [3], [4], [5], [6], [7]] == array.collate(1, 1, true) 
assert [[1, 2], [3, 4], [5, 6], [7]] == array.collate(2, 2, true) 
assert [[1, 2, 3], [4, 5, 6], [7]] == array.collate(3, 3, true) 
assert [[1, 2, 3, 4], [5, 6, 7]] == array.collate(4, 4, true) 
assert [[1, 2, 3, 4, 5], [6, 7]] == array.collate(5, 5, true) 
assert [[1, 2, 3, 4, 5, 6], [7]] == array.collate(6, 6, true) 
assert [[1, 2, 3, 4, 5, 6, 7]] == array.collate(7, 7, true) 

Answer 9

मैं एक ही समस्या के लिए देख रहा था और मैंने पाया सूचियों के लिए collate() विधि बहुत उपयोगी हो सकते हैं।

array.collate(2) 

Here दस्तावेज़ीकरण का लिंक है।