Двунаправленная хеш-таблица в Ruby

Вы можете довольно легко создать что-то самостоятельно, просто используйте простой объект, который обертывает два хэша (один для прямого направления, один для обратного). Например:

class BiHash
    def initialize
        @forward = Hash.new { |h, k| h[k] = [ ] }
        @reverse = Hash.new { |h, k| h[k] = [ ] }
    end

    def insert(k, v)
        @forward[k].push(v)
        @reverse[v].push(k)
        v
    end

    def fetch(k)
        fetch_from(@forward, k)
    end

    def rfetch(v)
        fetch_from(@reverse, v)
    end

    protected

    def fetch_from(h, k)
        return nil if(!h.has_key?(k))
        v = h[k]
        v.length == 1 ? v.first : v.dup
    end
end

Поиск будет вести себя так же, как обычный поиск по хешу (поскольку он является обычным поиском по хэшу). Добавьте несколько операторов и, возможно, достойные реализации to_s и inspect, и все будет хорошо.

Такая штука работает так:

b = BiHash.new
b.insert(:a, 'a')
b.insert(:a, 'b')
b.insert(:a, 'c')
b.insert(:b, 'a')
b.insert(:c, 'x')

puts b.fetch(:a).inspect            # ["a", "b", "c"]
puts b.fetch(:b).inspect            # "a"
puts b.rfetch('a').inspect          # [:a, :b]
puts b.rfetch('x').inspect          # :c
puts b.fetch(:not_there).inspect    # nil
puts b.rfetch('not there').inspect  # nil

Нет ничего плохого в том, чтобы создавать свои инструменты, когда они вам нужны.

В Ruby нет такой встроенной структуры.

Обратите внимание, что Hash#rassoc делает что-то подобное, но возвращает только первое совпадение и имеет линейное время:

h = {:abc => 123, :xyz => 789, :qaz => 789, :wsx => [888, 999]}
h.rassoc(123) # => [:abc, 123]

Кроме того, невозможно выполнить ваши требования в Ruby совершенно безопасным образом, так как вы не сможете обнаружить изменения в значениях, которые являются массивами. Например.:

h = MyBidirectionalArray.new(:foo => 42, :bar => [:hello, :world])
h.rfetch(:world) # => :bar
h[:bar].shift
h[:bar] # => [:world]
h.rfetch(:world) # => should be nil, but how to detect this??

Вычисление хеша каждый раз для обнаружения изменения сделает ваш поиск линейным по времени. Однако вы можете продублировать значения массива и заморозить их (как это делает Ruby для ключей Hash, которые являются строками!)

Кажется, вам нужен класс Graph, который может иметь API, отличный от Hash, не так ли? Вы можете проверить rgl или что-то подобное, но я не знаю, как они реализованы. .

Удачи.

Существует метод Hash#invert (http://www.ruby-doc.org/core-2.1.0/Hash.html#method-i-invert), чтобы добиться этого. Однако он не будет отображать несколько значений в массив.

Попробуй это:

class Hash
  def rfetch val
    select { |k,v| v.is_a?(Array) ? v.include?(val) : v == val }.map { |x| x[0] }
  end
end

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