Iterate through array of hashes and merge [closed] - ruby

Question

Closed. This question needs details or clarity. It is not currently accepting answers.
Want to improve this question? Add details and clarify the problem by editing this post.
Closed 7 years ago.
Improve this question
I have an array of hashes like so:
[{:a=>"a", :b=>"b", :c=>"c", :d=>"d"},
{:a=>"a", :b=>nil, :c=>"notc", :d=>"d"}]
I want to iterate over the hash and merge them where a specific key is the same, such as :a. If the next key element is the same - ignore it, but if the key is different, create an array. Result will look something like this:
{:a=>"a", :b=>"b", :c=>["c","notc"], :d=>"d"}
I think I have do a for loop through the array of hashes and then use the merge! method, but not sure where to start

Answer 1

I would also use Hash#merge! (aka update), like this (letting a denote the name of your array of hashes):
a.each_with_object({}) do |g,h|
h.update(g) do |_,o,n|
case o
when Array
o.include?(n) ? o : o + [n]
else
o.eql?(n) ? o : [o,n]
end
end
end
#=> {:a=>"a", :b=>["b", nil], :c=>["c", "notc"], :d=>"d"}
When o is an array, if you don't want to merge nil values, change the following line to:
(o.include?(n) || n.nil?) ? o : o + [n]
The steps:
a = [{:a=>"a", :b=>"b", :c=>"c", :d=>"d"},
{:a=>"a", :b=>nil, :c=>"notc", :d=>"d"},
{:a=>"aa", :b=>"b", :c=>"cc", :d=>"d"},
]
enum = a.each_with_object({})
#-> #<Enumerator: [{:a=>"a", :b=>"b", :c=>"c", :d=>"d"},
# {:a=>"a", :b=>nil, :c=>"notc", :d=>"d"},
# {:a=>"aa", :b=>"b", :c=>"cc", :d=>"d"}]
# :each_with_object({})>
We can see the values of the enumerator (which will be passed into the block) by converting it to an array:
enum.to_a
#=> [[{:a=>"a", :b=>"b", :c=>"c", :d=>"d"}, {}],
# [{:a=>"a", :b=>nil, :c=>"notc", :d=>"d"}, {}],
# [{:a=>"aa", :b=>"b", :c=>"cc", :d=>"d"}, {}]]
Pass in the first value and assign it to the block variables:
g,h = enum.next
#=> [{:a=>"a", :b=>"b", :c=>"c", :d=>"d"}, {}]
g #=> {:a=>"a", :b=>"b", :c=>"c", :d=>"d"}
h #=> {}
update's block is used for determining the values of keys that are present in both hashes being merged. As h is presently empty ({}), it is not used for this merge:
h.update(g)
#=> {:a=>"a", :b=>"b", :c=>"c", :d=>"d"}
The new value of h is returned.
Now pass the second value of enum into the block:
g,h = enum.next
#=> [{:a=>"a", :b=>nil, :c=>"notc", :d=>"d"},
# {:a=>"a", :b=>"b", :c=>"c", :d=>"d"}]
g #=> {:a=>"a", :b=>nil, :c=>"notc", :d=>"d"}
h #=> {:a=>"a", :b=>"b", :c=>"c", :d=>"d"}
and execute:
h.update(g)
When :a=>"a" from g is to be merged, update sees that h contains the same key, :a. It therefore defers to the block to determine the value for :a in the merged hash. It passes the following values to the block:
k = :a
o = "a"
n = "a"
where k is the key, o (for "old") is the value of k in h and n (for "new") is the value of k in g. (We're not using k in the block, so I've name the block variable _ to so signify.) In the case statement, o is not an array, so:
o.eql?(n) ? o : [o,n]
#=> "a".eql?("a") ? "a" : ["a","a"]
#=> "a"
is returned to returned to update to be the value for :a. That is, the value is not changed.
When the key is :b:
k = :b
o = "b"
n = nil
Again, o is not an array, so again we execute:
o.eql?(n) ? o : [o,n]
#=> ["b", nil]
but this time an array is returned. The remaining calculations for merging the second element of enum procede similarly. After the merge:
h #=> {:a=>"a", :b=>["b", nil], :c=>["c", "notc"], :d=>"d"}
When :c=>"cc" in the third element of enum is merged, the following values are passed to update's block:
_ :c
o = ["c", "notc"]
n = "cc"
Since o is an array, we execute the following line of the case statement:
o.include?(n) ? o : o + [n]
#=> ["c", "notc", "cc"]
and the value of :c is assigned that value. The remaining calculations are performed similarly.

Answer 2

I would do something like this:
array = [{ :a=>"a", :b=>"b", :c=>"c", :d=>"d" },
{ :a=>"a", :b=>nil, :c=>"notc", :d=>"d" }]
result = array.reduce({}) do |memo, hash|
memo.merge(hash) do |_, left, right|
combined = Array(left).push(right).uniq.compact
combined.size > 1 ? combined : combined.first
end
end
puts result
#=> { :a=>"a", :b=>"b", :c=>["c", "notc"], :d=>"d" }
Array(left) will ensure that the value of the one hash is an arary. push(right) adds the value from the other hash into that array. uniq.compact removes nil values and duplicates.
The combined.size > 1 ? combined : combined.first line returns just the element if the array holds only one element.

Answer 3

Assuming hs = [{:a=>"a", :b=>"b", :c=>"c", :d=>"d"}, {:a=>"a", :b=>nil, :c=>"notc", :d=>"d"}], you can do that with a (admittedly, terribly dense) one-liner:
Hash[hs.map { |h| h.map { |k,v| [k, v] } }.sort_by(&:first).reduce { |left,right| left.zip(right) }.map { |a| [a.first.first, a.map(&:last).compact.uniq] }]
To unpack what's going on here:
First we use map to convert the array of hashes into an array of arrays of pairs, and then use sort_by to sort the array so that all of the keys are 'lined up'.
[{:a=>"a", :b=>"b", :c=>"c", :d=>"d"}, {:a=>"a", :b=>nil, :c=>"notc", :d=>"d"}] becomes
[[[:a, "a"], [:b, "b"], [:c, "c"], [:d, "d"]],
[[:a, "a"], [:b, nil], [:c, "notc"], [:d, "d"]]]
That's this part:
hs.map { |h| h.map { |k,v| [k, v] } }.sort_by(&:first).
Then, we use reduce and zip all the arrays together, zip just takes two arrays [1,2,3], [:a,:b,:c] and outputs an array like: [[1,:a],[2,:b],[3,:c]]
reduce { |left,right| left.zip(right) }.
At this point we've grouped all the data together by key, and need to de-duplicate all the copies of the key, and we can remove the nils and uniq the values:
map { |a| [a.first.first, a.map(&:last).compact.uniq] }]
Here's a sample from a pry session:
[31] pry(main)> Hash[hs.map { |h| h.map { |k,v| [k, v] } }.sort_by(&:first).reduce { |left,right| left.zip(right) }.map { |a| [a.first.first, a.map(&:last).compact.uniq] }]
=> {:a=>["a"], :b=>["b"], :c=>["c", "notc"], :d=>["d"]}