[Solved] Sum of diagonal elements in a matrix

I am trying to find out the sum of the diagonal elements in a matrix. Here, n is the size of the square matrix and a is the matrix. Can someone explain this to me what is happening here.

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))

Solution #1:

Try this for summing your second diagonal:

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

The inner loop accesses these entries:

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

And the summed value of this diagonal for your sample matrix is:

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

The mistake in your code is to use the same expression for both dimensions:


which will process the first diagonal again in reverse order [(2, 2), (1, 1), (0, 0)] giving you the same sum twice.

Respondent: Hassan Imam

Solution #2:

Use numpy library which is powerful for any matrix calculations. For your specific case:

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)

You can easily install numpy with pip or other ways that you will find on many webs.

If you want all the diagonals, and not just the main diagonal, check this that also uses numpy.


mhawke, if you want to calculate antidiagonal (secondary diagonal), as explained in wikipedia, you can flip the matrix in 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)
Respondent: mhawke

Solution #3:

getting total and diagonal sum from a squared matrix

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
Respondent: iblasi

Solution #4:

try this:

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
Respondent: Samir Paul

Solution #5:

I don’t understand why no one posted any good solution.
Here is as descent solution:

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))

Here arr is a 2d list.

Respondent: Binyamin Even

Solution #6:

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)

Pass in your list.
This should work for you 🙂

Respondent: Akshat Tamrakar

Solution #7:

O(n) time solution to find the diagonal difference of given multidimensional array.

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:
                pointIndexFromLast -= 1
        diagonalDifference = abs(sumOfDiagonalFromLeft - sumOfDiagonalFromRight)
        return diagonalDifference
arr = [[11, 2, 4], [4, 5, 6], [10, 8, -12]]
Respondent: greyk0

Solution #8:

Since you know the positions of the diagonal elements for row i, you can write it quite densely like:

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

And, for odd sized matrices, you shouldn’t add the center element twice:

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

Solution #9:

def sum_diagnol():
    import random
    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"))
    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)]
        for i in range(r1):
            for j in range(c2):
                for k in range(c2):
        print("multiplication not possible")
    for i in range(r1):
        for j in range(c2):
            print(c[i][j],end=" ")
Respondent: xtofl

Solution #10:

I found a simple algorithm to accomplish this task.

  1. Store the square matrix in a single one dimensional array.

  2. Let ‘n’ be the order of square matrix.

  3. There are two diagonals , one that starts from the leftmost element in top row and
    another that starts from nth element of the top row.

  4. To get the indexes of numbers on the diagonal that starts from left most element in top row ,from the array containing all the numbers in the matrix; just add (n+1) recursively starting from index 1.
    That is, indexes of elements in left to right diagonal in the array are, 1, 1+(n+1) , (n+2)+(n+1) , (2n+3)+(n+1) till the last index of array.

  5. To get the indexes of another diagonal’s numbers from the array containing all the numbers in the matrix ; just add (n-1) recursively to the indexes starting from index equals to the ‘n’, which is the order of the square matrix.
    That is, indexes of elements in right to left diagonal in the array are, n, n+(n-1), (2n-1)+(n-1) and so on till the index equals to ‘length of the array – (n-1)’.

  6. If the order is odd then subtract the middle number in the array from the final sum.

The example ‘c++’ code is as follows:

 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)){
    sumOfLeftToRightDiagonal = sumOfLeftToRightDiagonal + numberArray[i];

for(int i=(order-1);i<=length-order;i+=(order-1)){
    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};
 return 0;

You can run it here: http://cpp.sh/6cmdp

Respondent: Sathvik Andela

Solution #11:


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)

here is a simple approach.

Respondent: Deepeshkumar

The answers/resolutions are collected from stackoverflow, are licensed under cc by-sa 2.5 , cc by-sa 3.0 and cc by-sa 4.0 .

Leave a Reply

Your email address will not be published. Required fields are marked *

New ride at Perth's Adventure World a ‘swing on steroids’ - Australasian Leisure Management npp pharma the truth about anabolic steroid drugs and professional sports