Ruby中的二维数组处理

我有一个二维整数值数组。我希望以最有效的方式处理阵列。处理逻辑是：

如果摘要[行][col]大于摘要[列][row]，则摘要[行][col]-=摘要[列][row]，反之亦然。如果两者相等，则将两个位置置零。基本上，计算两个位置之间的绝对差

这是我建立的逻辑。是否有一种更干净、更有效的方法使用数组函数来实现这一点

  row_ix = 0
  summary.each do |row|
    col_ix = 0
    row.each do |row_to_col_amt|
      if row_ix == col_ix
        col_ix += 1
        next
      end
      col_to_row_amt = summary[col_ix][row_ix]
      if row_to_col_amt >  col_to_row_amt
        summary[row_ix][col_ix] -= col_to_row_amt
        summary[col_ix][row_ix] = 0
      elsif row_to_col_amt <  col_to_row_amt
        summary[col_ix][row_ix] -= row_to_col_amt
        summary[row_ix][col_ix] = 0
      else
        summary[row_ix][col_ix] = 0
        summary[col_ix][row_ix] = 0
      end
      col_ix += 1
    end
    row_ix += 1
  end

第九行=0
summary.do每行|
col_ix=0
行。每个do |行到列金额|
如果第九行==第九列
col_ix+=1
下一个
结束
列至列金额=汇总[列九][列九]
如果行至列金额>列至行金额
汇总[第九行][第九列]-=第九列至第九行金额
摘要[第九列][第九行]=0
elsif行至列金额<列至行金额
汇总[第九列][第九列]-=第九列至第九列金额
摘要[第九行][第九列]=0
其他的
摘要[第九行][第九列]=0
摘要[第九列][第九行]=0
结束
col_ix+=1
结束
第九行+=1
结束

如果我理解这个问题

ary

应该是一个方阵，因此（x，y）和（y，x）之间存在1:1的关系。因为在对角线上，

ari（x，y）==ari（y，x）

始终为真，所以我将其保持不变（或者很容易将其设置为

0

）

因此，根据矩阵：

ary = 
      [
        [1,  5,  5,  1, 5],
        [1,  1,  1,  1, 1],
        [1,  1,  1,  1, 1 ],
        [1,  1,  1,  1, 1 ],
        [5,  10, 10,  1, 10]
      ]

让我们定义一个返回上部三角形索引的方法，不包括对角线：

def top_triangle_idxs(ary)
  n = ary.size - 1
  res = []
  (0..n).each do |m|
    (1..n).each do |n|
      res << [m,n] unless m == n || m > n
    end
  end
  res
end

现在，让我们迭代

idxs

执行以下逻辑：

idxs.each do |x,y|
  ary[x][y] -= ary[y][x] if ary[x][y] > ary[y][x]
  ary[y][x] -= ary[x][y] if ary[x][y] < ary[y][x]
  ary[x][y] = ary[y][x] = 0 if ary[x][y] == ary[y][x]
end

---

使用和可以得到相同的结果，但要构建一个新的矩阵：

res = ary.each_with_index.with_object(Array.new(ary.size) { [] }) do |(row, x), new_ary|
  row.each_with_index do |e, y|
    new_ary[x][y] = e
    new_ary[x][y] = e - ary[y][x] if ary[x][y] > ary[y][x]
    new_ary[x][y] = 0 if e == ary[y][x] && x != y
  end
end

---

谢谢，是的，它是一个正方形矩阵。谢谢你的解决方案。我想知道是否有一个更简单的解决方案涉及数组函数，如reduce、map等，以便减少自定义代码

ary.each(&method(:p))
# [1, 4, 4, 0, 0]
# [1, 1, 0, 0, 1]
# [1, 0, 1, 0, 1]
# [0, 0, 0, 1, 0]
# [0, 9, 9, 0, 10]

res = ary.each_with_index.with_object(Array.new(ary.size) { [] }) do |(row, x), new_ary|
  row.each_with_index do |e, y|
    new_ary[x][y] = e
    new_ary[x][y] = e - ary[y][x] if ary[x][y] > ary[y][x]
    new_ary[x][y] = 0 if e == ary[y][x] && x != y
  end
end