如何在Ruby中"逆转"？

Question

我不知道如何用正确的数学术语来称呼它.考虑一个采用两位数的方法:

 def num_of_sum(total, group_count)

 end

where total是整数,group_count是一个整数.

我怎样才能获得一个"精确"分组的整数数组 - group_count-length总和直到total.

我的规格看起来像:

describe "number to sum of" do
  it "grabs all numbers" do
    expect(num_of_sum(10, 2)).to eq([5,5])
    expect(num_of_sum(10, 3)).to eq([3,3,4])
    expect(num_of_sum(20, 3)).to eq([6,7,7])
    expect(num_of_sum(100, 3)).to eq([33,33,34])
    expect(num_of_sum(100, 2)).to eq([50,50])
  end
end

我尝试了这个,它有效:

def num_of_sum(total, in_groups_of)
  result = []
  section_count ||= (total.to_f / in_groups_of.to_f).round

  while(total > 0)
    total -= section_count

    if (total - section_count) < 0 && (total + section_count).even?
      section_count += total
      total -= total
    end

    result << section_count
  end

  result
end

但是,例如,此规范不起作用:

 expect(num_of_sum(67,5)).to eq([13,13,13,14,14]) 

我需要数组包含尽可能彼此接近的数字.但阵列仅限于长度group_count.

---

有人知道这个数学名称是什么,所以我可以更准确地搜索一下吗？

Answer 1

对此的数学术语是整数分区

更直接的方法是观察如果你对总数进行整数除法(向下舍入)除以组的数量,那么你的总和就会缩短整数mod_of_groups,所以你只需要在整个数组中分配这个数量:

def even_partition(total, number_of_groups)
  quotient, remainder = total.divmod(number_of_groups)
  (number_of_groups-remainder).times.collect {quotient} +
  remainder.times.collect { quotient + 1}    
end

Answer 2

一个天真的实现是这样的:

我们举个例子吧(20, 3).你想要三个数字.

20 / 3 # => 6

这是您的"基础"价值.创建一个由三个六个组成的数组[6, 6, 6].这将让你18.现在你必须尽可能平均分配剩余的2.例如,枚举数组元素并将每个元素递增1,直到您没有要分发的值.结果是[7, 7, 6].我认为这很好.

可能的(工作)实施:

def breakdown(total, group_count)
  avg_value, extra = total.divmod(group_count)

  result = Array.new(group_count, avg_value)
  extra.times do |i|
    result[i] += 1
  end

  result
end

breakdown(10, 2) == [5, 5] # => true
breakdown(10, 3) == [4, 3, 3] # => true
breakdown(20, 3) # => [7, 7, 6]

Answer 3

def n_parts(num, groupcount)
  div, mod = num.divmod(groupcount)
  Array.new(groupcount-mod, div) + Array.new(mod, div+1)
end

n_parts(100,3) => [33, 33, 34]

Docs到Array.new和Fixnum.divmod