Question

我试图找出矩阵中对角线元素的总和。这里，n是方阵的大小，a是矩阵。有人可以向我解释这里发生了什么。

n = 3
a = [[11,2,4],[4,5,6],[10,8,-12]]
sum_first_diagonal = sum(a[i][i] for i in range(n))
sum_second_diagonal = sum(a[n-i-1][n-i-1] for i in range(n))
print(str(sum_first_diagonal)+" "+str(sum_first_diagonal))

Answer 1

使用numpy库，它对任何矩阵计算都很有用。对于您的具体情况：

import numpy as np
a = [[11,2,4],[4,5,6],[10,8,-12]]
b = np.asarray(a)
print 'Diagonal (sum): ', np.trace(b)
print 'Diagonal (elements): ', np.diagonal(b)

您可以使用pip或其他方式轻松安装numpy，这些方法可以在许多网站上找到。

如果您想要所有对角线，而不仅仅是主对角线，请检查也使用numpy的this。

修改

mhawke，如果你想计算反对角线（二级对角线），如wikipedia中所述，你可以在numpy中翻转矩阵

import numpy as np a = [[11,2,4],[4,5,6],[10,8,-12]] b = np.asarray(a) b = np.fliplr(b) print 'Antidiagonal (sum): ', np.trace(b) print 'Antidiagonal (elements): ', np.diagonal(b)

Answer 2

尝试将第二个对角线相加：

sum(a[i][n-i-1] for i in range(n))

内部循环访问这些条目：

>>> n = 3
>>> [(i, n-i-1) for i in range(n)]
[(0, 2), (1, 1), (2, 0)]

您的样本矩阵的此对角线的总和值为：

>>> n = 3
>>> sum(a[i][n-i-1] for i in range(n))
19

代码中的错误是对两个维使用相同的表达式：

a[n-i-1][n-i-1]

将以相反的顺序[(2, 2), (1, 1), (0, 0)]再次处理第一个对角线，给你两次相同的和。

Answer 3

试试这个：

n=3
sum_second_diagonal=sum([a[i][j] for i in range(n) for j in range(n) if i==j]) #it will add when i==j

Answer 4

从平方矩阵中获取总和对角线总和

squared_matrix = [[2,3,4],[4,3,3],[3,3,4]]
s, ds = get_sum(squared_matrix)

def get_sum(diag_mat):
    n = len(diag_mat)
    total = sum([diag_mat[i][j] for i in range(n) for j in range(j)]
    d_sum = sum([diag_mat[i][j] if i==j else 0 for i in range(n) for j in range(j)]
   return d_sum, total

Answer 5

由于您知道行i的对角线元素的位置，因此您可以非常密集地编写它：

d = sum(row[i] + row[-1-i] for i, row in a)

并且，对于奇数大小的矩阵，您不应该将中心元素添加两次：

if len(a)%2:
    centre = len(a)//2
    d -= a[centre][centre]

Answer 6

def sum_diagnol():
    import random
    sum=0
    r1=int(input("row"))
    c1=int(input("col"))
    a=[[random.random()for col in range(c1)]for row in range(r1)]
    print("enter elements")
    for i in range(r1):
        for j in range(c1):
            a[i][j]=int(input("enter elements"))
    r2=int(input("row"))
    c2=int(input("col"))
    b=[[random.random()for col in range(c2)]for row in range(r2)]
    print("enter elements")
    for i in range(r2):
        for j in range(c2):
            b[i][j]=int(input("enter elements"))
    c=[[random.random()for col in range(c2)]for row in range(r1)]
    if(c1==r2):
        for i in range(r1):
            for j in range(c2):
                c[i][j]=0
                for k in range(c2):
                    c[i][j]=a[j][k]*b[k][j]
    else:
        print("multiplication not possible")
    for i in range(r1):
        for j in range(c2):
            print(c[i][j],end=" ")
        print()
sum_diagnol()

Answer 7

您可以按照以下代码获取矩阵中第一个对角线的总和和第二个对角线的总和。我认为这将是最了解的方式。

获取第一个对角线的总和，

n = 3
a = [[11,2,4],[4,5,6],[10,8,-12]]
sum_1_diagonal = 0
for x in range(0, n):
    for y in range(0, n):
       if x == y:
          sum_1_diagonal = sum_1_diagonal + a[x][y]

获取第二个对角线的总和，

n = 3
a = [[11,2,4],[4,5,6],[10,8,-12]]
sum_2_diagonal = 0
for x in range(0, n):
    for y in range(0, n):
       if x + y == n - 1:
          sum_2_diagonal = sum_2_diagonal + a[x][y]

Answer 8

我找到了一种简单的算法来完成此任务。

将方阵存储在单个一维数组中。



让'n'为方阵的顺序。



有两个对角线，一个从对角线的最左边的元素开始，   另一个从第一行的第n个元素开始。



从包含矩阵中所有数字的数组中获取对角线的索引，该对角线从顶部行中最左边的元素开始；只需从索引1开始递归地添加（n + 1）。   也就是说，数组中从左到右对角线的元素索引为1，1+（n + 1），（n + 2）+（n + 1），（2n + 3）+（n + 1）直到数组的最后一个索引。



从包含矩阵中所有数字的数组中获取另一个对角线数字的索引；只需将索引（n-1）递归地添加到从索引等于'n'的索引开始，即n方阵的顺序。   也就是说，数组中对角线从右到左的元素的索引为n，n +（n-1），（2n-1）+（n-1），依此类推，直到索引等于“数组的长度- （n-1）”。



如果顺序为奇数，则从最终的总和中减去数组中的中间数字。



示例“ c ++”代码如下：

 #include<iostream>
 using namespace std;

int sumOfDiagonalNumbersInSquareMatrix(int numberArray[],int order){
int sumOfLeftToRightDiagonal = 0;
int sumOfRightToLeftDiagonal = 0;
int length = order*order;
for(int i=0; i<length;i+=(order+1)){
    //cout<<numberArray[i]<<"\t";
    sumOfLeftToRightDiagonal = sumOfLeftToRightDiagonal + numberArray[i];

}
for(int i=(order-1);i<=length-order;i+=(order-1)){
    //cout<<numberArray[i]<<"\t";
    sumOfRightToLeftDiagonal = sumOfRightToLeftDiagonal + numberArray[i];
}
if(order % 2 != 0){
    return (sumOfLeftToRightDiagonal + sumOfRightToLeftDiagonal) - numberArray[(length/2)];
}
return (sumOfLeftToRightDiagonal + sumOfRightToLeftDiagonal);
}

 int main(){
 int nums[] = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16};
 cout<<sumOfDiagonalNumbersInSquareMatrix(nums,4);
 return 0;
 }

您可以在这里运行它：http://cpp.sh/6cmdp

Answer 9

我不明白为什么没人发布任何好的解决方案。这是下降的解决方案：

length = len(arr)
r1 = 0
r2 = 0
for i in range(length):
    r1 += arr[i][length - i - 1]
    r2 += arr[i][i]
print(r1 + r2)
# If you want sum of there absolute values
print(abs(r1) + abs(r2))

此处arr是2d列表。

Answer 10

def sum_up_diagonals(li):
index = len(li)
first_dia =  sum(li[i][i]for i in range(index))
second_dia = sum(li[i][index-i-1]for i in range(index))
return (first_dia,second_dia)

传递您的列表。这应该适合您：）

Answer 11

O（n）时间解以找到给定多维数组的对角线差异。

def diagonalDifference(arr):
        # arr[0][0], arr[1][1], arr[2][2]
        # arr[0][2], arr[1][1], arr[2][0]
        sumOfDiagonalFromLeft = 0
        sumOfDiagonalFromRight = 0
        pointIndexFromLeft = 0
        pointIndexFromLast = len(arr)-1
        for i in range(len(arr)):
            sumOfDiagonalFromLeft += arr[i][pointIndexFromLeft]
            # print(arr[i][pointIndexFromLeft])
            pointIndexFromLeft += 1
        
        for i in range(len(arr)):
            sumOfDiagonalFromRight += arr[i][pointIndexFromLast]
            # print(arr[i][pointIndexFromLast])
            if pointIndexFromLast < 0:
                break
            else:
                pointIndexFromLast -= 1
    
        diagonalDifference = abs(sumOfDiagonalFromLeft - sumOfDiagonalFromRight)
        return diagonalDifference
    
arr = [[11, 2, 4], [4, 5, 6], [10, 8, -12]]
print(diagonalDifference(arr))

Answer 12

'''

a = [[],[],[]] #your matrix
s = 0
for i in range(len(a)):
    for j in range(len(a[0])):
           if i == j:
               s += a[i][j]
print('sum ='s)

''' 这是一个简单的方法。谢谢

矩阵中对角元素的总和

12 个答案: