Toeplitz Matrix - Practice Coding Problems

Toeplitz Matrix - Problem

Array Matrix Easy

Imagine you're looking at a Toeplitz Matrix - a special type of matrix where every diagonal from top-left to bottom-right contains identical elements! This creates a beautiful pattern where elements "cascade" down and to the right.

Given an m x n matrix, your task is to determine if it follows this special property. Return true if the matrix is Toeplitz, otherwise return false.

What makes a matrix Toeplitz?

Every diagonal from top-left to bottom-right has the same elements
For any element at position (i, j), it should equal the element at (i+1, j+1)
This pattern continues throughout the entire matrix

Example: In matrix [[1,2,3,4],[5,1,2,3],[9,5,1,2]], the diagonals are [1,1,1], [2,2,2], [3,3], [4], [5,5], [9] - all elements in each diagonal are identical!

Input & Output

example_1.py — Valid Toeplitz Matrix

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

› Output: true

💡 Note: In this matrix, every diagonal has identical elements: [1,1,1], [2,2,2], [3,3], [4], [5,5], [9]. Since all diagonals contain the same elements throughout, it's a valid Toeplitz matrix.

example_2.py — Invalid Toeplitz Matrix

$ Input: matrix = [[1,2],[2,2]]

› Output: false

💡 Note: The diagonal starting from matrix[0][0] contains [1,2]. Since 1 ≠ 2, this diagonal doesn't have identical elements, making it not a Toeplitz matrix.

example_3.py — Single Element Matrix

$ Input: matrix = [[5]]

› Output: true

💡 Note: A single element matrix is always considered a Toeplitz matrix since there's only one diagonal with one element, which trivially satisfies the condition.

Visualization

Tap to expand

Understanding the Visualization

Identify the Pattern

Visualize the matrix as a staircase with colored diagonals

Check Adjacent Steps

Compare each tile with the tile diagonally down-right

Verify Consistency

Ensure all diagonal paths maintain the same color

Key Takeaway

🎯 Key Insight: A matrix is Toeplitz if every diagonal from top-left to bottom-right contains identical elements. The optimal solution simply compares each element with its diagonal neighbor (i+1, j+1).

Time & Space Complexity

Time Complexity

⏱️

O(m × n)

We visit each element once, except the last row and column

✓ Linear Growth

Space Complexity

O(1)

We only use a constant amount of extra space

✓ Linear Space

Constraints

m == matrix.length
n == matrix[i].length
1 ≤ m, n ≤ 20
0 ≤ matrix[i][j] ≤ 99

Asked in

G Google 45 f Facebook 38 a Amazon 32 ⊞ Microsoft 28

The optimal solution uses a single pass comparison approach, checking each element against its diagonal neighbor (i+1, j+1). This elegant solution runs in O(m×n) time with O(1) space complexity, making it both efficient and easy to understand.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check All Diagonals)	O(m × n)	O(min(m,n))	Check every diagonal separately by collecting all elements and verifying they're identical
Single Pass Comparison (Optimal)	O(m × n)	O(1)	Compare each element with its diagonal neighbor (i+1, j+1) in one pass

Brute Force (Check All Diagonals) — Algorithm Steps

Identify all diagonal starting positions (first row and first column)
For each diagonal, traverse from start to end collecting elements
Check if all elements in each diagonal are identical
Return false if any diagonal has different elements, true otherwise

Visualization

Tap to expand

Step-by-Step Walkthrough

Identify Starting Positions

Mark all diagonal starting positions in first row and first column

Traverse Each Diagonal

Follow each diagonal path collecting all elements

Validate Uniformity

Check if all elements in each diagonal are identical

Code -

solution.c — C

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

bool isToeplitzMatrix(int** matrix, int matrixSize, int* matrixColSize) {
    if (matrixSize == 0 || matrixColSize[0] == 0) {
        return true;
    }
    
    int m = matrixSize;
    int n = matrixColSize[0];
    
    // Check diagonals starting from first row
    for (int col = 0; col < n; col++) {
        int firstElement = matrix[0][col];
        int i = 0, j = col;
        while (i < m && j < n) {
            if (matrix[i][j] != firstElement) {
                return false;
            }
            i++;
            j++;
        }
    }
    
    // Check diagonals starting from first column (excluding [0][0])
    for (int row = 1; row < m; row++) {
        int firstElement = matrix[row][0];
        int i = row, j = 0;
        while (i < m && j < n) {
            if (matrix[i][j] != firstElement) {
                return false;
            }
            i++;
            j++;
        }
    }
    
    return true;
}

int main() {
    // Demo with hardcoded matrix
    int row1[] = {1, 2, 3, 4};
    int row2[] = {5, 1, 2, 3};
    int row3[] = {9, 5, 1, 2};
    int* matrix[] = {row1, row2, row3};
    int matrixColSize[] = {4, 4, 4};
    
    printf("%s\n", isToeplitzMatrix(matrix, 3, matrixColSize) ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m × n)

We visit each element exactly once across all diagonals

✓ Linear Growth

Space Complexity

O(min(m,n))

We store elements of the longest diagonal, which has at most min(m,n) elements

⚡ Linearithmic Space

Constraints

m == matrix.length
n == matrix[i].length
1 ≤ m, n ≤ 20
0 ≤ matrix[i][j] ≤ 99

87.4K Views

Medium Frequency

~15 min Avg. Time

1.8K 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Check All Diagonals) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler