How to group multiple hashes with same key into an array of hashes

Question

Starting form an array of hashes:

roles =[
 {:id=>1, :name=>"alpha", :gid=>1}, 
 {:id=>2, :name=>"beta", :gid=>2},   
 {:id=>3, :name=>"delta", :gid=>1}, 
 {:id=>4, :name=>"epsilon", :gid=>1}, 
 {:id=>5, :name=>"zeta", :gid=>3}
]

I am trying to get another structure:

groups = [
 {:gid=>1, :roles=>[
    {:id=>1, :name=>"alpha"}, 
    {:id=>3, :name=>"delta"}, 
    {:id=>4, :name=>"epsilon"}]}, 
 {:gid=>2, :roles=>[{:id=>2, :name=>"beta"}]}, 
 {:gid=>3, :roles=>[{:id=>5, :name=>"zeta"}]}
]

ANSWERS -- all answers output the same .. however I have to vote for the fastest one ..

time1 = Benchmark.measure do
 (1..10000).each do 
   roles.group_by { |e| e.slice(:gid) }.map{
     |k,v| k.merge(:roles => v.map { |e| e.except(:gid)}) }
 end
end
puts time1
user       system      total        real
1.150000   0.010000   1.160000 (  1.165781)

time2 = Benchmark.measure do
  (1..10000).each do
   roles.group_by{|el| el[:gid]}.map{|gid, els|
   {gid: gid, roles: els.map{ |el| { id: el[:id], name: el[:name]}}}}
   end
end
puts time2
user       system      total        real
0.270000   0.000000   0.270000 (  0.278286)

time3 = Benchmark.measure do
  (1..10000).each do
 roles.group_by{|h| h.delete(:gid)}.map{|k, v| {gid: k, roles: v}}
  end
end
puts time3
user       system      total        real
0.130000   0.000000   0.130000 (  0.134478)

the updated expected structure is the one output from the correct answer ... simple , I don't see what's incorrect — user762579
– user762579, Commented Dec 2, 2015 at 16:56
ok I removed the intermediate result which doesn't add any useful information for further readers and just kept input and expected output + performances — user762579
– user762579, Commented Dec 2, 2015 at 17:04
Writing code to minimize CPU time is like buying a car for its zero to sixty clocking. There may be other things to consider. — Cary Swoveland
– Cary Swoveland, Commented Dec 2, 2015 at 22:00

sawa · Accepted Answer · 2015-12-02 16:14:10Z

5

An answer to your question is:

gid = nil
h = [
  {:id=>1, :name=>"alpha", :gid=>1},
  {:id=>3, :name=>"delta", :gid=>1},
  {:id=>4, :name=>"epsilon", :gid=>1}
]
.each{|h| gid = h.delete(:gid)}
{gid: gid, roles: h}

but the whole thing can be done like this:

roles.group_by{|h| h.delete(:gid)}.map{|k, v| {gid: k, roles: v}}

answered Dec 2, 2015 at 16:14

sawa

169k51 gold badges288 silver badges401 bronze badges

Sign up to request clarification or add additional context in comments.

1 Comment

user762579 Over a year ago

Your answer is the faster

fl00r · Accepted Answer · 2015-12-02 15:16:05Z

0

roles = [
  {:id => 1, :name=>"alpha", :gid=>1}, 
  {:id => 2, :name=>"beta", :gid=>2}, 
  {:id => 3, :name=>"delta", :gid=>1}, 
  {:id => 4, :name=>"epsilon", :gid=>1},
  {:id => 5, :name=>"zeta", :gid=>3}
]

roles.group_by do |el|
  el[:gid]
end.map do |gid, els|
  { 
    gid: gid, 
    roles: els.map{ |el| { id: el[:id], name: el[:name] } } 
  }
end

answered Dec 2, 2015 at 15:16

fl00r

83.7k33 gold badges222 silver badges239 bronze badges

1 Comment

user762579 Over a year ago

both answers give the correct output, however I have to vote for the fastest 0.278286

sschmeck · Accepted Answer · 2015-12-02 15:36:48Z

0

A solution for Ruby 1.8.7 with ActiveSupport for methods slice() and except().

require 'rubygems'
require 'active_support/all'    

roles.group_by { |e| e.slice(:gid) }.
      map      { |k,v| k.merge(:roles => v.map { |e| e.except(:gid)}) }

#=> [{:gid=>1, :roles=>[{:name=>"alpha", :id=>1},
#                       {:name=>"delta", :id=>3},
#                       {:name=>"epsilon", :id=>4}]},
#    {:gid=>2, :roles=>[{:name=>"beta", :id=>2}]},
#    {:gid=>3, :roles=>[{:name=>"zeta", :id=>5}]}]

edited Dec 2, 2015 at 15:36

answered Dec 2, 2015 at 15:19

sschmeck

7,8036 gold badges45 silver badges78 bronze badges

1 Comment

user762579 Over a year ago

Thanks both answers give the correct output, however I have to vote for the fastest 1.165781

Cary Swoveland · Accepted Answer · 2015-12-02 22:58:37Z

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. Here that block is:

{ |k,ov,nv| { :gid=>ov[:gid], :roles=>ov[:roles]+nv[:roles] } }

where k is the common key, ov is the value of the key in the being constructed and nv is the value of the hash being merged in.

The calculation:

roles.each_with_object({}) do |g,h|
  h.update(g[:gid]=>{ :gid=>g[:gid],
                      :roles=>[{:id=>g[:id], :name=>g[:name]}]
                    }
          ) { |k,ov,nv| { :gid=>ov[:gid], :roles=>ov[:roles]+nv[:roles] } }
end.values
  #=> [{:gid=>1, :roles=>[{:id=>1, :name=>"alpha"},
  #                       {:id=>3, :name=>"delta"},
  #                       {:id=>4, :name=>"epsilon"}]},
  #    {:gid=>2, :roles=>[{:id=>2, :name=>"beta"}]},
  #    {:gid=>3, :roles=>[{:id=>5, :name=>"zeta"}]}]

Collectives™ on Stack Overflow

How to group multiple hashes with same key into an array of hashes

4 Answers 4

1 Comment

1 Comment

1 Comment

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

4 Answers 4

1 Comment

1 Comment

1 Comment

Comments

Your Answer

Sign up or log in

Post as a guest

Related