La permutation des clés et des valeurs dans une table de hachage

En Ruby, comment puis-je échanger des clés et des valeurs dans une table de Hachage?

Disons que j'ai la suite de Hachage:

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

Que je veux transformer en:

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

À l'aide d'une carte semble plutôt fastidieux. Est-il une solution plus courte?

InformationsquelleAutor Jonathan Allard | 2012-06-12

hashmap ruby

252

Ruby a une aide de la méthode de hachage qui permet de traiter un hachage comme si elle a été inversé.
```
{a: 1, b: 2, c: 3}.key(1)
=> :a
```
Si vous voulez garder l'inversion de hachage, puis Dièse#inverser devrait fonctionner pour la plupart des situations.
```
{a: 1, b: 2, c: 3}.invert
=> {1=>:a, 2=>:b, 3=>:c}
```
MAIS...

Si vous avez des doublons, invert va jeter tous, mais le dernier de vos valeurs. De même key ne reviendra que le premier match.
```
{a: 1, b: 2, c: 2}.key(2)
=> :b

{a: 1, b: 2, c: 2}.invert
=> {1=>:a, 2=>:c}
```
Si.. si vos valeurs sont uniques que vous pouvez utiliser Hash#invert si non, alors vous pouvez conserver toutes les valeurs dans un tableau, comme ceci:
```
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
```
Remarque: Ce code avec des tests est maintenant ici.

Ou en court...
```
class Hash
  def safe_invert
    self.each_with_object({}){|(k,v),o|(o[v]||=[])<<k}
  end
end
```
- each_with_object a plus de sens ici que inject.
- alors que devient each_with_object({}){ |i,o|k,v = *i; o[v] ||=[]; o[v] << k} nice ...
- Omg. je na sais que vous pourriez faire |(clé,valeur),out|. Que tellement génial, j'ai détesté ce tableau vient de là, au lieu de la clé et la valeur. Merci beaucoup
InformationsquelleAutor Nigel Thorne
62

Vous parie qu'il y en est un! Il y a toujours une façon plus simple de faire les choses en Ruby!

C'est assez simple, il suffit d'utiliser Hash#inverser:
```
{a: :one, b: :two, c: :three}.invert
=> {:one=>:a, :two=>:b, :three=>:c}
```
Et voilà!
- Dièse#inverser ne fonctionne pas si les mêmes valeurs apparaissent plusieurs fois dans votre hash.
InformationsquelleAutor Jonathan Allard
2
```
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
```
Cela va gérer le double des valeurs trop.
- Pouvez-vous peu expliquer la réponse que ce qui se passe à chaque étape?
- Personnellement, j'ai éviter de fixer la valeur de hachage de la valeur par défaut de comportement. J'ai peur que le code que je donne à ce hachage pour ne pas s'attendre à un hachage à se comporter de cette façon, et il pourrait causer certains insidieuse d'erreur plus tard. Je ne peux pas vraiment justifier cette préoccupation. C'est juste un doute je n'arrive pas à ignorer. Principe de moindre surprise?
InformationsquelleAutor Riaze

# 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 vous donne:

 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

alors que le haut- invert méthode est juste cassé:

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

InformationsquelleAutor Tilo

À L'Aide Du Tableau

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

À L'Aide De Hachage

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

InformationsquelleAutor Prashant Ravi Darshan

Si vous avez une table de hachage où sont les clés sont uniques, vous pouvez utiliser Dièse#inverser:

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

Qui ne fonctionnera pas si vous ne disposez pas des clés uniques, cependant, où seule la dernière clés vus, seront conservés:

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

Si vous avez une table de hachage avec les touches uniques, que vous pourriez faire:

> 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 les valeurs de hachage sont déjà des tableaux, vous pouvez le faire:

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

InformationsquelleAutor dawg

Vous devez vous connecter pour publier un commentaire.