Matrix Diagonal Sum - Practice Coding Problems

Matrix Diagonal Sum - Problem

Array Matrix Easy

Given a square matrix mat, 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.

The primary diagonal consists of elements where row index = column index. The secondary diagonal consists of elements where row index + column index = n - 1, where n is the matrix size.

Input & Output

Example 1 — 3×3 Matrix

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

› Output: 25

💡 Note: Primary diagonal: mat[0][0] + mat[1][1] + mat[2][2] = 1 + 5 + 9 = 15. Secondary diagonal: mat[0][2] + mat[2][0] = 3 + 7 = 10. The center element 5 is shared, so total = 15 + 10 = 25.

Example 2 — 2×2 Matrix

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

› Output: 4

💡 Note: Primary diagonal: mat[0][0] + mat[1][1] = 1 + 1 = 2. Secondary diagonal: mat[0][1] + mat[1][0] = 1 + 1 = 2. No overlap in even-sized matrix, so total = 2 + 2 = 4.

Example 3 — 1×1 Matrix

$ Input: mat = [[5]]

› Output: 5

💡 Note: Only one element which is both primary and secondary diagonal. Count it once: 5.

Constraints

n == mat.length == mat[i].length
1 ≤ n ≤ 100
1 ≤ mat[i][j] ≤ 100

Visualization

Tap to expand

Understanding the Visualization

Input Matrix

3×3 square matrix with primary and secondary diagonals highlighted

Sum Diagonals

Add elements from both diagonals, handling center overlap

Final Sum

Return total sum avoiding double-count

Key Takeaway

🎯 Key Insight: The main trick is to access diagonal elements directly in O(n) time while properly handling the center element overlap in odd-sized matrices

Asked in

G Google 15 a Amazon 12 M Microsoft 8 Apple 6

The key insight is that we only need to traverse the diagonal elements directly instead of checking every cell. The optimal approach uses a single pass through n elements, adding primary diagonal mat[i][i] and secondary diagonal mat[i][n-1-i] while avoiding double-counting the center. Time: O(n), Space: O(1)

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force - Check Every Cell	O(n²)	O(1)	Iterate through all matrix cells and check if each belongs to either diagonal
Single Pass Diagonal Traversal	O(n)	O(1)	Traverse only the diagonal elements directly in one pass

Brute Force - Check Every Cell — Algorithm Steps

Step 1: Initialize sum to 0
Step 2: For each cell (i,j), check if i==j or i+j==n-1
Step 3: Add cell value to sum if it's on either diagonal

Visualization

Tap to expand

Step-by-Step Walkthrough

Scan Matrix

Visit every cell (i,j) in the matrix

Check Diagonals

Test if i==j (primary) or i+j==n-1 (secondary)

Sum Elements

Add qualifying diagonal elements to total

Code -

solution.c — C

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

int solution(int** mat, int n) {
    int diagonalSum = 0;
    
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            // Check if cell is on primary diagonal (i == j)
            if (i == j) {
                diagonalSum += mat[i][j];
            }
            // Check if cell is on secondary diagonal (i + j == n - 1)
            else if (i + j == n - 1) {
                diagonalSum += mat[i][j];
            }
        }
    }
    
    return diagonalSum;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    // Simple parsing for small matrices
    int n = 3; // Assuming 3x3 for simplicity
    int** mat = (int**)malloc(n * sizeof(int*));
    for (int i = 0; i < n; i++) {
        mat[i] = (int*)malloc(n * sizeof(int));
    }
    
    // Parse [[1,2,3],[4,5,6],[7,8,9]] format
    char* ptr = strchr(line, '[');
    ptr++; // Skip first [
    
    for (int i = 0; i < n; i++) {
        ptr = strchr(ptr, '[');
        ptr++; // Skip [
        for (int j = 0; j < n; j++) {
            mat[i][j] = atoi(ptr);
            ptr = strchr(ptr, ',');
            if (ptr) ptr++;
            else break;
        }
        ptr = strchr(ptr, ']');
        if (ptr) ptr++;
    }
    
    int result = solution(mat, n);
    printf("%d\n", result);
    
    for (int i = 0; i < n; i++) {
        free(mat[i]);
    }
    free(mat);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Nested loops iterate through all n×n cells in the matrix

⚠ Quadratic Growth

Space Complexity

O(1)

Only uses a single variable to store the sum

✓ Linear Space

24.1K Views

Medium Frequency

~8 min Avg. Time

892 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

Brute Force - Check Every Cell — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler