红宝石，计数阵列内

Question

我有阵列的一个字符串数组和2 INT那样：

[["u31", 12, 23], ["u26", 12, 23], ["u26", 11, 3]] 

我首先需要合并这些阵列基于所述字符串的多个发生和累积ARR的值[1]和ARR [2]

因此，对于本例，我需要这样的：

[["u31", 12, 23], ["u26", 23, 26]] 

然后拆分那些这两个值那样：

[ 
    ["u31", "dl", 12], 
    ["u31", "ul", 23], 
    ["u26", "dl", 23], 
    ["u31", "ul", 26] 
] 

然后按降序排序。

我该怎么做？

Answer 1

我会倾向于以不同的顺序执行计算：

arr = [["u31", 12, 23], ["u26", 12, 23], ["u26", 11, 3]] 

arr.each_with_object({}) { |(s,*v),h| ['d1','ul'].zip(v).each { |t,x| 
     h.update([s,t]=>x) { |_,ox,nx| ox+nx } } }. 
    map { |(s,t),x| [s,t,x] }. 
    sort. 
    reverse 
    #=> [["u31", "ul", 23], 
    # ["u31", "d1", 12], 
    # ["u26", "ul", 26], 
    # ["u26", "d1", 23]] 

让我们来看看这里发生了什么。

enum0 = arr.each_with_object({}) 
    #=> #<Enumerator: [["u31", 12, 23], ["u26", 12, 23], 
    #     ["u26", 11, 3]]:each_with_object({})> 

我们可以枚举转换为数组看什么值将由each被传递到块：

enum0.to_a 
    #=> [[["u31", 12, 23], {}], [["u26", 12, 23], {}], 
    # [["u26", 11, 3], {}]] 

我们可以使用Enumerator#next获得枚举的每个值和手动分配它该块变量：

(s,*v),h = enum0.next 
    #=> [["u31", 12, 23], {}] 
s #=> "u31" 
v #=> [12, 23] 
h #=> {} 

注意我是如何分解或“消歧”传递到块阵列，这样我就不必在块内拆开它。

a = ['d1','ul'].zip(v) 
    #=> [["d1", 12], ["ul", 23]] 

上来：另一个枚举：

enum1 = a.each 
    #=> #<Enumerator: [["d1", 12], ["ul", 23]]:each> 
t,x = enum1.next 
    #=> ["d1", 12] 
h.update([s,t]=>x) 
    #=> {}.update(["u31,"d1"]=>12) 
    #=> {["u31", "d1"]=>12} 

Hash#update（又名merge!）具有被构建了用来决定存在于两者的散列密钥的值的块（h）和散列被合并（{["u31", "d1"]=>12}）。由于h为空，因此该块不用于第一次合并。

接下来，

t,x = enum1.next 
    #=> ["ul", 23] 
h.update([s,t]=>x) 
    #=> {["u31", "d1"]=>12}.update(["u31", "ul"]=>23) 
    #=> {["u31", "d1"]=>12, ["u31", "ul"]=>23} 

其中update返回h新值。我们已完成enum1，所以在enum0和类似的计算下一个值each通行证进行：

(s,*v),h = enum0.next 
    #=> [["u26", 12, 23], {["u31", "d1"]=>12, ["u31", "ul"]=>23}] 
['d1','ul'].zip(v).each { |t,x| h.update([s,t]=>x) {|_,ox,nx| ox+nx }} 
    #=> [["d1", 12], ["ul", 23]] 
h #=> {["u31", "d1"]=>12, ["u31", "ul"]=>23, ["u26", "d1"]=>12, 
    # ["u26", "ul"]=>23} 

我们现在通过的enum0第三和最后一个值成块。同样，计算是一样的，除了update步：

(s,*v),h = enum0.next 
    #=> [["u26", 11, 3], 
    # {["u31", "d1"]=>12, ["u31", "ul"]=>23, ["u26", "d1"]=>12, 
    #  ["u26", "ul"]=>23}] 
a = ['d1','ul'].zip(v) 
    #=> [["d1", 11], ["ul", 3]] 
enum1 = a.each 
    #=> #<Enumerator: [["d1", 11], ["ul", 3]]:each> 
t,x = enum1.next 
    #=> ["d1", 11] 
h.update([s,t]=>x) 
    #=> {["u31", "d1"]=>12, ["u31", "ul"]=>23, 
    # ["u26", "d1"]=>12, ["u26", "ul"]=>23}.update(["u26","d1"],11) 
    # h and the hash being merged both have the key ["u26", "d1"], 
    # so the merged value is determined by update's block: 
    #=> { |_,ox,nx| ox+nx } => 12+11 => 23 
    #=> {["u31", "d1"]=>12, ["u31", "ul"]=>23, 
    # ["u26", "d1"]=>11, ["u26", "ul"]=>23} 
t,x = enum1.next 
    #=> ["ul", 3] 
h.update([s,t]=>x) 
    #=> {["u31", "d1"]=>12, ["u31", "ul"]=>23, 
    # ["u26", "d1"]=>11, ["u26", "ul"]=>26} 

我们现在基本上是完成了。我们只是有这个哈希转化为所需形式的数组：

a = h.map { |(s,t),x| [s,t,x] } 
    #=> [["u31", "d1", 12], ["u31", "ul", 23], 
    # ["u26", "d1", 11], ["u26", "ul", 26]] 

和排序：

a.sort.reverse 
    #=> [["u31", "ul", 23], 
    # ["u31", "d1", 12], 
    # ["u26", "ul", 26], 
    # ["u26", "d1", 11]]