What happens if you double counting the center element in odd-sized matrices?

Output sum is larger than expected Fix: Subtract the center element once after summing both diagonals

What happens if you using nested loops unnecessarily?

Slower code and more complex logic Fix: Use a single loop leveraging diagonal index properties

What happens if you incorrect index calculation for secondary diagonal?

Wrong elements summed, incorrect result Fix: Use i + j == n - 1 or j = n - 1 - i for secondary diagonal

What happens if you not handling 1x1 matrix edge case?

May cause errors or incorrect subtraction Fix: Check matrix size and handle center subtraction only if n > 1

Interview PrepmatriceseasyAmazonGoogle

Matrix Diagonal Sum

Choose your preparation mode4 modes available

Try It Solution Trace

🎯

Matrix Diagonal Sum

easyMATRIXAmazonGoogle

Imagine you have a square photo grid and want to quickly find the sum of pixels along both diagonals to analyze brightness patterns.

💡 This problem is about traversing a square matrix to sum elements on its two diagonals. Beginners often struggle with avoiding double counting the center element when the matrix size is odd.

📋

Problem Statement

Given a square matrix mat of size n x n, return the sum of the matrix diagonals. Only include the sum of all the elements on the primary diagonal and all the elements on the secondary diagonal that are not part of the primary diagonal.

1 ≤ n ≤ 10^3mat.length == nmat[i].length == n1 ≤ mat[i][j] ≤ 100

💡

Example

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

Output25

Primary diagonal sum = 1 + 5 + 9 = 15; Secondary diagonal sum = 3 + 5 + 7 = 15; Center element 5 counted twice, so subtract once: 15 + 15 - 5 = 25.

1x1 matrix → sum is the single element
2x2 matrix → no center overlap, sum all four diagonal elements
Odd-sized matrix → center element counted twice, must subtract once
Large matrix with max values → ensure no integer overflow

⚠️

Common Mistakes

Double counting the center element in odd-sized matrices

Output sum is larger than expected

✅ Subtract the center element once after summing both diagonals

Using nested loops unnecessarily

Slower code and more complex logic

✅ Use a single loop leveraging diagonal index properties

Incorrect index calculation for secondary diagonal

Wrong elements summed, incorrect result

✅ Use i + j == n - 1 or j = n - 1 - i for secondary diagonal

Not handling 1x1 matrix edge case

May cause errors or incorrect subtraction

✅ Check matrix size and handle center subtraction only if n > 1

🧠

Brute Force (Nested Loops)

💡 This approach uses straightforward nested loops to check every element and add it if it lies on either diagonal. It helps beginners understand matrix indexing and diagonal conditions.

Intuition

Traverse every element in the matrix and check if it belongs to the primary or secondary diagonal. Sum those elements, taking care to avoid double counting the center element.

Algorithm

Initialize sum to 0.
Iterate over each row i from 0 to n-1.
Within each row, iterate over each column j from 0 to n-1.
If i == j (primary diagonal) or i + j == n - 1 (secondary diagonal), add mat[i][j] to sum.
If n is odd, subtract the center element once to avoid double counting.
Return the final sum.

💡 The nested loops make it easy to understand which elements belong to diagonals but are inefficient for large matrices.

</>

Code

def diagonalSum(mat):
    n = len(mat)
    total = 0
    for i in range(n):
        for j in range(n):
            if i == j or i + j == n - 1:
                total += mat[i][j]
    if n % 2 == 1:
        total -= mat[n//2][n//2]
    return total

# Driver code
if __name__ == '__main__':
    matrix = [[1,2,3],[4,5,6],[7,8,9]]
    print(diagonalSum(matrix))  # Output: 25

Line Notes

n = len(mat)Determine the size of the square matrix to control loops.

for i in range(n)Outer loop iterates over each row index.

for j in range(n)Inner loop iterates over each column index.

if i == j or i + j == n - 1Check if current element lies on primary or secondary diagonal.

total += mat[i][j]Add diagonal element to running total.

if n % 2 == 1Check if matrix size is odd to handle center element double counting.

total -= mat[n//2][n//2]Subtract center element once to avoid counting it twice.

return totalReturn the computed sum of diagonals.

public class Solution {
    public static int diagonalSum(int[][] mat) {
        int n = mat.length;
        int total = 0;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                if (i == j || i + j == n - 1) {
                    total += mat[i][j];
                }
            }
        }
        if (n % 2 == 1) {
            total -= mat[n / 2][n / 2];
        }
        return total;
    }

    public static void main(String[] args) {
        int[][] matrix = {{1,2,3},{4,5,6},{7,8,9}};
        System.out.println(diagonalSum(matrix)); // Output: 25
    }
}

Line Notes

int n = mat.length;Get matrix dimension for loop bounds.

for (int i = 0; i < n; i++)Loop over rows.

for (int j = 0; j < n; j++)Loop over columns.

if (i == j || i + j == n - 1)Identify diagonal elements by indices.

total += mat[i][j];Accumulate diagonal element values.

if (n % 2 == 1)Check for odd dimension to handle center overlap.

total -= mat[n / 2][n / 2];Remove double counted center element.

return total;Return final diagonal sum.

#include <iostream>
#include <vector>
using namespace std;

int diagonalSum(vector<vector<int>>& mat) {
    int n = mat.size();
    int total = 0;
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            if (i == j || i + j == n - 1) {
                total += mat[i][j];
            }
        }
    }
    if (n % 2 == 1) {
        total -= mat[n/2][n/2];
    }
    return total;
}

int main() {
    vector<vector<int>> matrix = {{1,2,3},{4,5,6},{7,8,9}};
    cout << diagonalSum(matrix) << endl; // Output: 25
    return 0;
}

Line Notes

int n = mat.size();Determine matrix size for iteration limits.

for (int i = 0; i < n; i++)Iterate over rows.

for (int j = 0; j < n; j++)Iterate over columns.

if (i == j || i + j == n - 1)Check if element is on either diagonal.

total += mat[i][j];Add diagonal element to total sum.

if (n % 2 == 1)Detect odd dimension to adjust for center element.

total -= mat[n/2][n/2];Subtract center element once to avoid double counting.

return total;Return the computed diagonal sum.

function diagonalSum(mat) {
    const n = mat.length;
    let total = 0;
    for (let i = 0; i < n; i++) {
        for (let j = 0; j < n; j++) {
            if (i === j || i + j === n - 1) {
                total += mat[i][j];
            }
        }
    }
    if (n % 2 === 1) {
        total -= mat[Math.floor(n/2)][Math.floor(n/2)];
    }
    return total;
}

// Test
const matrix = [[1,2,3],[4,5,6],[7,8,9]];
console.log(diagonalSum(matrix)); // Output: 25

Line Notes

const n = mat.length;Get matrix size for loops.

for (let i = 0; i < n; i++)Loop over rows.

for (let j = 0; j < n; j++)Loop over columns.

if (i === j || i + j === n - 1)Check if element is on primary or secondary diagonal.

total += mat[i][j];Add diagonal element to total sum.

if (n % 2 === 1)Check for odd dimension to handle center overlap.

total -= mat[Math.floor(n/2)][Math.floor(n/2)];Subtract center element once to avoid double counting.

return total;Return the final sum.

⏱

Complexity

TimeO(n^2)

SpaceO(1)

We visit every element in the n x n matrix once, so time is O(n^2). We use only a few variables, so space is O(1).

💡 For n=10, this means 100 operations, which is manageable but inefficient for very large matrices.

Interview Verdict: Accepted

This approach works correctly but is not optimal for large matrices due to unnecessary checks.

Approach	Time	Space	Stack Risk	Reconstruct	Use In Interview
1. Brute Force (Nested Loops)	`O(n^2)`	`O(1)`	No	N/A	Mention only - never code
2. Better Approach (Single Loop with Direct Indexing)	`O(n)`	`O(1)`	No	N/A	Code this approach
3. Optimal Approach (In-Place Summation Without Extra Variables)	`O(n)`	`O(1)`	No	N/A	Code this approach for minimalism

Practice

(1/5)

1. The following code attempts to count negative numbers in a sorted matrix using the staircase search approach. Identify the line containing the subtle bug that can cause incorrect results or infinite loops.

def countNegatives(grid):
    m, n = len(grid), len(grid[0])
    count = 0
    row, col = 0, n - 1
    while row < m and col >= 0:
        if grid[row][col] < 0:
            count += m - row
            row += 1  # Bug here
        else:
            col -= 1
    return count

medium

A. Line where row is incremented after finding a negative

B. Line where row and col are initialized

C. Line where col is decremented after finding a non-negative

D. Line where count is incremented by m - row

Recommended

Ready to prove it?

Pass the test and this pattern moves unknown strong while earning +1 Grip toward your certificate.

10 questions~5 mineasy hard

Intuition

Algorithm

Intuition

Algorithm

Intuition

Algorithm

How to Present

Time Allocation

What the Interviewer Tests

Common Follow-ups

When to Use

Signature Phrases

NOT This Pattern When

Similar Problems

Practice

Solution

Step 1: Understand staircase logic

Step 2: Identify incorrect movement

Final Answer:

Quick Check:

Solution

Step 1: Examine neighbor counting loop

Step 2: Confirm other parts are correct

Final Answer:

Quick Check:

Solution

Step 1: Identify space usage

Step 2: Understand common misconceptions

Final Answer:

Quick Check:

Solution

Step 1: Understand duplicates impact

Step 2: Modify single pass check

Step 3: Avoid unnecessary data structures

Final Answer:

Quick Check:

Solution

Step 1: Understand matrix shape constraints

Step 2: Evaluate options

Final Answer:

Quick Check:

Ready to prove it?