Ruby 防止密钥重写时哈希到哈希转换的数组

您将如何转换：

x = [
 {"a" => ["a","b","c","d","e"]}, 
 {"f" => ["f","g","h","i","j","k","l","m","n"]}, 
 {"f" => ["o","p"]}
]

进入：

{
 "a"=>["a", "b", "c", "d", "e"], 
 "f" => ["f","g","h","i","j","k","l","m","n"]}, 
 "f01"=>["o", "p"] 
}

我最初使用的是

x.reduce({},:update)

但是，这会覆盖第一个“f”（因为键是唯一的）

---

我已经搜索了答案，但没有找到任何适合这种情况的答案。

假设

f01

的

01

部分只是一个计数器，您不关心该数字的格式，您可以执行以下操作：

def reduce\u update\u incr（arr）
键计数={}
arr.reduce（{}）do|memo，h|
h、 每个都有| k，v|
k=k+（键计数[k]=（键计数[k]| 0）+1）。如果备忘录中包含？（k）
备忘录[k]=v
结束
备忘录
结束
结束
减少更新增量（x）
#{“a”=>[“a”、“b”、“c”、“d”、“e”]，
#“f”=>[“f”、“g”、“h”、“i”、“j”、“k”、“l”、“m”、“n”]，
#“f1”=>[“o”，“p”]}

---

糟糕。

假设

f01

的

01

部分只是一个计数器，您不关心该数字的格式，您可以执行以下操作：

def reduce\u update\u incr（arr）
键计数={}
arr.reduce（{}）do|memo，h|
h、 每个都有| k，v|
k=k+（键计数[k]=（键计数[k]| 0）+1）。如果备忘录中包含？（k）
备忘录[k]=v
结束
备忘录
结束
结束
减少更新增量（x）
#{“a”=>[“a”、“b”、“c”、“d”、“e”]，
#“f”=>[“f”、“g”、“h”、“i”、“j”、“k”、“l”、“m”、“n”]，
#“f1”=>[“o”，“p”]}

---

哎呀。

你可以使用

注入

如下：

 > x.inject({}){|r,h| r[h.keys.first] ||= [] ; r[h.keys.first] << h.values.first; r}
  => {"a"=>[["a", "b", "c", "d", "e"]], 
      "f"=>[["f", "g", "h", "i", "j", "k", "l", "m", "n"], ["o", "p"]]} 

>x.inject（{}）{r，h | r[h.keys.first]| |=[]；r[h.keys.first]{“a”=>[[“a”、“b”、“c”、“d”、“e”]，
“f”=>[“f”、“g”、“h”、“i”、“j”、“k”、“l”、“m”、“n”]、[“o”、“p”]}

请注意，对于同一个密钥，您将获得多个数组。（即

“f”

）

---

结果的散列与您要求的略有不同，但可能更易于使用，因为与修改的键没有混淆。

您可以使用

inject

，如下所示：

 > x.inject({}){|r,h| r[h.keys.first] ||= [] ; r[h.keys.first] << h.values.first; r}
  => {"a"=>[["a", "b", "c", "d", "e"]], 
      "f"=>[["f", "g", "h", "i", "j", "k", "l", "m", "n"], ["o", "p"]]} 

x = [
 {"a" => ["a","b","c","d","e"]}, 
 {"f" => ["f","g","h","i","j","k","l","m","n"]}, 
 {"f" => ["o","p"]}
]

res = x.collect{|d| d.first}.each_with_object({}) do |(k,v), h, n = "00"|
  (k += n.next!) if (h.key? k)
  h[k] = v
end

res == {
 "a"=>["a", "b", "c", "d", "e"], 
 "f" => ["f","g","h","i","j","k","l","m","n"], 
 "f01"=>["o", "p"] 
}

>x.inject（{}）{r，h | r[h.keys.first]| |=[]；r[h.keys.first]{“a”=>[[“a”、“b”、“c”、“d”、“e”]，
“f”=>[“f”、“g”、“h”、“i”、“j”、“k”、“l”、“m”、“n”]、[“o”、“p”]}

请注意，对于同一个密钥，您将获得多个数组。（即

“f”

）

---

生成的哈希与您要求的略有不同，但可能更易于使用，因为与修改的键没有混淆。

更改键后生成的哈希将导致一个非常困难的问题：如何轻松查找生成的哈希及其数组

x = [
 {"a" => ["a","b","c","d","e"]}, 
 {"f" => ["f","g","h","i","j","k","l","m","n"]}, 
 {"f" => ["o","p"]}
]

res = x.collect{|d| d.first}.each_with_object({}) do |(k,v), h, n = "00"|
  (k += n.next!) if (h.key? k)
  h[k] = v
end

res == {
 "a"=>["a", "b", "c", "d", "e"], 
 "f" => ["f","g","h","i","j","k","l","m","n"], 
 "f01"=>["o", "p"] 
}

我建议您重新考虑所需的散列类型。与其创建难以查找且与原始散列键关联微弱的新散列键，不如重用原始键并创建指向数组数组的散列键。从更简单的散列起始数组开始：

x = [ {'a' => ['a', 'b']}, {'f' => ['f', 'g']}, {'f' => ['o', 'p']} ] 查找变得更加简单：

hash['f'][0]
# => ["f", "g"]
hash['f'].last
# => ["o", "p"]

您可以保持原始阵列的分离，同时获得更具逻辑性和更简单的查找

如果您需要知道一个哈希分配了多少子数组，也很容易：

hash['f'].size
# => 2

如果您想迭代所有的

'f'

条目，这将使您的设计变得复杂和困难，只需执行以下操作：

hash['f'].each do |f|
  ...
end

或：

---

在更改键之后，生成的哈希将导致一个非常困难的问题：如何轻松地查找生成的哈希及其数组

我建议您重新考虑所需的散列类型。与其创建难以查找且与原始散列键关联微弱的新散列键，不如重用原始键并创建指向数组数组的散列键。从更简单的散列起始数组开始：

x = [ {'a' => ['a', 'b']}, {'f' => ['f', 'g']}, {'f' => ['o', 'p']} ] 查找变得更加简单：

hash['f'][0]
# => ["f", "g"]
hash['f'].last
# => ["o", "p"]

您可以保持原始阵列的分离，同时获得更具逻辑性和更简单的查找

如果您需要知道一个哈希分配了多少子数组，也很容易：

hash['f'].size
# => 2

如果您想迭代所有的

'f'

条目，这将使您的设计变得复杂和困难，只需执行以下操作：

hash['f'].each do |f|
  ...
end

或：

---

重命名方案有什么要求吗？如果没有，那就很简单了。如果输入是

[{“a”=>[1]，“b”=>[2]}，{“a”=>[3]，“a01”=>[4]}，该怎么办

？您试图将一组散列合并为一个散列，同时在发生任何键冲突的情况下保持唯一性，但生成的散列将非常难以搜索或操作。如果您解释一下您的用例，这将非常有帮助。看起来您正在走向一个受伤的世界CTE输出不是有效的Ruby。

“f01”

的规则是什么？数字总是用一个

“0”

填充，还是填充为两位数字，或者，…？重命名方案是否有任何要求？如果没有，则非常简单。如果输入是

[{“a”=>[1]，“b”=>[2]，{“a”=>[3]，“a01”=>[4]}，该怎么办

？您试图将一组散列合并为一个散列，同时在发生任何键冲突的情况下保持唯一性，但生成的散列将非常难以搜索或操作。如果您解释一下您的用例，这将非常有帮助。看起来您正在走向一个受伤的世界cted输出无效。什么是

“f01”

的规则？数字总是用一填充

“0”

，还是填充为两位数，或者，

直到（h[k]。nil？

可以写入

如果h.key？（k）

直到（h[k]。nil？基本上是

如果！（h[k]。nil？

与

如果h.key？（k）

直到（h[k].nil？

可以写

如果h.key？（k）

直到（h[k].nil？

基本上是

如果！（h[k].nil？

与

如果h.key？（k）

相比。在这里测试了所有建议之后，这是最可行的。非常感谢您的努力！在测试了所有建议之后，h