在Ruby中哈希颠倒？

Question

我已经得到了格式的哈希：

{key1 => [a, b, c], key2 => [d, e, f]} 

，我想直到结束：

{ a => key1, b => key1, c => key1, d => key2 ... } 

什么是实现这一目标的最简单的方法？

我正在使用Ruby on Rails。

UPDATE

OK，我设法提取从服务器日志真正的对象，它正在通过AJAX推。

Parameters: {"status"=>{"1"=>["1", "14"], "2"=>["7", "12", "8", "13"]}} 

Answer 1

hash = {:key1 => ["a", "b", "c"], :key2 => ["d", "e", "f"]} 

第一变型

hash.map{|k, v| v.map{|f| {f => k}}}.flatten 
#=> [{"a"=>:key1}, {"b"=>:key1}, {"c"=>:key1}, {"d"=>:key2}, {"e"=>:key2}, {"f"=>:key2}] 

或

hash.inject({}){|h, (k,v)| v.map{|f| h[f] = k}; h} 
#=> {"a"=>:key1, "b"=>:key1, "c"=>:key1, "d"=>:key2, "e"=>:key2, "f"=>:key2} 

UPD

OK，你的哈希：

hash = {"status"=>{"1"=>["1", "14"], "2"=>["7", "12", "8", "13"]}} 
hash["status"].inject({}){|h, (k,v)| v.map{|f| h[f] = k}; h} 
#=> {"12"=>"2", "7"=>"2", "13"=>"2", "8"=>"2", "14"=>"1", "1"=>"1"} 

Answer 2

如果你正在寻找扭转此格式的哈希，下面可以帮助你：

a = {:key1 => ["a", "b", "c"], :key2 => ["d", "e", "f"]} 
a.inject({}) do |memo, (key, values)| 
    values.each {|value| memo[value] = key } 
    memo 
end 

这将返回：

{"a"=>:key1, "b"=>:key1, "c"=>:key1, "d"=>:key2, "e"=>:key2, "f"=>:key2} 

Answer 3

new_hash={} 
hash = {"key1" => ['a', 'b', 'c'], "key2" => ['d','e','f']} 
hash.each_pair{|key, val|val.each{|v| new_hash[v] = key }} 

这给

new_hash # {"a"=>"key1", "b"=>"key1", "c"=>"key1", "d"=>"key2", "e"=>"key2", "f"=>"key2"} 

Answer 4

好的，我们来猜吧。你说你有一个阵列，但我同意Benoit，你可能有一个哈希。一种功能性的方法：

h = {:key1 => ["a", "b", "c"], :key2 => ["d", "e", "f"]} 
h.map { |k, vs| Hash[vs.map { |v| [v, k] }] }.inject(:merge) 
#=> {"a"=>:key1, "b"=>:key1, "c"=>:key1, "d"=>:key2, "e"=>:key2, "f"=>:key2} 

另外：

h.map { |k, vs| Hash[vs.product([k])] }.inject(:merge) 
#=> {"a"=>:key1, "b"=>:key1, "c"=>:key1, "d"=>:key2, "e"=>:key2, "f"=>:key2} 

Answer 5

一种方式来实现你在找什么：

arr = [{["k1"] => ["a", "b", "c"]}, {["k2"] => ["d", "e", "f"]}] 

results_arr = [] 
arr.each do |hsh| 
    hsh.values.flatten.each do |val| 
    results_arr << { [val] => hsh.keys.first }··· 
    end 
end 


Result: [{["a"]=>["k1"]}, {["b"]=>["k1"]}, {["c"]=>["k1"]}, {["d"]=>["k2"]}, {["e"]=>["k2"]}, {["f"]=>["k2"]}] 

Answer 6

如果你想有重复值的正确处理，那么你应该使用来自红宝石刻面的哈希＃

Hash#inverse保留重复值, 例如它确保了hash.inverse.inverse == hash

之一：

• 使用散列＃从这里逆：http://unixgods.org/~tilo/Ruby/invert_hash.html

• 使用散列＃从FacetsOfRuby库 '面'

使用这样的逆：

require 'facets' 

h = {:key1 => [:a, :b, :c], :key2 => [:d, :e, :f]} 
=> {:key1=>[:a, :b, :c], :key2=>[:d, :e, :f]} 

h.inverse 
=> {:a=>:key1, :b=>:key1, :c=>:key1, :d=>:key2, :e=>:key2, :f=>:key2} 

的代码看起来是这样的：

# this doesn't looks quite as elegant as the other solutions here, 
# but if you call inverse twice, it will preserve the elements of the original hash 

# true inversion of Ruby Hash/preserves all elements in original hash 
# e.g. hash.inverse.inverse ~ h 

class Hash 

    def inverse 
    i = Hash.new 
    self.each_pair{ |k,v| 
     if (v.class == Array) 
     v.each{ |x| 
      i[x] = i.has_key?(x) ? [k,i[x]].flatten : k 
     } 
     else 
     i[v] = i.has_key?(v) ? [k,i[v]].flatten : k 
     end 
    } 
    return i 
    end 

end 


h = {:key1 => [:a, :b, :c], :key2 => [:d, :e, :f]} 
=> {:key1=>[:a, :b, :c], :key2=>[:d, :e, :f]} 

h.inverse 
=> {:a=>:key1, :b=>:key1, :c=>:key1, :d=>:key2, :e=>:key2, :f=>:key2} 

Answer 7

在一个值对应于一个以上的键，如在这个例子中的“c”的情况下...

{ :key1 => ["a", "b", "c"], :key2 => ["c", "d", "e"]} 

...一些的其他答案不会给出预期的结果。我们将需要扭转哈希键存储阵列，像这样：

{ "a" => [:key1], "b" => [:key1], "c" => [:key1, :key2], "d" => [:key2], "e" => [:key2] } 

这应该做的伎俩：

reverse = {} 
hash.each{ |k,vs| 
    vs.each{ |v| 
     reverse[v] ||= [] 
     reverse[v] << k 
    } 
} 

这是我的使用情况下，我会多定义我的问题与OP相同的方式（实际上，搜索一个类似的词组让我在这里），所以我怀疑这个答案可能会帮助其他搜索者。

Answer 8

很多其他的好答案。只是想折腾太这一个对Ruby 2.0和1.9.3：

hash = {apple: [1, 14], orange: [7, 12, 8, 13]} 

Hash[hash.flat_map{ |k, v| v.map{ |i| [i, k] } }] 
# => {1=>:apple, 14=>:apple, 7=>:orange, 12=>:orange, 8=>:orange, 13=>:orange} 

这是利用：Hash::[]和Enumerable#flat_map

而且在这些新版本有Enumerable::each_with_object这是非常相似的Enumerable::inject/Enumerable::reduce ：

hash.each_with_object(Hash.new){ |(k, v), inverse| 
    v.each{ |e| inverse[e] = k } 
} 

执行快速benchmark（红宝石2.0.0p0; 2012的Macbook Air）使用原始散列与100键，每个键与100个不同的值：

Hash::[] w/ Enumerable#flat_map 
      155.7 (±9.0%) i/s -  780 in 5.066286s 
Enumerable#each_with_object w/ Enumerable#each 
      199.7 (±21.0%) i/s -  940 in 5.068926s 

显示each_with_object变体对于该数据集更快。