转换2元数组的数组的一个哈希，其中重复键追加额外的价值 [英] Convert array of 2-element arrays into a hash, where duplicate keys append additional values

问题描述

例如

给定一个数组：

 阵列= [[：一，：B]，[：一，：C]，[C：：B]]
 

返回下面的哈希：

 散= {：A =＆GT; [：B，：C]：C =＆GT; [：B]}
 

散散= [阵列] 覆盖previous协会，生产：

 散= {：A =＆GT; C：C =＆GT; ：B}
 

解决方案

使用功能性婴儿的步骤：

  IRB：01.0＆GT;数组= [[：一，：B]，[：一，：C]，[：C，：B]]
＃=＆GT; [[：一，：B]，[：一，：C]，[：C，：B]]IRB：02.0＆GT; array.group_by（安培;：先）
＃=＆GT; {：一个= GT; [[：一，：B]，[：一，：C]，：C =＆GT; [：C，：B]]}IRB：03.0＆GT; array.group_by（安培;：第一）.MAP {| K，A | [K，a.map（安培;：最后一个）]}
＃=＆GT; [[：一，[：B，：C]，[C：[：B]]IRB：04.0＆GT;哈希[array.group_by（安培;：第一）.MAP {| K，A | [K，a.map（安培;：最后一个）]}]
＃=＆GT; {：A =＆GT; [：B，：C]：C =＆GT;：B]}
 

使用命令式编程风格：

  IRB：10.0＆GT; H = {Hash.new | H，K | H [k]的= []}
＃=＆GT; {}IRB：11.0＆GT; array.each {| K，V | H [k]的＆下;＆下; v}
＃=＆GT; [[：一，：B]，[：一，：C]，[：C，：B]]IRB：12.0＆GT; H
＃=＆GT; {：A =＆GT; [：B，：C]：C =＆GT;：B]}
 

作为当务之急单行：

  IRB：13.0＆GT; H = {Hash.new | H，K | H [k]的= []} .tap {| H | array.each {| K，V | H [k]的＆下;＆下; V}}
＃=＆GT; {：A =＆GT; [：B，：C]：C =＆GT;：B]}
 

或者用大家最喜欢的注：

  IRB：14.0＆GT; array.inject（Hash.new {| H，K | H [K] = []}）{| h时，（K，V）| H [k]的＆下;＆下;伏; H }
＃=＆GT; {：A =＆GT; [：B，：C]：C =＆GT;：B]}
 

如果你真的想拥有单一数值没有发生碰撞为一个数组，您可以取消阵列他们作为一个后处理步骤，或者使用不同的哈希积累的策略，只有在产生碰撞的数组。另外，包装你的头周围这样的：

  IRB：17.0＆GT;哈希= array.map {|对|哈希[*一双]}＃合并许多小型哈希
＃=＆GT; [{：A =＆GT;：B}，{：A =＆GT;：C}，{：C =＆GT;：B}]IRB：18.0＆GT; hashes.inject {| H1，H2 | h1.merge（H2）{| * A |一个[1,2]}}
＃=＆GT; {：A =＆GT; [：B，：C]：C =＆GT;：B}
 

For example

Given an array:

array = [[:a,:b],[:a,:c],[:c,:b]]

Return the following hash:

hash = { :a => [:b,:c] , :c => [:b] }

hash = Hash[array] overwrites previous associations, producing:

hash = { :a => :c , :c => :b }

解决方案

Using functional baby steps:

irb:01.0> array = [[:a,:b],[:a,:c],[:c,:b]]
#=> [[:a, :b], [:a, :c], [:c, :b]]

irb:02.0> array.group_by(&:first)
#=> {:a=>[[:a, :b], [:a, :c]], :c=>[[:c, :b]]}

irb:03.0> array.group_by(&:first).map{ |k,a| [k,a.map(&:last)] }
#=> [[:a, [:b, :c]], [:c, [:b]]]

irb:04.0> Hash[ array.group_by(&:first).map{ |k,a| [k,a.map(&:last)] } ]
#=> {:a=>[:b, :c], :c=>[:b]}

Using imperative style programming:

irb:10.0> h = Hash.new{ |h,k| h[k]=[] }
#=> {}

irb:11.0> array.each{ |k,v| h[k] << v }
#=> [[:a, :b], [:a, :c], [:c, :b]]

irb:12.0> h
#=> {:a=>[:b, :c], :c=>[:b]}

As an imperative one-liner:

irb:13.0> h = Hash.new{ |h,k| h[k]=[] }.tap{ |h| array.each{ |k,v| h[k] << v } }
#=> {:a=>[:b, :c], :c=>[:b]}

Or using everyone's favorite inject:

irb:14.0> array.inject(Hash.new{ |h,k| h[k]=[] }){ |h,(k,v)| h[k] << v; h }
#=> {:a=>[:b, :c], :c=>[:b]}

If you really want to have single values not collided as an array, you can either un-array them as a post-processing step, or use a different hash accumulation strategy that only creates an array upon collision. Alternatively, wrap your head around this:

irb:17.0> hashes = array.map{ |pair| Hash[*pair] } # merge many mini hashes
#=> [{:a=>:b}, {:a=>:c}, {:c=>:b}]

irb:18.0> hashes.inject{ |h1,h2| h1.merge(h2){ |*a| a[1,2] } }
#=> {:a=>[:b, :c], :c=>:b}

这篇关于转换2元数组的数组的一个哈希，其中重复键追加额外的价值的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！