Ruby数组-求对角线的和

以前没有见过这个，但我想知道如何在Ruby中找到2D数组的两条对角线的和。假设您有一个简单的数组，包含3行3列

array = [1,2,3,4,5,6,7,8,9]

我可以使用

array.each_slice(3).to_a

现在应该是

[1,2,3], [4,5,6], [7,8,9]

[1,2,3]
[4,5,6]
[7,8,9]

在这种情况下，对角线是

1 + 5 + 9 = 15
3 + 5 + 7 = 15

因此，总数将是

15+15=30

我在想我能做点什么

diagonal_sum = 0
for i in 0..2
  for j in 0..2
    diagonal_sum += array[i][j]
  end
end

我完全忘记了#map.和#u索引…感谢@xlembouras，这里有一行

first_diagonal = array.map.with_index {|row, i| row[i]} .inject :+
inverted_diagonal = array.map.with_index {|row, i| row[-i-1]} .inject :+

有可能使其成为一艘班轮：

first_diagonal, inverted_diagonal = (array.map.with_index {|row, i| row[i]} .inject :+) , (array.map.with_index {|row, i| row[-i-1]} .inject :+)

原件：

这里有一个想法，这让我觉得有一个#map#u和#u索引方法会很好：

对于从第一个到最后一个对角线：

i = -1
array.map { |row| row[i=i+1] }.inject :+

(0...arr.size).step(n+1).reduce(0) { |t,i| t+arr[i] }
  #=> 15 

对于最后一条到第一条对角线（假设为方形阵列）：

以下是我的尝试：

array = [1,2,3,4,5,6,7,8,9]
sliced = array.each_slice(3).to_a
# As sliced size is 3, I took 2, i.e. 3 - 1
(0..2).map { |i| sliced[i][i] } #=> [1, 5, 9]
(0..2).map { |i| sliced[i][-i-1] } # => [3, 5, 7]
(0..2).map { |i| sliced[i][i] }.reduce :+
# => 15
(0..2).map { |i| sliced[i][-i-1] }.reduce :+
# => 15

根据上述观察，在一次迭代中，您似乎可以解决：

left_diagonal, right_diagoal = (0..2).each_with_object([[], []]) do |i, a|
  a[0] << sliced[i][i]
  a[1] << sliced[i][-i-1]
end

left_diagonal.reduce(:+) # => 15
right_diagonal.reduce(:+) # => 15

---

我将尝试遍历数组，并根据（分组）数组的长度保留所需的值

---

以下内容主要用于学术讨论：

对于主对角线，您正在寻找为“矩阵”类定义的“跟踪”函数。因此，下面的方法是可行的（尽管它不能得到另一条对角线，我也不会对它的效率下注）：

要获得另一条对角线，您必须以某种方式“翻转”矩阵，因此以下操作似乎有效（因为

每个\u片的结果是一个行数组，
reverse
反转行的顺序。反转列的顺序更困难）：

您不需要首先应用
切片
：

arr = [1,2,3,4,5,6,7,8,9]

我们将
arr
可视化为：

1 2 3
4 5 6
7 8 9

n = Math.sqrt(arr.size).round 
  #=> 3

对于主对角线：

i = -1
array.map { |row| row[i=i+1] }.inject :+

(0...arr.size).step(n+1).reduce(0) { |t,i| t+arr[i] }
  #=> 15 

对于非对角线：

i = -1
array.map { |row| row[i=i+1] }.inject :+

(0...arr.size).step(n+1).reduce(0) { |t,i| t+arr[i] }
  #=> 15 

(n-1..arr.size-n).step(n-1).reduce(0) { |t,i| t+arr[i] }
  #=> 15  

另一个例子：

arr = [1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6]

1 2 3 4
5 6 7 8
9 0 1 2
3 4 5 6

n = Math.sqrt(arr.size).round 
  #=> 4

(0...arr.size).step(n+1).reduce(0) { |t,i| t+arr[i] } +
(n-1..arr.size-n).step(n-1).reduce(0) { |t,i| t+arr[i] }
  #=> 14 + 14 => 28

def对角线（数组）
single=array.flatte
新=[]
i=array.length-1
而i新的j是由我决定的，不是免费的。这是一个干净的答案。很好的答案。（我也会发布同样的）一些小的编辑建议。1.“对于主对角线，您可以使用”。2. 
arr=array。每个_片（3）到_a；矩阵（*arr）.trace#=>15
.3。“要获取另一条对角线，需要在调用
trace
：
Matrix[*arr.reverse].trace#=>15
之前颠倒行的顺序。”。不需要回复，因为我想你看到后会删除此评论。这不仅仅是一个学术讨论——这是最好的答案。我的第一个想法是Matrix类可能会派上用场。假设OP是从一个真正的2D数组开始的，对角线是简单的
Matrix[array].trace
.unf幸运的是，我没有看到一种内置的方法来镜像数组以获得反向对角线。回答很好，很简单。有时候，简单的答案就是所需的全部。
(n-1..arr.size-n).step(n-1).reduce(0) { |t,i| t+arr[i] }
  #=> 15  

arr = [1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6]

1 2 3 4
5 6 7 8
9 0 1 2
3 4 5 6

n = Math.sqrt(arr.size).round 
  #=> 4

(0...arr.size).step(n+1).reduce(0) { |t,i| t+arr[i] } +
(n-1..arr.size-n).step(n-1).reduce(0) { |t,i| t+arr[i] }
  #=> 14 + 14 => 28

require 'Matrix'

arr = [[1, 3, 4], [2, 5, 7], [6, 7, 8]]

diag1 = Matrix[*arr].tr
diag2 = Matrix[*arr.reverse].tr

def diagonal(array)
 single=array.flatten
 new=[]
 i=array.length-1

 while i < single.length-2
   new << single[i]
   i+=array.length-1
 end
 new.sum
  
    
end



p diagonal([
    [1, 2, 3],
    [4, 5, 6],
    [7, 9, 8],
]) 


 OUTPUT
 15
That is for finding the sum of right diagonal of a 2D array