Questions on implementing hashes in ruby

Question

I'm new to ruby, I am solving a problem that involves hashes and key. The problem asks me to Implement a method, #pet_types, that accepts a hash as an argument. The hash uses people's # names as keys, and the values are arrays of pet types that the person owns. My question is about using Hash#each method to iterate through each num inside the array. I was wondering if there's any difference between solving the problem using hash#each or hash.sort.each? I spent several hours coming up different solution and still to figure out what are the different approaches between the 2 ways of solving the problem below.

I include my code in repl.it: https://repl.it/H0xp/6 or you can see below:

# Pet Types
# ------------------------------------------------------------------------------
# Implement a method, #pet_types, that accepts a hash as an argument. The hash uses people's
# names as keys, and the values are arrays of pet types that the person owns.

# Example input:
# {
#   "yi" => ["dog", "cat"],
#   "cai" => ["dog", "cat", "mouse"],
#   "venus" => ["mouse", "pterodactyl", "chinchilla", "cat"]
# }
def pet_types(owners_hash)

  results = Hash.new {|h, k| h[k] = [ ] }
  owners_hash.sort.each { |k, v| v.each { |pet| results[pet] << k } }
  results 
end

puts "-------Pet Types-------"

owners_1 = {
  "yi" => ["cat"]
}
output_1 = {
  "cat" => ["yi"]
}

owners_2 = {
  "yi" => ["cat", "dog"]
}
output_2 = {
  "cat" => ["yi"],
  "dog" => ["yi"]
}

owners_3 = {
  "yi" => ["dog", "cat"],
  "cai" => ["dog", "cat", "mouse"],
  "venus" => ["mouse", "pterodactyl", "chinchilla", "cat"]
}
output_3 = {
  "dog" => ["cai", "yi"],
  "cat" => ["cai", "venus", "yi"],
  "mouse" => ["cai", "venus"],
  "pterodactyl" => ["venus"],
  "chinchilla" => ["venus"]
}


  # method 2 
    # The 2nd and 3rd method should return a hash that uses the pet types as keys and the values should
    # be a list of the people that own that pet type. The names in the output hash should
    # be sorted alphabetically

  # switched_hash = Hash.new()

  # owners_hash.each do |owner, pets_array|
  #   pets_array.each do |pet|
  #     select_owners = owners_hash.select { |owner, pets_array| 

owners_hash[owner].include?(pet) }

  #     switched_hash[pet] = select_owners.keys.sort
  #   end 
  # end 

  # method 3 
  #switched_hash
  # pets = Hash.new {|h, k| h[k] = [ ] } # WORKS SAME AS: pets = Hash.new( Array.new )
  # owners = owners_hash.keys.sort
  # owners.each do |owner|
  #   owners_hash[owner].each do |pet|
  #     pets[pet] << owner 
  #   end 
  # end 
  # pets 
# Example output:

# output_3 = {
#   "dog" => ["cai", "yi"],
#   "cat" => ["cai", "venus", "yi"],  --->  (sorted alphabetically!)
#   "mouse" => ["cai", "venus"],
#   "pterodactyl" => ["venus"],
#   "chinchilla" => ["venus"]
# }

I used a hash data structure in my program to first solve this problem. Then I tried to rewrite it using the pet_hash. And my final codes is the following:

def pet_types(owners_hash)
  pets_hash = Hash.new { |k, v| v = [] }

  owners_hash.each do |owner, pets|
    pets.each do |pet|
      pets_hash[pet] += [owner]
    end
  end


  pets_hash.values.each(&:sort!)

  pets_hash
end

puts "-------Pet Types-------"
owners_1 = {
  "yi" => ["cat"]
}
output_1 = {
  "cat" => ["yi"]
}
owners_2 = {
  "yi" => ["cat", "dog"]
}
output_2 = {
  "cat" => ["yi"],
  "dog" => ["yi"]
}
owners_3 = {
  "yi" => ["dog", "cat"],
  "cai" => ["dog", "cat", "mouse"],
  "venus" => ["mouse", "pterodactyl", "chinchilla", "cat"]
}
output_3 = {
  "dog" => ["cai", "yi"],
  "cat" => ["cai", "venus", "yi"],
  "mouse" => ["cai", "venus"],
  "pterodactyl" => ["venus"],
  "chinchilla" => ["venus"]
}
puts pet_types(owners_1) == output_1
puts pet_types(owners_2) == output_2
puts pet_types(owners_3) == output_3

Answer 1

Hash#sort has the same effect (at least for my basic test) as Hash#to_a followed by Array#sort.

hash = {b: 2, a: 1}
hash.to_a.sort # => [[:a, 1, [:b, 2]]
hash.sort      # => the same

Now let's look at #each, both on Hash and Array.

When you provide two arguments to the block, that can handle both cases. For the hash, the first argument will be the key and the second will be the value. For the nested array, the values essentially get splatted out to the args:

[[:a, 1, 2], [:b, 3, 4]].each { |x, y, z| puts "#{x}-#{y}-#{z}" }
# => a-1-2
# => b-3-4

So basically, you should think of Hash#sort to be a shortcut to Hash#to_a followed by Array#sort, and recognize that #each will work the same on a hash as a hash converted to array (a nested array). In this case, it doesn't matter which approach you take. Clearly if you need to sort iteration by the keys then you should use sort.