Check if Grid Satisfies Conditions - Practice Coding Problems

Check if Grid Satisfies Conditions - Problem

Array Matrix Easy

You are given a 2D matrix grid of size m × n. Your task is to validate whether this grid follows a specific pattern:

Vertical Consistency: Each cell must be equal to the cell directly below it (if it exists)
Horizontal Diversity: Each cell must be different from the cell to its right (if it exists)

In other words, values should be consistent within columns but vary across rows. Think of it like a striped pattern where each column has the same color throughout, but adjacent columns have different colors.

Goal: Return true if all cells satisfy both conditions, otherwise return false.

Input & Output

example_1.py — Valid Grid

$ Input: grid = [[1,0,2],[1,0,2]]

› Output: true

💡 Note: Each column has consistent values (1,1), (0,0), (2,2) and adjacent columns have different values (1≠0, 0≠2)

example_2.py — Invalid Horizontal

$ Input: grid = [[1,1,1],[0,0,0]]

› Output: false

💡 Note: Adjacent cells in the same row have the same values, violating the horizontal diversity rule

example_3.py — Invalid Vertical

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

› Output: false

💡 Note: The single column has different values (1≠2), violating the vertical consistency rule

Constraints

1 ≤ m, n ≤ 10
1 ≤ grid[i][j] ≤ 1000
grid[i][j] contains only positive integers

Visualization

Tap to expand

Understanding the Visualization

Check Vertical

Ensure each column has consistent values from top to bottom

Check Horizontal

Ensure adjacent columns have different values

Early Exit

Return false immediately when any violation is found

Key Takeaway

🎯 Key Insight: We only need one pass since we're checking local relationships between adjacent cells, making this an optimal O(m×n) solution.

Asked in

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

The optimal approach uses a single pass through the matrix, checking both conditions for each cell in O(m×n) time. We validate vertical consistency (same values in columns) and horizontal diversity (different values in adjacent columns) simultaneously.

Common Approaches

Approach	Time	Space	Notes
✓ Single Pass Matrix Traversal	O(m×n)	O(1)	Check every cell against its right and bottom neighbors in one pass

Single Pass Matrix Traversal — Algorithm Steps

Iterate through each row and column of the matrix
For each cell, check if it equals the cell below (if exists)
For each cell, check if it differs from the cell to the right (if exists)
Return false immediately if any condition is violated
Return true if all cells pass both checks

Visualization

Tap to expand

Step-by-Step Walkthrough

Start at top-left

Begin checking from grid[0][0]

Check vertical consistency

Compare current cell with cell below

Check horizontal diversity

Compare current cell with cell to the right

Move to next cell

Continue row by row, left to right

Code -

solution.c — C

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

bool satisfiesConditions(int** grid, int gridSize, int* gridColSize) {
    int m = gridSize;
    int n = gridColSize[0];
    
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            // Check vertical consistency
            if (i + 1 < m && grid[i][j] != grid[i + 1][j]) {
                return false;
            }
            
            // Check horizontal diversity
            if (j + 1 < n && grid[i][j] == grid[i][j + 1]) {
                return false;
            }
        }
    }
    
    return true;
}

int main() {
    // Parse input and call function
    printf("%s\n", satisfiesConditions(grid, gridSize, gridColSize) ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m×n)

We visit each cell exactly once and perform constant time operations

✓ Linear Growth

Space Complexity

O(1)

Only using variables for iteration, no additional data structures

✓ Linear Space

28.5K Views

Medium Frequency

~8 min Avg. Time

834 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

Single Pass Matrix Traversal — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler