Проверка Ruby Hash подмножество?

Question

Как я могу определить, является ли хэш-символ Ruby подмножеством (или включает) другой хеш?

Например:

hash = {a: 1, b: 2, c: 3, d: 4, e: 5, f: 6, g: 7} 
hash.include_hash?({})   # true 
hash.include_hash?({f: 6, c: 3}) # true 
hash.include_hash?({f: 6, c: 1}) # false 

Answer 1

С Руби 2.3 вы можете также сделать следующее, чтобы проверить, является ли это подмножество

hash = {a: 1, b: 2, c: 3, d: 4, e: 5, f: 6, g: 7} 
{} <= hash   # true 
{f: 6, c: 3} <= hash # true 
{f: 6, c: 1} <= hash # false 

Answer 2

Решение, которое пришло мне в использовании ума Hash#merge метод:

class Hash 
    def include_hash?(hash) 
    merge(hash) == self 
    end 
end 

hash = {a: 1, b: 2, c: 3, d: 4, e: 5, f: 6, g: 7} 
hash.include_hash?({}) 
# => true 
hash.include_hash?(f: 6, c:3) 
# => true 
hash.include_hash?(f: 6, c:1) 
# => false 

Answer 3

Вы можете конвертировать хэши в sets и чем выполнить проверку с помощью методов subset? и superset? (или их соответствующие алиасы <= и >=):

require 'set' 

hash.to_set.superset?({}.to_set) 
# => true 

hash.to_set >= {a: 1}.to_set 
# => true 

{a: 2}.to_set <= hash.to_set 
# => false 

Update: эталон предлагаемых решений:

require 'fruity' 
require 'set' 

hash = ('aa'..'zz').zip('aa'..'zz').to_h 
# {"aa"=>"aa", "ab"=>"ab", ... 
find = ('aa'..'zz').zip('aa'..'zz').select { |k, _| k[0] == k[1] }.to_h 
# {"aa"=>"aa", "bb"=>"bb", ... 

compare(
    toro2k:  -> { hash.to_set >= find.to_set }, 
    MarekLipka: -> { hash.merge(find) == hash }, 
    CarySwoveland: -> { (find.to_a - hash.to_a).empty? }, 
    ArupRakshit: -> { arr = hash.to_a; find.all? { |pair| arr.include?(pair) } } 
) 

Результат:

Running each test 2 times. Test will take about 1 second. 
MarekLipka is faster than toro2k by 3x ± 0.1 
toro2k is faster than CarySwoveland by 39.99999999999999% ± 10.0% 
CarySwoveland is faster than ArupRakshit by 1.9x ± 0.1 

Answer 4

Вы можете сделать:

def include_hash?(hash,subset_hash) 
    arr = hash.to_a 
    subset_hash.all? { |pair| arr.include?(pair) } 
end 

Answer 5

разница массив кажется простой:

class Hash 
    def include_hash?(h) 
    (h.to_a - to_a).empty? 
    end 
end 

h = {a: 1, b: 2} 
h.include_hash?({b: 2}) #=> true 
h.include_hash?({b: 3}) #=> false