合并哈希数组：值应为合并值的平均值

Question

Issue: Merge array of hashes with the same value of specified key and find average for the other keys.

My solution seems to be ugly

data:

require 'pp'

arr = [{:red=>346.0,
  :unu=>10.0,
  :used=>20147.0,
  :acc_id=>550,
  :percent=>0.01},
 {:red=>0.0,
  :unu=>1.0,
  :used=>66.0,
  :acc_id=>550,
  :percent=>0.06},
 {:red=>120.0,
  :unu=>11.0,
  :used=>166.0,
  :acc_id=>550,
  :percent=>10.06},
 {:red=>1306.0,
  :unu=>1.0,
  :used=>13259.0,
  :acc_id=>9999,
  :percent=>0.0}]

In current example we should merge 3 hashes with ( :acc_id = 550 ) and result array should contain two hashes ( merged hash with :acc_id = 550 and untouched hash with :acc_id = 9999 )

algorithm:

data = []
arr.group_by{|h| h[:acc_id] }.map {|_, arr_of_hashes|
  sz = arr_of_hashes.size
  if sz > 1
    arr_of_hashes = arr_of_hashes.inject{|memo, el|
      memo.merge(el) {|k, old_v, new_v| old_v + new_v}
    }

    arr_of_hashes.map {|k, v| arr_of_hashes[k] = v / sz}
  end
  data << arr_of_hashes if arr_of_hashes.is_a? Hash
  data << arr_of_hashes[0] if arr_of_hashes.is_a? Array
}

pp data

Expected result: Array of merged hashes

[{:red=>155.33333333333334,
  :unu=>7.333333333333333,
  :used=>6793.0,
  :acc_id=>550,
  :percent=>3.376666666666667},
 {:red=>1306.0,
  :unu=>1.0,
  :used=>13259.0,
  :acc_id=>9999,
  :percent=>0.0}]

... ... ...

Answer 1

I found one bug you perform / and + on acc_id Have refactored the code let's try this but I guess we still improve this.

data = []
arr.group_by{|h| h[:acc_id] }.map {|_, arr_of_hashes|
  sz = arr_of_hashes.size
  result = Hash.new(0)
  arr_of_hashes.map{ |hash| hash.map{ |k,v| result[k] += v/sz unless k == :acc_id } }
  result[:acc_id] = arr_of_hashes.first[:acc_id]
  data << result
}

Answer 2

I suggest you compute the averages as follows. I assume that, as in the example, all hashes have the same keys (though they need not necessarily appear in the same order).

Code

def doit(arr, key)
  keys = arr.first.keys
  arr.group_by { |g| g[key] }.
      map do |_,a| 
        averages = a.map { |h| h.values_at(*keys) }.
                     transpose.
                     map { |v| v.sum.fdiv(v.size) }
        keys.zip(averages).to_h
      end
end 

Example

Notice that my array of hashes is somewhat different than that given in example in the question. Specifically, there are three (rather than two) groups of hashes for which the value of the key :acc_id has a common value.

arr = [{ red: 346.0,  unu: 10.0, used: 20147.0, acc_id: 550,  percent: 0.01 },
       { red: 0.0,    unu: 1.0,  used: 66.0,    acc_id: 550,  percent: 0.06 },
       { red: 120.0,  unu: 11.0, used: 166.0,   acc_id: 10,   percent: 10.06 },
       { red: 100.0,  unu: 19.0, used: 170.0,   acc_id: 10,   percent: 11.56 },
       { red: 1306.0, unu: 1.0,  used: 13259.0, acc_id: 9999, percent: 0.0 }]

doit(arr, :acc_id)
  #=> [{:red=>173.0, :unu=>5.5, :used=>10106.5, :acc_id=>550.0, :percent=>0.035},
  #    {:red=>110.0, :unu=>15.0, :used=>168.0, :acc_id=>10.0, :percent=>10.81},
  #    {:red=>1306.0, :unu=>1.0, :used=>13259.0, :acc_id=>9999.0, :percent=>0.0}]

Explanation

See Enumerable#group_by and Array#sum (the latter having made its debut in v2.4).

The steps are as follows.

key = :acc_id
keys = arr.first.keys
  #=> [:red, :unu, :used, :acc_id, :percent]
b = arr.group_by { |g| g[key] }
  #=> { 550=>[{:red=>346.0, :unu=>10.0, :used=>20147.0, :acc_id=>550, :percent=>0.01},
  #           {:red=>0.0, :unu=>1.0, :used=>66.0, :acc_id=>550, :percent=>0.06}],
  #      10=>[{:red=>120.0, :unu=>11.0, :used=>166.0, :acc_id=>10, :percent=>10.06},
  #           {:red=>100.0, :unu=>19.0, :used=>170.0, :acc_id=>10, :percent=>11.56}],
  #    9999=>[{:red=>1306.0, :unu=>1.0, :used=>13259.0, :acc_id=>9999, :percent=>0.0}]}
b.map do |_,a| 
  averages = a.map { |h| h.values_at(*keys) }.
               transpose.
               map { |v| v.sum.fdiv(v.size) }
  keys.zip(averages).to_h
end 
  #=> <the array of hashes shown above>