Dividing elements of a ruby array into an exact number of (nearly) equal-sized sub-arrays [duplicate]

Question

I need a way to split an array in to an exact number of smaller arrays of roughly-equal size. Anyone have any method of doing this?

For instance

a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13]  groups = a.method_i_need(3) groups.inspect     => [[1,2,3,4,5], [6,7,8,9], [10,11,12,13]] 

Note that this is an entirely separate problem from dividing an array into chunks, because a.each_slice(3).to_a would produce 5 groups (not 3, like we desire) and the final group may be a completely different size than the others:

[[1,2,3], [4,5,6], [7,8,9], [10,11,12], [13]]  # this is NOT desired here. 

In this problem, the desired number of chunks is specified in advance, and the sizes of each chunk will differ by 1 at most.

Answer 1

You're looking for Enumerable#each_slice

a = [0, 1, 2, 3, 4, 5, 6, 7] a.each_slice(3) # => #<Enumerator: [0, 1, 2, 3, 4, 5, 6, 7]:each_slice(3)> a.each_slice(3).to_a # => [[0, 1, 2], [3, 4, 5], [6, 7]] 

Answer 2

Perhaps I'm misreading the question since the other answer is already accepted, but it sounded like you wanted to split the array in to 3 equal groups, regardless of the size of each group, rather than split it into N groups of 3 as the previous answers do. If that's what you're looking for, Rails (ActiveSupport) also has a method called in_groups:

a = [0,1,2,3,4,5,6] a.in_groups(2) # => [[0,1,2,3],[4,5,6,nil]] a.in_groups(3, false) # => [[0,1,2],[3,4], [5,6]] 

I don't think there is a ruby equivalent, however, you can get roughly the same results by adding this simple method:

class Array; def in_groups(num_groups)   return [] if num_groups == 0   slice_size = (self.size/Float(num_groups)).ceil   groups = self.each_slice(slice_size).to_a end; end  a.in_groups(3) # => [[0,1,2], [3,4,5], [6]] 

The only difference (as you can see) is that this won't spread the "empty space" across all the groups; every group but the last is equal in size, and the last group always holds the remainder plus all the "empty space".

Update: As @rimsky astutely pointed out, the above method will not always result in the correct number of groups (sometimes it will create multiple "empty groups" at the end, and leave them out). Here's an updated version, pared down from ActiveSupport's definition which spreads the extras out to fill the requested number of groups.

def in_groups(number)   group_size = size / number   leftovers = size % number    groups = []   start = 0   number.times do |index|     length = group_size + (leftovers > 0 && leftovers > index ? 1 : 0)     groups << slice(start, length)     start += length   end    groups end