Check if Matrix Is X-Matrix - Practice Coding Problems

Check if Matrix Is X-Matrix - Problem

Array Matrix Easy

🎯 Check if Matrix Forms an X Pattern

Imagine you're looking at a square grid from above - can you spot an X pattern? An X-Matrix is a special type of square matrix that follows two simple rules:

📍 All elements on both diagonals (main diagonal and anti-diagonal) must be non-zero
🚫 All other elements must be exactly zero

Given a 2D integer array grid of size n x n, your task is to determine whether it forms a valid X-Matrix. Return true if it does, false otherwise.

Example: In a 3x3 matrix, positions (0,0), (0,2), (1,1), (2,0), and (2,2) should be non-zero, while positions (0,1), (1,0), (1,2), and (2,1) must be zero.

Input & Output

example_1.py — Valid X-Matrix

$ Input: grid = [[2,0,0,1],[0,3,1,0],[0,5,2,0],[4,0,0,2]]

› Output: true

💡 Note: This is a valid X-Matrix because all diagonal elements (2,1,3,2,5,4,2) are non-zero and all non-diagonal elements are zero.

example_2.py — Invalid X-Matrix

$ Input: grid = [[5,7,0],[0,3,1],[0,5,0]]

› Output: false

💡 Note: This is not an X-Matrix because grid[0][1] = 7 and grid[1][2] = 1 are non-diagonal elements that should be zero.

example_3.py — Single Element Matrix

$ Input: grid = [[5]]

› Output: true

💡 Note: A 1×1 matrix is always an X-Matrix if the single element (which is on both diagonals) is non-zero.

Constraints

n == grid.length == grid[i].length
3 ≤ n ≤ 100
-10⁵ ≤ grid[i][j] ≤ 10⁵
The matrix is guaranteed to be square

Visualization

Tap to expand

Understanding the Visualization

Identify Diagonal Positions

Locate all positions that form the X pattern (main diagonal i==j and anti-diagonal i+j==n-1)

Validate Diagonal Elements

Ensure all diagonal positions contain non-zero values

Validate Non-Diagonal Elements

Ensure all other positions contain exactly zero

Final Verdict

Return true if all conditions met, false otherwise

Key Takeaway

🎯 Key Insight: An X-Matrix has a simple pattern - diagonal positions (i==j or i+j==n-1) must be non-zero, all others must be zero. This can be validated in a single O(n²) pass through the matrix.

Asked in

a Amazon 15 ⊞ Microsoft 12 G Google 8 f Meta 6

The optimal approach is a single-pass matrix traversal that checks each element against the X-Matrix rules. For each position (i,j), we determine if it's on a diagonal using the conditions i == j or i + j == n - 1, then verify the element is non-zero (diagonal) or zero (non-diagonal). Time complexity: O(n²), Space complexity: O(1).

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force Matrix Traversal	O(n²)	O(1)	Check every matrix element to verify X-pattern rules

Brute Force Matrix Traversal — Algorithm Steps

Traverse each element (i, j) in the n×n matrix
Check if position (i, j) is on main diagonal (i == j) or anti-diagonal (i + j == n - 1)
If on diagonal: verify element is non-zero, return false if zero
If not on diagonal: verify element is zero, return false if non-zero
Return true if all elements pass their respective checks

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Check

Start with the first element at position (0,0)

Diagonal Detection

Determine if current position is on main or anti-diagonal

Value Validation

Check if element value matches X-Matrix rule for this position

Continue or Return

Move to next element or return false if rule violated

Code -

solution.c — C

#include <stdio.h>
#include <stdbool.h>

bool checkXMatrix(int** grid, int n) {
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            // Check if position is on diagonal
            bool isDiagonal = (i == j) || (i + j == n - 1);
            
            if (isDiagonal) {
                // Diagonal elements must be non-zero
                if (grid[i][j] == 0) {
                    return false;
                }
            } else {
                // Non-diagonal elements must be zero
                if (grid[i][j] != 0) {
                    return false;
                }
            }
        }
    }
    
    return true;
}

int main() {
    int n;
    scanf("%d", &n);
    
    int** grid = (int**)malloc(n * sizeof(int*));
    for (int i = 0; i < n; i++) {
        grid[i] = (int*)malloc(n * sizeof(int));
        for (int j = 0; j < n; j++) {
            scanf("%d", &grid[i][j]);
        }
    }
    
    printf("%s\n", checkXMatrix(grid, n) ? "true" : "false");
    
    // Free memory
    for (int i = 0; i < n; i++) {
        free(grid[i]);
    }
    free(grid);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

We visit each element in the n×n matrix exactly once

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a constant amount of extra space for variables

✓ Linear Space

28.4K Views

Medium Frequency

~8 min Avg. Time

842 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

🎯 Check if Matrix Forms an X Pattern

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force Matrix Traversal — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler