Обмен ключами и значениями в хеш

Question

В Ruby, как мне поменять ключи и значения на хеш?

Допустим, у меня есть следующий Hash:

{:a=>:one, :b=>:two, :c=>:three} 

То, что я хочу, чтобы преобразовать в:

{:one=>:a, :two=>:b, :three=>:c} 

Используя карту, кажется, довольно утомительно. Есть ли более короткое решение?

Answer 1

Ruby имеет вспомогательный метод для хэша, который позволяет обрабатывать хеш, как если бы он был инвертирован.

{a: 1, b: 2, c: 3}.key(1) 
=> :a 

Если вы хотите сохранить перевернутый хэш, то Hash#invert должны работать для большинства ситуаций.

{a: 1, b: 2, c: 3}.invert 
=> {1=>:a, 2=>:b, 3=>:c} 

НО ...

Если у вас есть повторяющиеся значения, invert будет отбрасывая все, кроме последнего из значений. Аналогично key вернет только первый матч.

{a: 1, b: 2, c: 2}.key(2) 
=> :b 

{a: 1, b: 2, c: 2}.invert 
=> {1=>:a, 2=>:c} 

Так .. если значения уникальны вы можете использовать Hash#invert, если нет, то вы можете сохранить все значения в виде массива, например:

class Hash 
    # like invert but not lossy 
    # {"one"=>1,"two"=>2, "1"=>1, "2"=>2}.inverse => {1=>["one", "1"], 2=>["two", "2"]} 
    def safe_invert 
    each_with_object({}) do |(key,value),out| 
     out[value] ||= [] 
     out[value] << key 
    end 
    end 
end 

Примечания: Этот код с тестами сейчас here.

Или короче ...

class Hash 
    def safe_invert 
    self.each_with_object({}){|(k,v),o|(o[v]||=[])<<k} 
    end 
end 

Answer 2

Вы ставите, что есть один! В Ruby всегда есть более короткий путь!

Это довольно просто, просто используйте Hash#invert:

{a: :one, b: :two, c: :three}.invert 
=> {:one=>:a, :two=>:b, :three=>:c} 

вуаля!

Answer 3

# 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 

Hash#inverse дает:

h = {a: 1, b: 2, c: 2} 
h.inverse 
    => {1=>:a, 2=>[:c, :b]} 
h.inverse.inverse 
    => {:a=>1, :c=>2, :b=>2} # order might not be preserved 
h.inverse.inverse == h 
    => true     # true-ish because order might change 

в то время как встроенный invert метод просто сломана:

h.invert 
    => {1=>:a, 2=>:c} # FAIL 
h.invert.invert == h 
    => false    # FAIL 

Answer 4

Использование Массив

input = {:key1=>"value1", :key2=>"value2", :key3=>"value3", :key4=>"value4", :key5=>"value5"} 
output = Hash[input.to_a.map{|m| m.reverse}] 

Использование Hash

input = {:key1=>"value1", :key2=>"value2", :key3=>"value3", :key4=>"value4", :key5=>"value5"} 
output = input.invert 

Answer 5

files = { 
    'Input.txt' => 'Randy', 
    'Code.py' => 'Stan', 
    'Output.txt' => 'Randy' 
} 

h = Hash.new{|h,k| h[k] = []} 
files.map {|k,v| h[v]<< k} 
puts h 

Это будет обрабатывать повторяющиеся значения тоже.

Answer 6

Если у вас есть хэш, где находятся ключи уникальны, вы можете использовать Hash#invert:

> {a: 1, b: 2, c: 3}.invert 
=> {1=>:a, 2=>:b, 3=>:c} 

Это не будет работать, если у вас есть не уникальные ключи, однако, где только последние ключи видно будет продолжал:

> {a: 1, b: 2, c: 3, d: 3, e: 2, f: 1}.invert 
=> {1=>:f, 2=>:e, 3=>:d} 

Если у вас есть хэш с не уникальным ключом, вы можете сделать:

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

Если значения хэша уже являются массивами, вы можете сделать:

> hash={ "A" => [14, 15, 16], "B" => [17, 15], "C" => [35, 15] } 
> hash.each_with_object(Hash.new { |h,k| h[k]=[] }) {|(k,v), h| 
      v.map {|t| h[t] << k} 
      } 
=> {14=>["A"], 15=>["A", "B", "C"], 16=>["A"], 17=>["B"], 35=>["C"]}