Subtract hash values ​​from corresponding values ​​in another hash

Question

I would like to account for two hashes and get a third hash in Ruby.

The two hashes are as follows:

h1 = {"Cat" => 100, "Dog" => 5, "Bird" => 2, "Snake" => 10} h1.default = 0 h2 = {"cat" => 50, "dog" => 3, "BIRD" => 4, "Mouse" => 75, "Snake" => 10} h2.default = 0 

I would like to be able to call the method on h1 as follows:

 h1.difference(h2) 

and get this hash as a result:

 {"Cat" => 50, "Dog" => 2, "BIRD" => -2, "Mouse" => -75} 

I would like to create a new hash with keys from hashes, and the values ​​of the new hash are the key value in the first hash, minus the value of this key in the second hash. The trick is that I would like this Hash method to work regardless of the key case. In other words, I would like Cat to match cat.

Here is what I still have:

 class Hash def difference(another_hash) (keys + another_hash.keys).map { |key| key.strip }.uniq.inject(Hash.new(0)) { |acc, key| acc[key] = (self[key] - another_hash[key]); acc }.delete_if { |key, value| value == 0 } end end 

This is normal, but unfortunately the result is not the one I want.

Any help would be appreciated.

Answer 1

How to convert hashes to settings.

 require 'set' h1 = {"Cat" => 100, "Dog" => 5, "Bird" => 2, "Snake" => 10} h1.default = 0 h2 = {"cat" => 50, "dog" => 3, "BIRD" => 4, "Mouse" => 75, "Snake" => 10} h2.default = 0 p (h1.to_set - h2.to_set) #=> #<Set: {["Cat", 100], ["Dog", 5], ["Bird", 2]}> 

Answer 2

As a recommendation ...

In the past, I used something like this:

 class Hash def downcase_keys Hash[map{ |k,v| [k.downcase, v]}] end def difference(other) Hash[self.to_a - other.to_a] end alias :- :difference end 

which allows me to do things like:

 irb(main):206:0> h1.downcase_keys - h2.downcase_keys { "cat" => 100, "dog" => 5, "bird" => 2 } irb(main):207:0> h2.downcase_keys - h1.downcase_keys { "cat" => 50, "dog" => 3, "bird" => 4, "mouse" => 75 } 

alias gives a good use syntax - instead of difference , similar to use - for arrays and sets. You can still use difference , though:

 irb(main):210:0> h1.downcase_keys.difference(h2.downcase_keys) { "cat" => 100, "dog" => 5, "bird" => 2 } irb(main):211:0> h2.downcase_keys.difference(h1.downcase_keys) { "cat" => 50, "dog" => 3, "bird" => 4, "mouse" => 75 } 

I always normalize my hash keys and don't allow options to appear in them. This makes processing hashes too complicated when you don't know which keys are being called, so I highly recommend doing this as a first step. This is a code maintenance problem.

Otherwise, you can create a map of the original key names and their normalized names, but you will have problems if your hash contains two keys with a unique key, such as “key” and “key”, since normalization will stomp one.

Answer 3

Sorry, because of the time limit (I have to take care of my boy now), I just figured out this stupid but working code:

 h1 = {"Cat" => 100, "Dog" => 5, "Bird" => 2, "Snake" => 10} h1.default = 0 h2 = {"cat" => 50, "dog" => 3, "BIRD" => 4, "Mouse" => 75, "Snake" => 10} h2.default = 0 h3 = {"Cat" => 50, "Dog" => 2, "BIRD" => -2, "Mouse" => -75} class Hash def difference(subtrahend) diff = {} self.each_pair do |k1, v1| flag = false subtrahend.each_pair do |k2, v2| if k1.downcase == k2.downcase flag = true v_diff = v1 - v2 break if v_diff == 0 v_diff > 0 ? diff[k1] = v_diff : diff[k2] = v_diff end end diff[k1] = v1 unless flag end subtrahend.each_pair do |k2, v2| flag = false self.each_pair do |k1, v1| if k1.downcase == k2.downcase flag = true break end end diff[k2] = -v2 unless flag end return diff end end h1.difference(h2) == h3 ? puts("Pass") : puts("Fail") #=> "Pass" 

Answer 4

I got this for resque https://github.com/junegunn/insensitive_hash

then follow your procedure, but slightly tweaking it as a requirement

 require 'insensitive_hash' h1 = {"Cat" => 100, "Dog" => 5, "Bird" => 2, "Snake" => 10}.insensitive h1.default = 0 h2 = {"cat" => 50, "dog" => 3, "BIRD" => 4, "Mouse" => 75, "Snake" => 10}.insensitive h2.default = 0 class Hash def difference(another_hash) (keys + another_hash.keys).map { |key| key.downcase }.uniq.inject(Hash.new(0)) do |acc, key| val = self[key] - another_hash[key] acc[key] = val if val!= 0 acc end end end h1.difference(h2) # => {"cat"=>50, "dog"=>2, "bird"=>-2, "mouse"=>-75} 

Answer 5

This time I would like to provide another solution: normalized -> keep the original key value pairs -> grab the original key, which has more values ​​as the key for the difference.

 h1 = {"Cat" => 100, "Dog" => 5, "Bird" => 2, "Snake" => 10} h1.default = 0 h2 = {"cat" => 50, "dog" => 3, "BIRD" => 4, "Mouse" => 75, "Snake" => 10} h2.default = 0 h3 = {"Cat" => 50, "Dog" => 2, "BIRD" => -2, "Mouse" => -75} class Hash def difference(subtrahend) # create a hash which contains all normalized keys all_pairs = (self.keys.map{|x| x.downcase} + subtrahend.keys.map{|x| x.downcase}).uniq.inject({}) do |pairs, key| pairs[key] = [] pairs end #=> {"mouse"=>[], "cat"=>[], "snake"=>[], "bird"=>[], "dog"=>[]} # push original key value pairs into array which is the value of just created hash [self, subtrahend].each_with_index do |hsh, idx| hsh.each_pair { |k, v| all_pairs[k.downcase].push([k, v]) } all_pairs.each_value { |v| v.push([nil, 0]) if v.size == idx } end #=> {"mouse"=>[[nil, 0], ["Mouse", 75]], "cat"=>[["Cat", 100], ["cat", 50]], "snake"=>[["Snake", 10], ["Snake", 10]], "bird"=>[["Bird", 2], ["BIRD", 4]], "dog"=>[["Dog", 5], ["dog", 3]]} results = {} all_pairs.each_value do |values| diff = values[0][1] - values[1][1] # always take the key whose value is larger if diff > 0 results[values[0][0]] = diff elsif diff < 0 results[values[1][0]] = diff end end return results end end puts h1.difference(h2).inspect #=> {"Cat" => 50, "Dog" => 2, "BIRD" => -2, "Mouse" => -75} h1.difference(h2) == h3 ? puts("Pass") : puts("Fail") #=> "Pass" 

According to what you described, this one does a pretty good job. The result is exactly what you showed (the key does not normalize in the final result, but depends on whose value is greater).