Вопрос по hashmap, ruby – Обмен ключей и значений в хэше

132

В Ruby, как я могу поменять ключи и значения в Hash?

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

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

Что я хочу превратить в:

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

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

Ваш Ответ

5   ответов
1
# 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.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
1
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

242

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

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

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

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

BUT...

Если у вас есть повторяющиеся значения,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

Примечание: этот код с тестами сейчасВот.

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

class Hash
  def safe_invert
    self.each_with_object({}){|(k,v),o|(o[v]||=[])<<k}
  end
end
так что становитсяeach_with_object({}){ |i,o|k,v = *i; o[v] ||=[]; o[v] << k} ... отлично
each_with_object здесь больше смысла, чемinject.
О, мой бог. я не знал, что вы можете сделать | (ключ, значение), из |. Это так здорово, я ненавидел этот массив, приходящий туда вместо ключа и значения. Спасибо
60

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

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

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

Et voil & # xE0 ;!

Hash # инвертировать не работает, если одни и те же значения появляются в вашем хэше несколько раз.
1

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

Использование хэша

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

Похожие вопросы