Cross Sum of a Matrix - Problem

Given a 2D matrix of integers, calculate and display the following sums in a formatted way:

Main diagonal sum - Sum of elements where row index equals column index
Anti-diagonal sum - Sum of elements where row + column equals matrix size - 1
Row sums - Sum of each individual row
Column sums - Sum of each individual column

Return a formatted string showing all these calculations in a table-like structure.

Input & Output

Example 1 — Basic 3x3 Matrix

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

› Output: Main Diagonal: 15 Anti Diagonal: 15 Row Sums: [6,15,24] Column Sums: [12,15,18]

💡 Note: Main diagonal: 1+5+9=15, Anti-diagonal: 3+5+7=15, Row sums: [1+2+3=6, 4+5+6=15, 7+8+9=24], Column sums: [1+4+7=12, 2+5+8=15, 3+6+9=18]

Example 2 — 2x2 Matrix with Negatives

$ Input: matrix = [[1,-2],[-3,4]]

› Output: Main Diagonal: 5 Anti Diagonal: 2 Row Sums: [-1,1] Column Sums: [-2,2]

💡 Note: Main diagonal: 1+4=5, Anti-diagonal: -2+(-3)=-5 but we have -2+(-3)=2, Row sums: [1+(-2)=-1, -3+4=1], Column sums: [1+(-3)=-2, -2+4=2]

Example 3 — Single Element Matrix

$ Input: matrix = [[5]]

› Output: Main Diagonal: 5 Anti Diagonal: 5 Row Sums: [5] Column Sums: [5]

💡 Note: For 1x1 matrix, the single element is both main and anti-diagonal, and constitutes the only row and column sum

Constraints

1 ≤ matrix.length ≤ 100
matrix is a square matrix (n × n)
-1000 ≤ matrix[i][j] ≤ 1000

Visualization

Tap to expand

Asked in

M Microsoft 15 G Google 12

The key insight is to process each matrix element once and update all relevant sums simultaneously instead of making multiple passes. Best approach uses single pass iteration with O(n²) time and O(n) space complexity.

Common Approaches

✓ Brute Force - Multiple Passes

⏱️ Time: O(n²) Space: O(n)

Make multiple complete passes through the matrix - one pass for main diagonal, one for anti-diagonal, one for each row sum, and one for each column sum. This results in many redundant iterations through the same elements.

Single Pass Solution

⏱️ Time: O(n²) Space: O(n)

Iterate through the matrix just once, and for each element, update all relevant sums simultaneously - row sums, column sums, and diagonal sums when applicable.

Brute Force - Multiple Passes — Algorithm Steps

Step 1: Loop through matrix to calculate main diagonal sum
Step 2: Loop through matrix to calculate anti-diagonal sum
Step 3: For each row, loop through all columns to get row sums
Step 4: For each column, loop through all rows to get column sums
Step 5: Format results into table string

Visualization

Tap to expand

Step-by-Step Walkthrough

Main Diagonal

Loop through matrix diagonal elements

Anti Diagonal

Loop through anti-diagonal elements

Row & Column Sums

Separate nested loops for each

Code -

solution.c — C

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

char* solution(int** matrix, int n) {
    // Calculate main diagonal sum
    int mainDiag = 0;
    for (int i = 0; i < n; i++) {
        mainDiag += matrix[i][i];
    }
    
    // Calculate anti-diagonal sum
    int antiDiag = 0;
    for (int i = 0; i < n; i++) {
        antiDiag += matrix[i][n-1-i];
    }
    
    // Calculate row sums
    int* rowSums = (int*)malloc(n * sizeof(int));
    for (int i = 0; i < n; i++) {
        int rowSum = 0;
        for (int j = 0; j < n; j++) {
            rowSum += matrix[i][j];
        }
        rowSums[i] = rowSum;
    }
    
    // Calculate column sums
    int* colSums = (int*)malloc(n * sizeof(int));
    for (int j = 0; j < n; j++) {
        int colSum = 0;
        for (int i = 0; i < n; i++) {
            colSum += matrix[i][j];
        }
        colSums[j] = colSum;
    }
    
    // Format result
    char* result = (char*)malloc(1000);
    char temp[100];
    
    sprintf(result, "Main Diagonal: %d\n", mainDiag);
    sprintf(temp, "Anti Diagonal: %d\n", antiDiag);
    strcat(result, temp);
    
    strcat(result, "Row Sums: [");
    for (int i = 0; i < n; i++) {
        sprintf(temp, "%d", rowSums[i]);
        strcat(result, temp);
        if (i < n-1) strcat(result, ",");
    }
    strcat(result, "]\n");
    
    strcat(result, "Column Sums: [");
    for (int i = 0; i < n; i++) {
        sprintf(temp, "%d", colSums[i]);
        strcat(result, temp);
        if (i < n-1) strcat(result, ",");
    }
    strcat(result, "]");
    
    free(rowSums);
    free(colSums);
    return result;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Multiple nested loops, each O(n²), but still dominated by O(n²)

⚠ Quadratic Growth

Space Complexity

O(n)

Arrays to store row and column sums

⚡ Linearithmic Space

24.5K Views

Medium Frequency

~15 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

Cross Sum of a Matrix - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Multiple Passes — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler