tl;dr I want to make an array from the division by 5 results:
20 => [5,5,5,5]
16 => [5,5,5,1]
7 => [5,2]
My current implementation is straightforward yet too large. How can I make it simpler and shorter?
max_count = 5
total_count = input_value
count_array = []
div = total_count / max_count
mod = total_count % max_count
div.times { count_array << max_count }
count_array << mod unless mod == 0
total_count.div.times { count_array << max_count } is [max_count] * count_arraymax_count = 5
[*[max_count] * (input_value / max_count), input_value % max_count] - [0]
Alternatively, using divmod
max_count = 5
n, mod = input_value.divmod(max_count)
[*[max_count] * n, mod] - [0]
Last line can also be written as:
(Array.new(n) { max_count } << mod) - [0]
or as Stefan suggested in the comment, using Numeric#nonzero?:
Array.new(n, max_count).push(*mod.nonzero?)
([max_count] * n).tap { |arr| arr << mod if mod > 0 }. rem may be a better name than mod.
nonzero?, today I learned :) I'll edit and add it.One option more:
d = 5
n = 24
Array.new(n/d){d}.tap{ |a| a << n%d if (n%d).nonzero? }
#=> [5, 5, 5, 5, 4]
You can try this as well.
max=5
num=48
q, r=num.divmod(max) # => [9, 3]
Array.new.fill(max, 0, q).push(r.nonzero?).compact
# => [5, 5, 5, 5, 5, 5, 5, 5, 5, 3]
What about this?
[20].tap{|a| a.push(5, a.pop - 5) while a.last > 5} # => [5, 5, 5, 5]
[16].tap{|a| a.push(5, a.pop - 5) while a.last > 5} # => [5, 5, 5, 1]
[7] .tap{|a| a.push(5, a.pop - 5) while a.last > 5} # => [5, 2]
16 => [5,5,5,1]20.divmod(5) #=> [4, 0]. Contains the all the information you require i.e. the quotient and the remainder.