Convert Array of 2-Element Arrays into a Hash, Where Duplicate Keys Append Additional Values

Convert array of 2-element arrays into a hash, where duplicate keys append additional values

Using functional baby steps:

irb:01.0> array = [[:a,:b],[:a,:c],[:c,:b]]
#=> [[:a, :b], [:a, :c], [:c, :b]]

irb:02.0> array.group_by(&:first)
#=> {:a=>[[:a, :b], [:a, :c]], :c=>[[:c, :b]]}

irb:03.0> array.group_by(&:first).map{ |k,a| [k,a.map(&:last)] }
#=> [[:a, [:b, :c]], [:c, [:b]]]

irb:04.0> Hash[ array.group_by(&:first).map{ |k,a| [k,a.map(&:last)] } ]
#=> {:a=>[:b, :c], :c=>[:b]}

Using imperative style programming:

irb:10.0> h = Hash.new{ |h,k| h[k]=[] }
#=> {}

irb:11.0> array.each{ |k,v| h[k] << v }
#=> [[:a, :b], [:a, :c], [:c, :b]]

irb:12.0> h
#=> {:a=>[:b, :c], :c=>[:b]}

As an imperative one-liner:

irb:13.0> h = Hash.new{ |h,k| h[k]=[] }.tap{ |h| array.each{ |k,v| h[k] << v } }
#=> {:a=>[:b, :c], :c=>[:b]}

Or using everyone's favorite inject:

irb:14.0> array.inject(Hash.new{ |h,k| h[k]=[] }){ |h,(k,v)| h[k] << v; h }
#=> {:a=>[:b, :c], :c=>[:b]}

If you really want to have single values not collided as an array, you can either un-array them as a post-processing step, or use a different hash accumulation strategy that only creates an array upon collision. Alternatively, wrap your head around this:

irb:17.0> hashes = array.map{ |pair| Hash[*pair] } # merge many mini hashes
#=> [{:a=>:b}, {:a=>:c}, {:c=>:b}]

irb:18.0> hashes.inject{ |h1,h2| h1.merge(h2){ |*a| a[1,2] } }
#=> {:a=>[:b, :c], :c=>:b}

Convert Array to Hash removing duplicate keys and adding values at the same time

This works:

result = Hash.new(0)
f = [["Wed, 12-31", 120.0],["Thu, 01-01", 120.0], ["Thu, 01-01", 120.0]]
f.each { |subarray| result[subarray[0]] += subarray[1] }
puts result

If you would like to be fancy you could use .inject()

Preserving key value pairs for duplicate keys when merging two Arrays to a hash

There are three standard ways of doing this.

a1 = ["farmer_joe", "farmer_judy", "farmer_crazy_eyes", "farmer_joe"]
a2 = ["pigs", "chickens", "elephants", "cows"]
pairs = a1.zip(a2) # or [a1,a2].transpose
  #=> [["farmer_joe", "pigs"], ["farmer_judy", "chickens"],
  #    ["farmer_crazy_eyes", "elephants"], ["farmer_joe", "cows"]]

1. Use Hash.new to create a hash with a default value of an empty array

pairs.each_with_object(Hash.new { |h,k| h[k]=[] }) { |(f,l),h| h[f] << l }
  # => {"farmer_joe"=>["pigs", "cows"], "farmer_judy"=>["chickens"],
  #     "farmer_crazy_eyes"=>["elephants"]}

A variant of this (which tends to be slightly faster) is:

pairs.each_with_object({}) { |(f,l),h| (h[f] ||= []) << l }

2. Use the form of Hash#update (aka merge!) that takes a block to determine the values of keys present in both hashes being merged

pairs.each_with_object({}) { |(f,l),h| h.update(f=>[l]) { |_,o,n| o+n } }
  #=> {"farmer_joe"=>["pigs", "cows"], "farmer_judy"=>["chickens"],
  #    "farmer_crazy_eyes"=>["elephants"]} 

3. Use Enumerable#group_by

h = pairs.group_by(&:first)
  #=> {"farmer_joe"=>[["farmer_joe", "pigs"], ["farmer_joe", "cows"]],
  #    "farmer_judy"=>[["farmer_judy", "chickens"]],
  #    "farmer_crazy_eyes"=>[["farmer_crazy_eyes", "elephants"]]} 
h.keys.each { |k| h[k] = h[k].map(&:last) }
h
  #=> {"farmer_joe"=>["pigs", "cows"], "farmer_judy"=>["chickens"],
  #    "farmer_crazy_eyes"=>["elephants"]} 

There are many alternative to the last two lines, one being:

h.merge(h) { |*_,v| v.map(&:last) }

Combine values of two arrays to form key and values to hash in ruby

Sure, very simple

Hash[[1,2,3,4].zip([5,6,7,8])]
 => {1=>5, 2=>6, 3=>7, 4=>8} 

But it might be a problem if the arrays have not the same size.

ruby convert array to hash preserve duplicate key

I hope you would like this :

ary = [
       "19d97e408ee3f993745b053e281ac9dc69519e06","refs/heads/auto",
       "8f6f47c6e8023540b022586e368c68e1e814ce6d","refs/heads/callout_hooks",  
       "3cbdb4b2fcb85bc7f0ed08b62e2bf2445a7659e8","refs/heads/elab",
       "d38a9a26ef887c08b306bdab210b39882f58e587","refs/heads/elab_6.1",
       "19d97e408ee3f993745b053e281ac9dc69519e06","refs/heads/master",
       "906dfe6eebff832baf0f92683d751432fcc98ab7","refs/heads/regression"
     ]

array_hash = ary.each_slice(2).with_object(Hash.new { |h,k| h[k] = []}) do |(k,v),hash|
  hash[k] << v 
end

# the main advantage is here you wouldn't loose any data, all are with you. You can
# use it as per your need. I think it is a better approach to deal with your situation.
array_hash
# => {"19d97e408ee3f993745b053e281ac9dc69519e06"=>
#      ["refs/heads/auto", "refs/heads/master"],
#     "8f6f47c6e8023540b022586e368c68e1e814ce6d"=>["refs/heads/callout_hooks"],
#     "3cbdb4b2fcb85bc7f0ed08b62e2bf2445a7659e8"=>["refs/heads/elab"],
#     "d38a9a26ef887c08b306bdab210b39882f58e587"=>["refs/heads/elab_6.1"],
#     "906dfe6eebff832baf0f92683d751432fcc98ab7"=>["refs/heads/regression"]}

How to reduce array of hashes with duplicate keys to nested hash?

def combine(arr)
  arr.group_by {|g|g[:foo]}.map {|_,a|{foo: a.first[:foo], bar: a.map {|g| g[:bar]}}}
end

combine arr_with_dup_hsh_keys
  #=> [{:foo=>"dup", :bar=>[1, 2, 3, 4, 5]}]

arr_with_dup_hsh_keys1 = [
  { foo: "dup",  bar: 1 },
  { foo: "dup",  bar: 2 },
  { foo: "soup", bar: 3 },
  { foo: "dup",  bar: 4 },
  { foo: "soup", bar: 5 }
]

combine arr_with_dup_hsh_keys1
  #=> [{:foo=>"dup", :bar=>[1, 2, 4]}, {:foo=>"soup", :bar=>[3, 5]}] 

See Enumerable#group_by and note that

arr_with_dup_hsh_keys1.group_by { |g| g[:foo] }
 #=> {"dup"=> [{:foo=>"dup", :bar=>1}, {:foo=>"dup", :bar=>2},
 #             {:foo=>"dup", :bar=>4}],
 #    "soup"=>[{:foo=>"soup", :bar=>3}, {:foo=>"soup", :bar=>5}]}

You could alternatively write the following.

def combine(arr)
  arr.each_with_object({}) do |g,h|
    f = g.merge(bar: [g[:bar]])
    h.update(f[:foo]=>f) { |_,o,n| { foo: o[:foo], bar: o[:bar]+n[:bar] } }
  end.values
end

combine arr_with_dup_hsh_keys1
  #=> [{:foo=>"dup", :bar=>[1, 2, 4]}, {:foo=>"soup", :bar=>[3, 5]}] 

This uses the form of Hash#update (aka merge!) that employs a block to determine the values of keys that are present in both hashes being merged. See the doc for an explanation of the three block variables (the first being the common key, which I've represented with an underscore to signify that it's not used in the block calculation).

How to convert, in Ruby, a list of key value pairs to a Hash, such that values with duplicate keys are stored in an array?

Another way is to use the form of Hash#update (aka merge!) that uses a block to determine the values of keys that are in both hashes being merged.

arr = [ ["key1","value1"], ["key2","value2"], ["key1", "value3"] ]

arr.each_with_object({}) { |(k,v),h| h.update(k=>[v]) { |_,o,n| o+n } }
  #=> {"key1"=>["value1", "value3"], "key2"=>["value2"]}

Merge arrays to hash and use duplicates

As Justin & Luca said:

Hashes don't allow duplicate keys.

Best you can do is by having array of values, found this solution in this SO question:

Hash.new.tap { |h| keys.zip(values).each { |k, v| (h[k] ||= []) << v } }
# => {1=>["a", "c"], 2=>["b"]} 

---

Related Topics