ruby - update - Intercambio de claves y valores en un hash

update hash ruby

Question

En Ruby, ¿cómo puedo intercambiar claves y valores en un Hash?

Digamos que tengo el siguiente hash:

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

Que quiero transformarme en:

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

Usar un mapa parece bastante tedioso. ¿Hay una solución más corta?

Answer 1

¡Estás apostando a que hay uno! ¡Siempre hay una manera más corta de hacer cosas en Ruby!

Es bastante simple, solo usa Hash#invert :

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

Et voilà!

Answer 2

Ruby tiene un método auxiliar para hash que te permite tratar un hash como si estuviera invertido.

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

Si desea mantener el hash invertido, entonces Hash#invert debería funcionar para la mayoría de las situaciones.

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

PERO...

Si tiene valores duplicados, invert descartando todos menos el último de sus valores. Del mismo modo, la key solo devolverá la primera coincidencia.

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

Entonces ... si sus valores son únicos, puede usar Hash#invert si no es así, entonces puede mantener todos los valores como una matriz, como esta:

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

Nota: Este código con las pruebas ahora está here .

O en resumen ...

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

Answer 3

Si tiene un hash donde las claves son únicas, puede usar Hash#invert :

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

Sin embargo, eso no funcionará si tiene claves no exclusivas, donde solo se conservarán las últimas claves:

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

Si tiene un hash con claves no únicas, puede hacer:

> 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]}

Si los valores del hash ya son matrices, puede hacer:

> 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"]}

Answer 4

Usando matriz

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

Usando hash

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

Answer 5

# 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 te da:

 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

mientras que el método de invert integrado simplemente se rompe:

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

Answer 6

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

Esto manejará los valores duplicados también.