将不同的 hash 值切换到一个组合数组，并执行对第一个数组进行排名的计算 - Ruby on rails

Question

我有几个 arrays 包含相同的值，但关联的键不同。 在这种情况下，我有具有相关价格和积分值的团队和车手的名称。 我对每个都使用了 4，但两者都可以有任何数字，都是小数。

# DRIVER AND TEAM ARRAYS
driver_points = { "john" => 20.1, "mike" => 19.3, "paul" => 15.6, "mark" => 1.1 }
driver_price = { "john" => 4.0, "mike" => 5.0, "paul" => 6.0, "mark" => 2.1 }
team_points = { "cowboys" => 20.1, "bears" => 19.3, "lions" => 15.6, "united" => 2.8 }
team_price = { "cowboys" => 1.0, "bears" => 2.0, "lions" => 3.0, "united" => 2.4 }

我已将driver_price和team_price哈希值转换为一个数组，该数组为我提供小于或等于目标值的所有组合。 条件是只能容纳1支车队和3名车手。 我现在想按最高点对这些价格组合进行排名。 所以我希望有一种方法，在我当前的组合中，我可以用每个键的等效点值代替，对点求和，然后按点对组合进行排名。 我也喜欢这样，而不是我的包含数字的组合，而是使用键。

这是我当前的代码（给我目标的所有组合）。 底部还有一条线，是每个组合的总和。

 # ALL COMBINATIONS OF DRIVERS AND TEAMS BASED ON BUDGET AND ARRAY
team = team_price.values.permutation(1).to_a
driver = driver_price.values.permutation(3).to_a
target = 13.5
array = team.product(driver)
res = array.select {|i| i.map(&:sum).sum <= target}.compact
t1 = res.map {|i| i[0]}
d2 = res.map {|i| i[1].flatten.sort}
combo = t1.zip(d2).uniq
full_combo = combo.flatten.each_slice(4).to_a

# TOTAL COST OF COMBINATION
total_cost = combo.map {|budget| budget.map(&:sum).sum}

# OUTPUT
@test1 = full_combo, total_cost

正在输出（所有价格组合和总计组合）：

[[[1.0, 2.1, 4.0, 5.0], [1.0, 2.1, 4.0, 6.0], [2.0, 2.1, 4.0, 5.0], [2.4, 2.1, 4.0, 5.0]], [12.1, 13.1, 13.1, 13.5]]

我想对这些组合进行排名，但要按等效的分值。 所以希望我可以切换点数，对其进行总结，然后根据此对组合进行从高到低的排序，并显示键而不是值。 所以像这样：

1. 将当前组合转换为等效键：

[[cowboys, mark, john, mike], [cowboys, mark, john, paul], [bears, mark, john, mike], [united, mark, john, mike]]

2. 使用它来切换点hash 值并对每个组合求和：

[[60.6], [56.9], [59.8], [43.4]]

3. 然后使用 Points Sums 对每个组合进行排名。 理想 output：

组合	总价	总积分
牛仔，马克，约翰，迈克	12.1	60.6
熊，马克，约翰，迈克	13.1	59.8
牛仔，马克，约翰，保罗	13.1	56.9
联合，马克，约翰，迈克	13.5	43.4

Answer 1

我们得到哈希值team_price 、 driver_price 、 team_points和driver_points以及组合的最高价格，它由一个团队和三个车手组成：

target = 13.5 

---

我们首先需要保存团队和车手的变量。

teams = team_price.keys
  #=> ["cowboys", "bears", "lions", "united"]

drivers = driver_price.keys
  #=> ["john", "mike", "paul", "mark"]

---

展望未来，我们将需要对给定组合的价格和点数求和。 因此，创建一种方法来做到这一点是有意义的。

def add_up(combo, ht, hd)
  t, d = combo
  ht[t] + hd.values_at(*d).sum
end

例如，如果

combo = ["cowboys", ["john", "mike", "paul"]]

那么该组合的总价格是

add_up(combo, team_price, driver_price)
  #=> 16.0

请参阅Hash#values_at和Array#sum 。

---

我们需要计算价格总和不超过target的所有组合的数组。 首先计算三个驱动程序的所有组合。

all_driver_combos = drivers.combination(3).to_a
  #=> [["john", "mike", "paul"], ["john", "mike", "mark"],
  #    ["john", "paul", "mark"], ["mike", "paul", "mark"]]

请参阅数组#combination 。

接下来构建所有组合。

all_combos = teams.product(all_driver_combos)
  #=> [["cowboys", ["john", "mike", "paul"]],
  #    ["cowboys", ["john", "mike", "mark"]],
  #    ["cowboys", ["john", "paul", "mark"]],
  #    ["cowboys", ["mike", "paul", "mark"]],
  #    ["bears", ["john", "mike", "paul"]],
  #    ["bears", ["john", "mike", "mark"]],
  #    ["bears", ["john", "paul", "mark"]],
  #    ["bears", ["mike", "paul", "mark"]],
  #    ["lions", ["john", "mike", "paul"]],
  #    ["lions", ["john", "mike", "mark"]],
  #    ["lions", ["john", "paul", "mark"]],
  #    ["lions", ["mike", "paul", "mark"]],
  #    ["united", ["john", "mike", "paul"]],
  #    ["united", ["john", "mike", "mark"]],
  #    ["united", ["john", "paul", "mark"]],
  #    ["united", ["mike", "paul", "mark"]]]

参见数组#product 。

接下来从all_combos中提取价格总和不超过target的那些。

valid_combos = all_combos.select do |c|
  add_up(c, team_price, driver_price) <= target
end
  #=> [["cowboys", ["john", "mike", "mark"]],
  #    ["cowboys", ["john", "paul", "mark"]],
  #    ["bears", ["john", "mike", "mark"]],
  #    ["united", ["john", "mike", "mark"]]]

如果需要，我们可以替换掉all_driver_combos并链接all_combos ：

valid_combos = teams.product(drivers.combination(3).to_a)
                    .select do |c|
                       add_up(c, team_price, driver_price)<=target
                     end

---

最后，我们希望通过valid_combos valid_combos排序。

ordered = valid_combos.sort_by do |c|
  -add_up(c, team_points, driver_points)
end
  #=> [["cowboys", ["john", "mike", "mark"]],
  #    ["bears", ["john", "mike", "mark"]],
  #    ["cowboys", ["john", "paul", "mark"]],
  #    ["united", ["john", "mike", "mark"]]]

请参阅Enumerable#sort_by 。

请注意，我已经否定了add_up返回的值，因此排序是从大到小。 也可以写

ordered = valid_combos.sort_by do |c|
  add_up(c, team_points, driver_points)
end.reverse

---

我们可以检查ordered的每个元素的总价格和点数，如下所示。

ordered.map do |c|
  { c=>{ price: add_up(c, team_price, driver_price),
         points: add_up(c, team_points, driver_points) } }  
end
  #=> [{["cowboys", ["john", "mike", "mark"]]=>
  #        {:price=>12.1, :points=>60.6}},
  #    {["bears", ["john", "mike", "mark"]]=>
  #        {:price=>13.1, :points=>59.8}},
  #    {["cowboys", ["john", "paul", "mark"]]=>
  #        {:price=>13.1, :points=>56.9}},
  #    {["united", ["john", "mike", "mark"]]=>
  #        {:price=>13.5, :points=>43.3}}]