紅寶石合併n個哈希元素，並採取中間鍵

Question

我有以下structur的哈希：

{ 
    timestamp1 => { attr1 => 1, attri2 => 2, attr3 => 3}, 
    timestamp2 => { attr1 => 1, attri2 => 2, attr3 => 3}, 
    timestamp3 => { attr1 => 1, attri2 => 2, attr3 => 3}, 
    ... 
} 

我要做的是總結n個元素在一起，取中間時間戳。 因此，例如，在這種情況下，如果將3天合併在一起，我想這樣的結果：

{ 
    timestamp2 => {attr1 => 3. attr2 => 6, attr3 => 9} 
    timestamp5 => ... # Here the next summed values 
    ... 
} 

我這樣做，現在媒體鏈接，它是工作，但代碼是不完全好的，它只是將合併直到只剩下中間一個第一和最後一個元素是左：

hash.each_slice(n) do |part| 
    iterator = 0 

    while(part.length > 1) do 
    hash_a = part.first.last 
    hash_b = part.last.last 

    new_values = hash_a.merge(hash_b){ | key, oldval, newval| (newval + oldval) 

    if iteration % 2 == 0 
    part[0][1] = new_values 
    part.delete_at(part.count-1) 
    else 
    part.delete_at(0) 
    part[part.count-1][1] = new_values 
    end 
    iteration += 1 
end 

注：我知道這個代碼是不漂亮，但你沒有糾正這一點，它僅僅是一個例子，不是我的實際代碼。

現在我想知道的。有沒有更好的方法來實現這一點，有些減少，選擇，group_by或合併。如果我能擺脫while循環，那將是非常好的。

預先感謝您。

Answer 1

N = 3 

hash.each_slice(N).map do |part| 
    [part[part.size/2].first, part.each_with_object({}) do |(_, v), acc| 
    acc.merge!(v) { |_, v1, v2| v1 + v2 } 
    end] 
end.to_h 

Answer 2

代碼

def group(h,n) 
    h.each_slice(n).with_object({}) do |a,g| 
    key = a[(a.size-1)/2].first 
    a.each {|k,f| g.update(key=>f) {|_,oh,nh| oh.merge(nh) {|_,ov,nv| ov+nv}}} 
    end 
end 

這不會發生變異h。

例

爲了證明代碼我將使用含有鍵文字的散列。

h = { 
    :timestamp1 => { :attr1 => 1, :attri2 => 2, :attr3 => 3}, 
    :timestamp2 => { :attr1 => 1, :attri2 => 2, :attr3 => 3}, 
    :timestamp3 => { :attr1 => 1, :attri2 => 2, :attr3 => 3}, 
    :timestamp4 => { :attr1 => 4, :attri2 => 5, :attr3 => 6}, 
    :timestamp5 => { :attr1 => 4, :attri2 => 5, :attr3 => 6}, 
    :timestamp6 => { :attr1 => 4, :attri2 => 5, :attr3 => 6}, 
} 

group(h,1) == h 
    #=> true 
group(h,2) 
    #=> {:timestamp1=>{:attr1=>2, :attri2=>4, :attr3=>6}, 
    # :timestamp3=>{:attr1=>5, :attri2=>7, :attr3=>9}, 
    # :timestamp5=>{:attr1=>8, :attri2=>10, :attr3=>12}} 
group(h,3) 
    #=> {:timestamp2=>{:attr1=>3, :attri2=>6, :attr3=>9}, 
    # :timestamp5=>{:attr1=>12, :attri2=>15, :attr3=>18}} 
group(h,4) 
    #=> {:timestamp2=>{:attr1=>7, :attri2=>11, :attr3=>15}, 
    # :timestamp5=>{:attr1=>8, :attri2=>10, :attr3=>12}} 
group(h,5) 
    #=> {:timestamp3=>{:attr1=>11, :attri2=>16, :attr3=>21}, 
    # :timestamp6=>{:attr1=>4, :attri2=>5, :attr3=>6}} 
group(h,6) 
    #=> {:timestamp4=>{:attr1=>15, :attri2=>21, :attr3=>27}} 

說明

我已經使用的Hash#update（又名Hash.merge!）和Hash#merge僱用一個塊，以確定存在於被合併兩個散列密鑰的值的形式。 （「舊值」），nh（「新值」），ov（「舊值」）和nv（「新值」）參見文檔以解釋塊變量_（常用密鑰），oh 。

步驟如下。

n = 3 
enum0 = h.each_slice(n) 
    #=> #<Enumerator: {:timestamp1=>{:attr1=>1, :attri2=>2, :attr3=>3}, 
    #     :timestamp2=>{:attr1=>1, :attri2=>2, :attr3=>3}, 
    #     ... 
    #     :timestamp6=>{:attr1=>4, :attri2=>5, :attr3=>6}} 
    #  :each_slice(3)> 
enum1 = enum0.with_object({}) 
    #=> #<Enumerator: 
    #  #<Enumerator: {:timestamp1=>{:attr1=>1, :attri2=>2, :attr3=>3}, 
    #     :timestamp2=>{:attr1=>1, :attri2=>2, :attr3=>3}, 
    #     ... 
    #     :timestamp6=>{:attr1=>4, :attri2=>5, :attr3=>6}} 
    #  :each_slice(3)>:with_object({})> 

我們可以檢查將被enum1通過轉換enum1到一個陣列產生並傳遞到該塊中的（二）的元件。

enum1.to_a 
    #=> [ 
    #  [ 
    #  [ 
    #   [:timestamp1, {:attr1=>1, :attri2=>2, :attr3=>3}], 
    #   [:timestamp2, {:attr1=>1, :attri2=>2, :attr3=>3}], 
    #   [:timestamp3, {:attr1=>1, :attri2=>2, :attr3=>3}]], 
    #   {} 
    #  ], 
    #  [ 
    #  [ 
    #   [:timestamp4, {:attr1=>4, :attri2=>5, :attr3=>6}], 
    #   [:timestamp5, {:attr1=>4, :attri2=>5, :attr3=>6}], 
    #   [:timestamp6, {:attr1=>4, :attri2=>5, :attr3=>6}]], 
    #   {} 
    #  ] 
    #  ] 

空數組由塊變量g表示。該方法將構建並返回。將由enum1生成的第一個元素傳遞給該塊，並使用並行分配分配兩個塊變量。

a,g = enum1.next 
    #=> [ 
    #  [ 
    #  [:timestamp1, {:attr1=>1, :attri2=>2, :attr3=>3}], 
    #  [:timestamp2, {:attr1=>1, :attri2=>2, :attr3=>3}], 
    #  [:timestamp3, {:attr1=>1, :attri2=>2, :attr3=>3}] 
    #  ] 
    #  {} 
    # ] 
a #=> [ 
    #  [:timestamp1, {:attr1=>1, :attri2=>2, :attr3=>3}], 
    #  [:timestamp2, {:attr1=>1, :attri2=>2, :attr3=>3}], 
    #  [:timestamp3, {:attr1=>1, :attri2=>2, :attr3=>3}] 
    # ] 
g #=> {} 

現在可以執行塊計算。

key = a[(a.size-1)/2].first 
    #=> a[2].first 
    #=> [:timestamp2, {:attr1=>1, :attri2=>2, :attr3=>3}].first 
    #=> :timestamp2 
enum2 = a.each 
    #=> #<Enumerator: [[:timestamp1, {:attr1=>1, :attri2=>2, :attr3=>3}], 
    #     [:timestamp2, {:attr1=>1, :attri2=>2, :attr3=>3}], 
    #     [:timestamp3, {:attr1=>1, :attri2=>2, :attr3=>3}]] 
    #  :each> 
enum2.to_a # for display purposes only 
    #=> [[:timestamp1, {:attr1=>1, :attri2=>2, :attr3=>3}], 
    # [:timestamp2, {:attr1=>1, :attri2=>2, :attr3=>3}], 
    # [:timestamp3, {:attr1=>1, :attri2=>2, :attr3=>3}]] 
k,f = enum2.next 
    #=> [:timestamp1, {:attr1=>1, :attri2=>2, :attr3=>3}] 
k #=> :timestamp1 
f #=> {:attr1=>1, :attri2=>2, :attr3=>3} 
g.update(key=>f) {|_,oh,nh| 
    oh.merge(nh) {|_,ov,nv| g.update(key=>f) {|_,oh,nh| oh.merge(nh) {|_,ov,nv| ov+nv}}}} 
    #=> g.update(:timestamp2=>{:attr1=>1, :attri2=>2, :attr3=>3}) {|_,oh,nh| 
    #  oh.merge(nh) {|_,ov,nv| ov+nv}}}} 
    #=> {:timestamp2=>{:attr1=>1, :attri2=>2, :attr3=>3}} 

然後

k,f = enum2.next 
    #=> [:timestamp2, {:attr1=>1, :attri2=>2, :attr3=>3}] 
k #=> :timestamp2 
f #=> {:attr1=>1, :attri2=>2, :attr3=>3} 
g.update(key=>f) {|_,oh,nh| oh.merge(nh) {|_,ov,nv| ov+nv}} 
    # g.update(:timestamp2=>{:attr1=>1, :attri2=>2, :attr3=>3} {|_,oh,nh| 
    # oh.merge(nh) {|_,ov,nv| ov+nv}} 
    #=> {:timestamp2=>{:attr1=>2, :attri2=>4, :attr3=>6}} 

其餘的計算是相似的。

^{1公用密鑰用下劃線表示，表示它在塊計算中不使用。}