arrays - 使用 Ruby 合并基于相似位置的数组哈希

Question

我有以下两个以数组作为值的散列。

a = {
  "Us" => [["1", ["1", "2"]], ["2", ["1"]]],
  "Pa" => [["1", ["1", "3", "5"]], ["4", ["7"]]]
}
b = {
  "Us" => [["1", ["F", "O"]], ["2", ["N"]]],
  "Pa" => [["1", ["S", "D", "H"]], ["4", ["K"]]]
}

我正在尝试合并哈希以获得这样的最终结果:

c = {
  "Us" => [["1", ["1|F", "2|O"]], ["2", ["1|N"]]],
  "Pa" => [["1", ["1|S", "3|D", "5|H"]], ["4", ["7|K"]]]
}

我通过 merge 找到了以下代码，并尝试将其应用于我的问题，但出现错误:

a.merge(b) {|key, a_val, b_val| a_val.merge b_val }
# >> NoMethodError: undefined method `merge' for [["1", ["1", "2"]], ["2", ["1"]]]:Array

我什至在使用 a + b 时遇到错误:

a + b
# >> NoMethodError: undefined method `+' for #<Hash:0x0000060078e460>

<<<< 更新 >>>>>

感谢卡里和塔德曼。在原始问题之外，我展示了我拥有的输入文件和我试图获得的输出。我展示是为了让你知道为什么我以这种方式生成了 2 个哈希值。在输出中，我创建了 block ，其中父亲是第 1 列的唯一值，在 child 下面(第 2 列中与第 1 列相关的唯一值)。第 3 列是属于 col2 中的值的子项，第 4 列是与 col3 相关的文本内容。

可能哈希“c”从一开始就更容易生成。

这是我的输入文件

Main,Stage1,Stage2,Description
Us,1,1,F
Us,1,2,O
Us,2,1,N
Pa,1,1,S
Pa,1,3,D
Pa,1,5,H
Pa,4,7,K

这是我几乎得到的输出。

Main..Stage1..Stage2..Description       
Us      
......1
..............1.......F
..............2.......O
......2 
..............1.......N
Pa
......1
..............1.......S
..............3.......D
..............5.......H
......4
..............7.......K

然后我能够创建此代码，但就像 tadman 所说的那样，我需要重新排序我获得此代码的方式以使事情变得更容易，因为我使用 4 个哈希值。创建散列“a”和“b”后，我被卡住了，因为我需要一个唯一的散列来迭代并能够在上面显示的输出结构中打印。

我在发布问题之前的代码

X = Hash.new{|hsh,key| hsh[key] = [] }
Y = Hash.new{|hsh,key| hsh[key] = [] }
a = Hash.new{|hsh,key| hsh[key] = [] }
b = Hash.new{|hsh,key| hsh[key] = [] }

File.foreach('file.txt').with_index do
    |line, line_num|

    if line_num > 0
        r = line.split(",")

        X[r[0] + "°" + r[1]].push r[2]
        Y[r[0] + "°" + r[1]].push r[3].strip
    end
end

X.each{ |k,v|
    lbs = k.split("°")
    a[lbs[0]].push [ lbs[1], v] #Here I generate hash a
}

Y.each{ |k,v|
    lbs = k.split("°")
    b[lbs[0]].push [ lbs[1], v] #Here I generate hash b
}

Answer 1

由于所有复杂的嵌套，您在这里需要做一些工作才能解决。如果您做了一些工作来重新排序数据的存储方式，这会容易得多。

但你可以这样做:

a={"Us"=>[["1", ["1", "2"]], ["2", ["1"]]], "Pa"=>[["1", ["1", "3", "5"]], ["4", ["7"]]]}
b={"Us"=>[["1", ["F", "O"]], ["2", ["N"]]], "Pa"=>[["1", ["S", "D", "H"]], ["4", ["K"]]]}

c = a.keys.map do |k|
  ah = a[k].to_h
  bh = b[k].to_h

  [
    k,
    ah.keys.map do |ka|
      [
        ka,
        ah[ka].zip(bh[ka]).map do |pair|
          pair.join('|')
        end
      ]
    end
  ]
end.to_h

# => {"Us"=>[["1", ["1|F", "2|O"]], ["2", ["1|N"]]], "Pa"=>[["1", ["1|S", "3|D", "5|H"]], ["4", ["7|K"]]]}

这里的关键是严格使用 map 来转换每一层，并使用 zip 将两个数组“压缩”成对，然后可以用 join 组合 到所需的字符串目标。返回到末尾带有 to_h 的哈希，您将得到想要的结果。

每个子集都有一个到散列的中间转换，以处理可能以不同顺序指定明显“键”的乱序情况。

您要做的是将其包装在一个具有描述性名称的方法中:

def hash_compactor(a,b)
  # ... (code) ...
end

这将有助于保持模块化。通常我会尝试创建处理 N 个参数的解决方案，方法是将其定义为:

def hash_compactor(*input)
  # ...
end

其中 input 是您给定形式的各种集合的数组。令人惊讶的是，生成的代码要复杂得多。

请注意，这对输入完全匹配做出了很多假设，如果不是这种情况就会爆炸。