Arrays 查找最大数量

我有两个阵列和一辆卡车。我得弄清楚一辆卡车能装多少单位。以下是阵列：

boxes = [3, 1, 6]
units_per_box = [2, 7, 4]
truck_size = 6

每个箱子的大小都一样，卡车可以装那么多箱子。我要找出的是卡车上能装的最大单位数量。以下是我到目前为止的情况：

array = []
hash = Hash[boxes.zip units_per_box] => {3=>2, 1=>7, 6=>4}
hash.each { |k, v| k.times { array << v } } => [2, 2, 2, 7, 4, 4, 4, 4, 4, 4]

array=[]
hash=hash[box.zip units\u per\u box]=>{3=>2,1=>7,6=>4}
hash.each{k，v{k.times{array[2,2,2,7,4,4,4,4]

---

现在，我必须在

数组中找到适合卡车的最大项数。数组中的每个数字都是一个盒子，卡车可以容纳6个盒子。只要看看数字，你就可以看到数字应该是27，因为7+（4*5）=27.我怎么能在代码中找出这个问题？我的方向是否正确？
你似乎有很多误解。首先，这似乎无关紧要
每个物品有多少个盒子，因为你的目标是获得最多的单位
卡车

其次，卡车大小本身似乎并不重要。如果前面的假设
是正确的，那么我们只关心每个盒子的单位和最大值
无论卡车大小，始终保持

如果所有这些假设都是正确的，则每个方框[1]

或

7

的单位数将是正确的 在这种情况下，答案是肯定的。再一次，我们似乎需要一些 澄清一下。我会根据需要删除和/或编辑我的问题。

你很接近——你有整数数组，你想要N个最大的，对吗

那只是：

fits_in_truck=[2,2,2,7,4,4,4,4].sort.last（n）
结构中的单位=结构中的配合。总和

总的来说，用一些更有意义的名字来澄清问题：

num\u per\u type=[3,1,6]
盒子单元类型=[2,7,4]
卡车尺寸=6
box\u type\u tally=box\u unit\u types.zip（每种类型的数量）。至
方框=方框\类型\计数。平面\地图do \方框\单位，数量\方框|
[box\u单位]*num\u盒
结束
可装载箱=箱。分拣。最后（卡车尺寸）
可交付单位=可装载箱。总和

据我所知，三种盒子中的每一种都有给定的编号，比如红色、绿色和蓝色。每个盒子都有一个特定的值，这取决于它的颜色。卡车的容量是给定数量的盒子。问题是要确定每种颜色的多少盒子装载到卡车上，以使总价值最大化。我稍后将简化如果只需要最大总值

可以使用以下方法确定最佳解决方案

def load_plan(nbr_boxes, box_value, truck_capacity)
  nbr_boxes.each_index.sort_by { |i| -box_value[i] }.
            each_with_object(Hash.new(0)) do |i,h|
              h[i] = [nbr_boxes[i], truck_capacity].min
              truck_capacity -= h[i]
              break(h) if truck_capacity.zero?
            end
end

最大总值由以下公式得出：

plan.sum { |i,n| n * box_value[i] }
  #=> 27

boxes.sum { |box| plan[box[:name]] * box[:value] }
  #=> 27

步骤如下

a = nbr_boxes.each_index.sort_by { |i| -box_value[i] }
  #=> [1, 2, 0]

这表明索引

1

处的框具有最大值，而索引

0

处的框具有最小值

为了说明剩余的计算，我将使用

put

语句对代码进行说明

a.each_with_object(Hash.new(0)) do |i,h|
  puts "i=#{i}, h=#{h}, nbr_boxes[#{i}]=#{nbr_boxes[i]}"
  h[i] = [nbr_boxes[i], truck_capacity].min
  truck_capacity -= h[i]
  puts "  h=#{h}, truck_capacity=#{truck_capacity}"
  puts "  break #{h} as truck_capacity=0" if truck_capacity.zero? 
  break(h) if truck_capacity.zero?
end
  #=> {1=>1, 2=>5} 

将显示以下内容

i=1, h={}, nbr_boxes[1]=1
  h={1=>1}, truck_capacity=5
i=2, h={1=>1}, nbr_boxes[2]=6
  h={1=>1, 2=>5}, truck_capacity=0
  break {1=>1, 2=>5} as truck_capacity=0

通过将块变量

h

持有的散列定义为

hash.new（0）

我们可以编写

plan[0]
  #=> 0

即使

0

不是

plan

的键。它使用的形式是带参数且无块的。该参数称为默认值。通常，与此处一样，它被设置为零。这意味着如果定义了哈希值

h=hash.new（0）

，

h[k]

将返回默认值（

0

）如果

h

没有键

k

请注意，最后一条语句，

break（h）if truck\u capacity.zero？

，是可选的。我包含它只是为了计算速度

如果不需要装载每种类型箱子的最佳数量，只需要最佳总值，则可以进行一些简化。以下是@engineersmnky在对该问题的评论中建议的方法的一个细微变化：

def optimal_value(nbr_boxes, box_value, truck_capacity)
  nbr_boxes.each_index.
            flat_map { |i| [box_value[i]] * nbr_boxes[i] }.
            sort.
            last(truck_capacity).sum
end

请注意，即使在卡车未满时，此操作也有效：

truck_capacity = 100
[2, 2, 2, 7, 4, 4, 4, 4, 4, 4].last(truck_capacity)
  #=> [2, 2, 2, 7, 4, 4, 4, 4, 4, 4]

---

在设计应用程序时，可以考虑用以下散列数组替换<代码> NBRIX框和<代码> BOXYValue。

boxes = [
  { name: "A", nbr: 3, value: 2 },
  { name: "B", nbr: 1, value: 7 },
  { name: "C", nbr: 6, value: 4 }
]

然后写：

def load_plan(boxes, truck_capacity)
  boxes.sort_by { |box| -box[:value] }.
        each_with_object(Hash.new(0)) do |box,h|
          nbr_to_load = [box[:nbr], truck_capacity].min
          h[box[:name]] = nbr_to_load
          truck_capacity -= nbr_to_load
          break(h) if truck_capacity.zero?
        end
end

最大总值由以下公式得出：

plan.sum { |i,n| n * box_value[i] }
  #=> 27

boxes.sum { |box| plan[box[:name]] * box[:value] }
  #=> 27

如果只需要最大值：

def optimal_value(boxes, truck_capacity)
  boxes.flat_map { |box| [box[:value]] * box[:nbr] }.
        sort.
        last(truck_capacity).
        sum
end

---

我很确定有一个更优化的解决方案，但是我想你可以使用

Array\35; combination

强制执行它，假设每个盒子的单位与盒子的数量直接相关，并且不改变你所做的太多

box.zip（每个盒子的单位数）。flat\u map{|（a，b）|[b]*a}.sort.last（卡车大小）.sum

。如果

每个盒子的单位数

独立于

盒子

，则

盒子.sort.zip（每个盒子的单位数.排序）.平面图{|（a，b）|[b]*a}.sort.last（卡车大小）

可能是另一种选择这些箱子尺寸或每个箱子都包含一定数量的单位吗？这似乎是一个模棱两可的问题。必须装载箱子中的全部或全部。卡车的容量是满箱的。卡车可以容纳6个箱子（这很重要），因为箱子的大小都相同。问题实际上是“单位”所有尺寸都相同，因此在这种情况下，一个盒子可以清楚地容纳至少7个“单位”，因为至少一个盒子中有7个单位。你是什么意思？你的答案是我对OP的评论的更长版本，但方法完全相同。

boxes.sum { |box| plan[box[:name]] * box[:value] }
  #=> 27

def optimal_value(boxes, truck_capacity)
  boxes.flat_map { |box| [box[:value]] * box[:nbr] }.
        sort.
        last(truck_capacity).
        sum
end

optimal_value(boxes, truck_capacity)
  #=> 27