Come scambiare chiavi e valori in un hash

Come posso scambiare chiavi e valori in un hash?

Ho il seguente hash:

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

che voglio trasformare in:

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

L'uso mapsembra piuttosto noioso. C'è una soluzione più breve?

Ruby ha un metodo di supporto per Hash che ti consente di trattare un Hash come se fosse invertito (in sostanza, permettendoti di accedere alle chiavi attraverso i valori):

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

Se vuoi mantenere l'hash invertito, Hash # invert dovrebbe funzionare nella maggior parte dei casi:

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

MA...

Se hai valori duplicati, inverteliminerai tutti tranne l'ultima occorrenza dei tuoi valori (perché continuerà a sostituire il nuovo valore per quella chiave durante l'iterazione). Allo stesso modo, keyrestituirà solo la prima partita:

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

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

Quindi, se i tuoi valori sono unici, puoi usarli Hash#invert. In caso contrario, è possibile mantenere tutti i valori come un array, in questo modo:

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: questo codice con test è ora su GitHub .

O:

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

Scommetti che ce n'è uno! C'è sempre un modo più breve di fare le cose in Ruby!

È piuttosto semplice, basta usare Hash#invert:

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

Et voilà!

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

h = Hash.new{|h,k| h[k] = []} # Create hash that defaults unknown keys to empty an empty list
files.map {|k,v| h[v]<< k} #append each key to the list at a known value
puts h

Questo gestirà anche i valori duplicati.

# 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 ti dà:

 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

mentre il invertmetodo integrato è appena rotto:

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

Utilizzando la matrice

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

Usando l'hash

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

Se hai un hash in cui le chiavi sono uniche, puoi usare Hash # invert :

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

Ciò non funzionerà se si dispone di chiavi non univoche, tuttavia, dove verranno conservate solo le ultime chiavi visualizzate:

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

Se hai un hash con chiavi non univoche, potresti fare:

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

Se i valori dell'hash sono già array, puoi fare:

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