Как разделить список на списки одинакового размера в Groovy?
Если у меня есть это:
def array = [1,2,3,4,5,6]
есть ли какой-то встроенный, который позволяет мне это делать (или что-то подобное ):
array.split(2)
и
[[1,2],[3,4],[5,6]]
?
9 ответов
Я согласен с Крисом, что нет ничего встроенного в groovy, чтобы справиться с этим (по крайней мере, для более чем 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)
редактировать начиная с groovy 1.8.6 вы можете использовать сличить метод в списках
def origList = [1, 2, 3, 4, 5, 6, 7, 8, 9]
assert [[1, 2, 3, 4], [5, 6, 7, 8], [9]] == origList.collate(4)
другой метод, используя inject и 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)
Edit: Исправлена проблема с пустым списком
Проверьте groovy 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 для получения дополнительной информации, потому что есть несколько других параметров, которые дают вам некоторые другие варианты, включая удаление остатка.
Я искал ту же проблему, и я нашел collate()
метод для списков, чтобы быть очень полезным.
array.collate(2)
здесь ссылка на документацию.
нет ничего встроенного, но это не трудно написать:
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
вот альтернативная версия, которая использует динамические функции Groovy для добавления метода split в класс List, который делает то, что вы ожидаете:
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)
Я знаю, что это супер старый-но для тех, кто хочет разделить список на равные разделы (с остатками), и вы пропустите комментарий Тима к исходному сообщению, самым последним способом groovy является метод collate () для объектов списка, который был доступен с Groovy 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)
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
}
этот вопрос старый, но я все равно хочу поделиться тем, что я придумал, чтобы разделить лист на равные листы.
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)
}