Matrix Diagonal Sum - Practice Coding Problems

Matrix Diagonal Sum - Problem

Array Matrix Easy

Matrix Diagonal Sum is a fundamental matrix manipulation problem that tests your understanding of 2D array indexing. Given a square matrix mat, you need to calculate the sum of elements on both diagonals.

The primary diagonal runs from top-left to bottom-right (elements where i == j), while the secondary diagonal runs from top-right to bottom-left (elements where i + j == n - 1). The key challenge is avoiding double-counting the center element in odd-sized matrices, where both diagonals intersect.

Goal: Return the sum of all diagonal elements, counting the center element only once.
Input: A square matrix mat of size n × n
Output: An integer representing the sum of diagonal elements

Input & Output

example_1.py — 3x3 Matrix

$ Input: mat = [[1,2,3],[4,5,6],[7,8,9]]

› Output: 25

💡 Note: Primary diagonal: 1 + 5 + 9 = 15. Secondary diagonal: 3 + 5 + 7 = 15. Center element 5 is counted twice, so total = 15 + 15 - 5 = 25.

example_2.py — 4x4 Matrix

$ Input: mat = [[1,1,1,1],[1,1,1,1],[1,1,1,1],[1,1,1,1]]

› Output: 8

💡 Note: Primary diagonal: 1 + 1 + 1 + 1 = 4. Secondary diagonal: 1 + 1 + 1 + 1 = 4. No center overlap in even-sized matrix, so total = 4 + 4 = 8.

example_3.py — 1x1 Matrix

$ Input: mat = [[5]]

› Output: 5

💡 Note: Single element matrix - the only element is both on primary and secondary diagonal, but counted once. Result = 5.

Constraints

n == mat.length == mat[i].length
1 ≤ n ≤ 100
1 ≤ mat[i][j] ≤ 100
The matrix is always square

Visualization

Tap to expand

Understanding the Visualization

Identify Diagonals

Primary diagonal (↘): i==j positions. Secondary diagonal (↙): i+j==n-1 positions

Single Pass

For each row, access both mat[i][i] and mat[i][n-1-i] simultaneously

Handle Overlap

In odd-sized matrices, center element appears on both diagonals - subtract once

Return Sum

Total sum represents all diagonal elements counted exactly once

Key Takeaway

🎯 Key Insight: The optimal solution recognizes that we only need to visit diagonal elements, and cleverly handles the center overlap by subtracting it once when the matrix size is odd.

Asked in

a Amazon 25 G Google 18 ⊞ Microsoft 15 f Meta 12

The optimal solution uses a single pass through the matrix rows, accessing both diagonal elements simultaneously in O(n) time. The key insight is handling the center element overlap in odd-sized matrices by subtracting it once after adding both diagonals.

Common Approaches

Approach	Time	Space	Notes
✓ Single Pass Diagonal Traversal (Optimal)	O(n)	O(1)	Visit only diagonal elements in one pass, handling center overlap efficiently
Brute Force (Check Every Element)	O(n²)	O(1)	Iterate through every matrix element and check if it belongs to either diagonal

Single Pass Diagonal Traversal (Optimal) — Algorithm Steps

Initialize sum to 0
For each row i from 0 to n-1:
Add primary diagonal element: mat[i][i]
Add secondary diagonal element: mat[i][n-1-i]
If both elements are the same (center), subtract it once
Return the total sum

Visualization

Tap to expand

Step-by-Step Walkthrough

Row 0

Add mat[0][0] + mat[0][n-1] = primary + secondary diagonal

Row 1

Add mat[1][1] + mat[1][n-2] = next diagonal elements

Continue

Process each row, accessing both diagonals simultaneously

Handle Center

If n is odd, subtract center element once to avoid double counting

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>

int diagonalSum(int** mat, int n) {
    int total = 0;
    
    for (int i = 0; i < n; i++) {
        // Add primary diagonal element
        total += mat[i][i];
        // Add secondary diagonal element
        total += mat[i][n - 1 - i];
    }
    
    // If matrix has odd size, subtract center element once
    // (it was counted twice)
    if (n % 2 == 1) {
        int center = n / 2;
        total -= mat[center][center];
    }
    
    return total;
}

int main() {
    printf("Optimal diagonal sum\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

We only iterate through n rows, accessing exactly 2 elements per row (or 1 for center)

✓ Linear Growth

Space Complexity

O(1)

Only using a constant amount of extra space for variables

✓ Linear Space

45.2K Views

Medium Frequency

~8 min Avg. Time

1.9K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Single Pass Diagonal Traversal (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler