ruby - 散列中具有多个值的重复值之和

Question

给定一个如下所示的散列:

h = {
  "0" => ["1", "true", "21"],
  "1" => ["2", "true", "21"],
  "2" => ["3", "false", "21"],
  "3" => ["4", "true", "22"],
  "4" => ["5", "true", "22"],
  "5" => ["6", "true", "22"],
  "6" => ["7", "false", "21"]
}

我想在索引 1 和 2 处具有相同元素的数组中找到位置 0 处的元素总和，然后返回像下面这样的散列:

{
  0 => ["3", "true", "21"],
  1 => ["10", "false", "21"],
  2 => ["15", "true", "22"]
}

因为有两个索引为 1 和 2 的数组，其值为 "true" 和 "21" ，例如，我想对这两个数组的索引 0 的整数值求和。

如何将此问题顶部的示例哈希转换为其下方的结果哈希？

Answer 1

代码

def group_em(h)    
  h.group_by { |_,v| v.drop(1) }.
    transform_values do |a|
      a.transpose.
        last.
        map(&:first).
        sum(&:to_i).
        to_s
    end.
    each_with_index.
    with_object({}) { |((a,v),i),g| g[i] = [v,*a] }
end

示例

h = {
  "0" => ["1", "true",  "21"],
  "1" => ["2", "true",  "21"],
  "2" => ["3", "false", "21"],
  "3" => ["4", "true",  "22"],
  "4" => ["5", "true",  "22"],
  "5" => ["6", "true",  "22"],
  "6" => ["7", "false", "21"]
}

group_em(h)
  #=> {0=>["3",  "true",  "21"],
  #    1=>["10", "false", "21"],
  #    2=>["15", "true",  "22"]}

解释

主要步骤

对于上面的散列h，主要步骤如下。

p = h.group_by { |_,v| v.drop(1) }
  #=> {["true",  "21"]=>[["0", ["1", "true",  "21"]],
  #                      ["1", ["2", "true",  "21"]]],
  #    ["false", "21"]=>[["2", ["3", "false", "21"]],
  #                      ["6", ["7", "false", "21"]]],
  #    ["true",  "22"]=>[["3", ["4", "true",  "22"]],
  #                      ["4", ["5", "true",  "22"]],
  #                      ["5", ["6", "true",  "22"]]]}
q = p.transform_values do |a|
      a.transpose.
        last.
        map(&:first).
        sum(&:to_i).
        to_s
    end
  #=> {["true", "21"]=>"3", ["false", "21"]=>"10", ["true", "22"]=>"15"}
enum0 = q.each_with_index
  #=> #<Enumerator: {["true", "21"]=>"3", ["false", "21"]=>"10",
  #     ["true", "22"]=>"15"}:each_with_index>
enum1 = enum0.with_object({})
  #=> #<Enumerator: #<Enumerator: {["true", "21"]=>"3", ["false", "21"]=>"10",
  #     ["true", "22"]=>"15"}:each_with_index>:with_object({})>
enum1.each { |((a,v),i),g| g[i] = [v,*a] }
  #=> {0=>["3", "true", "21"],
  #    1=>["10", "false", "21"],
  #    2=>["15", "true", "22"]}

通过将枚举器 enum1 转换为数组，我们可以看到将生成并传递给 block 的值:

enum1.to_a
  #=> [[[[["true", "21"], "3"], 0], []],
  #    [[[["false", "21"], "10"], 1], []],
  #    [[[["true", "22"], "15"], 2], []]]

如果将 enum0 的返回值与 enum1 的返回值进行比较，您可以将后者视为一个复合枚举器，尽管 Ruby 确实如此不使用该术语。

Hash#transform_values 的详细信息

现在让我们更仔细地看看q 的计算。 p 的第一个值由 Hash#transform_values 传递给 block (在 MRI 2.4 中首次亮相)并成为 block 变量 a 的值:

a = p.first.last
  #=> [["0", ["1", "true", "21"]], ["1", ["2", "true", "21"]]]

区 block 计算如下。

b = a.transpose
  #=> [["0", "1"], [["1", "true", "21"], ["2", "true", "21"]]]
c = b.last
  #=> [["1", "true", "21"], ["2", "true", "21"]]
d = c.map(&:first) # ~same as c.map { |a| a.first }
  #=> ["1", "2"] 
e = e.sum(&:to_i)  # ~same as e.sum { |s| s.to_i }
  #=> 3
e.to_s
  #=> "3"

我们看到值 a 已转换为 "3"。计算 q 的其余计算类似。

文档链接

您可以在以下类链接中找到我使用的方法的文档 Array (drop、transpose、last、first 和sum)，Integer (to_s), String (to_i) 和 Enumerator (with_object 和 next)，以及模块 Enumerable (group_by、map 和 each_with_index)。

嵌套对象的分解

还有一个棘手的问题我想提一下。就是这条线

enum1.each { |((a,v),i),g| g[i] = [v,*a] }

我以这样一种方式编写了 block 变量，以分解由枚举器 enum1 生成并传递给 block 的值。我敢肯定，对于新手来说，它一定看起来很有气势，但如果您按部就类地进行操作，情况还不错，正如我将解释的那样。

首先，假设我有一个 block 变量 r (enum1.each { |r|...})。生成第一个值并将其传递给 block ，为 r 赋值:

r = enum1.next
  #=> [[[["true", "21"], "3"], 0], []]

然后我们可以在 block 中执行以下语句来分解(消除歧义)r，如下所示:

((a,v),i),g = r
  #=> [[[["true", "21"], "3"], 0], []]

产生以下作业:

a #=> ["true", "21"]
v #=> "3"
i #=> 0
g #=> []

将 block 中的|r|替换为|((a,v),i),g|是等价的，也更简单。

如果您研究 enum1.next 生成的嵌套数组中括号的位置，您将了解我如何确定在编写 block 变量时需要括号的位置。这种嵌套数组和其他对象的分解是一种非常方便和强大的功能或 Ruby，但未得到充分利用。