arrays - 什么是 'Ruby way' 来识别哈希中的重复值？

Question

我在 macOS Catalina 上使用 Ruby 2.7.x。

我有多达 100 万个键值元组。 键是字符串并且保证是唯一的。 这些值是字符串，可能包含重复项(或一式三份或更多)。 鉴于键的唯一性，散列似乎是它们的自然数据结构。 所以如果我从包含所有键值元组的 original_hash 开始， 我想以 uniques_hash 结束，它包含所有且仅包含唯一的键值元组， 和 duplicates_hash，包含所有具有重复值的键。

与内存效率或速度相比，我对优化清晰度和 Ruby 惯用语更感兴趣 - 我不希望经常运行此代码，而且我有足够的 RAM。

如果我转换为两个数组，我可以在值数组中找到唯一值——但我如何保证使用正确的 key 重新配对？这是解决这个问题的正确方法吗？

非常感谢您的帮助!

Answer 1

假设

original_hash = {:a=>1, :b=>2, :c=>2, :d=>2, :e=>3, :f=>4, :g=>4}

如果您只对返回哈希值感兴趣 uniques_hash包含唯一值，您可以编写以下内容。

uniques_hash = original_hash.invert.invert
  #=> {:a=>1, :d=>2, :e=>3, :g=>4}

中间步骤是

original_hash.invert
  #=> {1=>:a, 2=>:d, 3=>:e, 4=>:g}

参见 Hash#invert .注意 uniques_hash ，正如定义的那样，它本身并不是唯一的。它可以是以下任何一项。

{:a=>1, :b=>2, :e=>3, :f=>4}
{:a=>1, :b=>2, :e=>3, :g=>4}
{:a=>1, :c=>2, :e=>3, :f=>4}
{:a=>1, :c=>2, :e=>3, :g=>4}
{:a=>1, :d=>2, :e=>3, :f=>4}
{:a=>1, :d=>2, :e=>3, :g=>4}

另一种方法是使用 Enumerable#uniq和 Array#to_h .

unique_hash = original_hash.uniq(&:last).to_h
  #=> {:a=>1, :b=>2, :e=>3, :f=>4} 

中间计算是

original_hash.uniq(&:last)
  #=> [[:a, 1], [:b, 2], [:e, 3], [:f, 4]]

这是

的简写

original_hash.uniq { |_k,v| v }

---

据推测，duplicates_hash 的每个键是 original_hash 中的一个值该键的值是这些键的数组 k在 original_hash为此 original_hash[k] == v .

一种计算duplicates_hash的方法如下。

duplicates_hash = original_hash.each_with_object({}) do |(k,v),h|
  h[v] = (h[v] || []) << k
end
  #=> {1=>[:a], 2=>[:b, :c, :d], 3=>[:e], 4=>[:f, :g]}

这样写也可以

duplicates_hash = original_hash.
  each_with_object(Hash.new { |h,k| h[k] = [] }) { |(k,v),h| h[v] << k }
  #=> {1=>[:a], 2=>[:b, :c, :d], 3=>[:e], 4=>[:f, :g]}

参见 Hash::new .两种形式都等同于

duplicates_hash = original_hash.each_with_object({}) do |(k,v),h|
  h[v] = [] unless h.key?(v)
  h[v] << k
end

将 block 变量写为 |(k,v),h|利用array decomposition .

我们有一个枚举器，它将生成值并将它们传递给它的 block 。

enum = original_hash.each_with_object({})
  #=> #<Enumerator: {:a=>1, :b=>2, :c=>2, :d=>2, :e=>3, :f=>4, :g=>4}:
  #     each_with_object({})> 

枚举器是 Enumerator 类的实例.

生成枚举器的第一个值，并为 block 变量赋值，如下所示:

(k,v),h = enum.next
  #=> [[:a, 1], {}]

可以看到数组分解将这个包含两个元素的数组拆分如下:

k #=> :a 
v #=> 1 
h #=> {} 

注意左边的括号是如何对应于右边的内括号的。然后使用这些变量执行 block 计算。

h[v] = (h[v] || []) << k
  #=> [:a]

现在，

h #=> {1=>[:a]}

然后由枚举器生成下一个值并执行分 block 计算。

(k,v),h = enum.next
  #=> [[:b, 2], {1=>[:a]}] 
k #=> :b 
v #=> 2 
h #=> {1=>[:a]} 
h[v] = (h[v] || []) << k

现在

h #=> {1=>[:a], 2=>[:b]} 

这一直持续到

enum.next
  #=> Stop Interation (exception)

导致 Ruby 返回 h 的值.

---

请注意，通过计算 duplicates_hash首先我们可以计算uniques_hash如下。

keeper_keys = duplicates_hash.values.map(&:first)
  #=> [:a, :b, :e, :f] 
unique_keys = original_hash.slice(*keeper_keys)
  #=> {:a=>1, :b=>2, :e=>3, :f=>4} 

或

unique_keys = original_hash.slice(*duplicates_hash.values.map(&:first))
  #=> {:a=>1, :b=>2, :e=>3, :f=>4}

参见 Hash#slice .如果一个人因为偏爱某些键而感到内疚，那么他可以改写

unique_keys = original_hash.slice(*duplicates_hash.values.map(&:sample))
  #=> {:a=>1, :b=>2, :e=>3, :g=>4}

参见 Array#sample .