如何将一个整数分解为一个整数数组

Question

可以说我有一些“事物”，例如7。

但我可以将这些“东西”存储在最大“2”单位的组中。所以，我需要做的是这样的：

7 ----> [2, 2, 2, 1] 

最明显的方法，如果简单地做一个循环遍历它

def decompose(qty, group_max) 
    ret = [] 

    while qty > 0 
     if qty < group_max 
      ret.push qty 
      qty = 0 
     else 
      ret.push group_max 
      qty -= group_max 
     end 
    end 

    ret 

end 

decompose 7, 2 

虽然这个工程...这是不是真的ellegant。我想知道如果可能有整数或数组结构中的方法，我可以用它来改善此代码。

我发现清洁剂做的事情一样

myarray.map {|x| ... } 

，我想知道是否有类似的东西，可能会帮助我与此有关。

Answer 1

你可以做到这一点是：

qty = 15 # say 
group_size = 2 
count_of_groups = qty/group_size 
result = [group_size] * count_of_groups 
remaining = qty % group_size 
result += [remaining] if remaining != 0 
result  # [2, 2, 2, 2, 2, 2, 2, 1] 

Answer 2

我会拿Array构造的优势：第一放慢参数元素的数量，第二个参数的价值。

def decompose(qty, group_max) 
    result = Array.new(qty/group_max, group_max) 
    remainder = qty % group_max 
    remainder == 0 ? result : result.push(remainder) 
end 

decompose(7, 2) 
=> [2, 2, 2, 1] 

甲一行溶液

def decompose(qty, group_max) 
    (Array.new(qty/group_max, group_max) + [qty % group_max]).reject(&:zero?) 
end 

Answer 3

val, max = 8, 3 
([max] * (val/max)).tap do |arr| 
    arr << val % max unless (val % max).zero? 
end 
#⇒ [3, 3, 2] 

val, max = 7, 2 
([max] * (val/max)).tap do |arr| 
    arr << val % max unless (val % max).zero? 
end 
#⇒ [2, 2, 2, 1] 

甚至：

([max] * (val/max) + [val % max]).reject &:zero? 

Answer 4

def decompose(qty, group_max) 
    q, r = qty.divmod(group_max) 
    (Array.new(q) { group_max }) + (r > 0 ? [r] : []) 
end 

Answer 5

divmod

人吗？

qty = 15 # say 
group_size = 2 

d, r = qty.divmod(group_size) 
Array.new(d, group_size) << r # => [2, 2, 2, 2, 2, 2, 2, 1] 

Answer 6

另一种方法对皮肤的猫：

比方说，我有许多的“东西”，比如7

让我们用一个数组来表示，每个nil是一个 “东西”：

Array.new(7) 
#=> [nil, nil, nil, nil, nil, nil, nil] 

但我可以存储的最大“2”单元组这个“东西”：

each_slice能做到这一点：

Array.new(7).each_slice(2).to_a 
#=> [[nil, nil], [nil, nil], [nil, nil], [nil]] 

要获得各组的“东西”数量：

Array.new(7).each_slice(2).map(&:length) 
#=> [2, 2, 2, 1] 

Answer 7

def decompose(n, grp_size) 
    nbr_groups, remainder = n.divmod(grp_size) 
    [grp_size]*nbr_groups << remainder 
end 

decompose(23, 3) 
    #=> [3, 3, 3, 3, 3, 3, 3, 2]