Number of Black Blocks - Practice Coding Problems

Number of Black Blocks - Problem

Grid Color Block Counter

Imagine you're analyzing a digital art canvas represented as an m × n grid where certain cells are painted black while others remain white. Your task is to count how many 2×2 blocks contain exactly 0, 1, 2, 3, or 4 black cells.

Given:
• Grid dimensions: m rows and n columns
• Array of coordinates where each [x, y] represents a black cell
• All other cells are white by default

Goal: Return an array of size 5 where result[i] represents the count of 2×2 blocks containing exactly i black cells.

Example: In a 3×3 grid with black cells at [[0,0], [1,1]], you need to examine all possible 2×2 blocks and count how many contain 0, 1, 2, 3, or 4 black cells respectively.

Input & Output

example_1.py — Basic Grid

$ Input: m = 3, n = 3, coordinates = [[0,0], [1,1]]

› Output: [3, 1, 1, 0, 0]

💡 Note: In a 3×3 grid, there are 4 possible 2×2 blocks. Block (0,0) contains 1 black cell at [0,0]. Block (0,1) contains 1 black cell at [1,1]. Block (1,0) contains 1 black cell at [1,1]. Block (1,1) contains 0 black cells. So we have 3 blocks with 0 black cells, 1 block with 1 black cell, 1 block with 1 black cell.

example_2.py — Dense Pattern

$ Input: m = 3, n = 3, coordinates = [[0,0], [1,1], [0,1], [1,0]]

› Output: [0, 0, 0, 1, 0]

💡 Note: All 4 black cells form a 2×2 square. The only 2×2 block starting at (0,0) contains all 4 black cells, while blocks (0,1), (1,0), and (1,1) each contain some subset. Actually, let me recalculate: Block (0,0) has 4 blacks, so result[4] = 1, and the other 3 blocks have fewer.

example_3.py — Minimal Case

$ Input: m = 2, n = 2, coordinates = [[0,1]]

› Output: [0, 1, 0, 0, 0]

💡 Note: Only one 2×2 block is possible in a 2×2 grid. It contains exactly 1 black cell at position [0,1], so result[1] = 1.

Visualization

Tap to expand

Understanding the Visualization

Place Black Cells

Mark black cells on the grid

Identify Block Contributions

Each black cell affects up to 4 different 2×2 blocks

Count Block Types

Categorize blocks by their black cell counts

Generate Final Result

Return array with counts for 0-4 black cells per block

Key Takeaway

🎯 Key Insight: Instead of examining every block, track how black cells contribute to blocks - each black cell affects at most 4 blocks, making the solution scale with input size rather than grid size.

Time & Space Complexity

Time Complexity

⏱️

O(k)

Where k is the number of black cells. Each black cell contributes to at most 4 blocks

✓ Linear Growth

Space Complexity

O(min(k, m×n))

Hash map stores at most min(4k, (m-1)×(n-1)) block contributions

⚡ Linearithmic Space

Constraints

2 ≤ m, n ≤ 10⁵
0 ≤ coordinates.length ≤ 10⁴
coordinates[i].length == 2
0 ≤ coordinates[i][0] < m
0 ≤ coordinates[i][1] < n
All coordinates in coordinates are distinct

Asked in

G Google 23 f Meta 18 a Amazon 15 ⊞ Microsoft 12

The optimal approach uses smart contribution counting where each black cell contributes to at most 4 different 2×2 blocks. Instead of checking every possible block (O(m×n)), we only process the black cells and track their block contributions (O(k) where k is number of black cells), making it highly efficient for sparse grids.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check Every Block)	O(m × n)	O(k)	Examine every possible 2×2 block and count black cells in each
Smart Block Contribution (Optimal)	O(k)	O(min(k, m×n))	Each black cell contributes to at most 4 blocks - count contributions efficiently

Brute Force (Check Every Block) — Algorithm Steps

Convert coordinates array to a set for O(1) lookup
Initialize result array [0, 0, 0, 0, 0] to count blocks with 0-4 black cells
Iterate through all valid top-left corners (0 to m-2, 0 to n-2)
For each 2×2 block, count black cells in its 4 positions
Increment the corresponding counter in result array

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Grid

Create grid and mark black cells

Check Each Block

Examine every possible 2×2 block

Count Black Cells

Count black cells in current block

Update Result

Increment counter for this block type

Code -

solution.c — C

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

int* countBlackBlocks(int m, int n, int** coordinates, int coordinatesSize, int* returnSize) {
    *returnSize = 5;
    int* result = calloc(5, sizeof(int));
    
    // Simple approach: check each block
    for (int i = 0; i < m - 1; i++) {
        for (int j = 0; j < n - 1; j++) {
            int blackCount = 0;
            
            // Count black cells in 2x2 block
            for (int k = 0; k < coordinatesSize; k++) {
                int x = coordinates[k][0];
                int y = coordinates[k][1];
                if (x >= i && x <= i + 1 && y >= j && y <= j + 1) {
                    blackCount++;
                }
            }
            result[blackCount]++;
        }
    }
    
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(m × n)

We check every possible 2×2 block in the grid, which is (m-1) × (n-1) blocks

✓ Linear Growth

Space Complexity

O(k)

Space for storing k black cell coordinates in a set

✓ Linear Space

Constraints

2 ≤ m, n ≤ 10⁵
0 ≤ coordinates.length ≤ 10⁴
coordinates[i].length == 2
0 ≤ coordinates[i][0] < m
0 ≤ coordinates[i][1] < n
All coordinates in coordinates are distinct

23.4K Views

Medium Frequency

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Check Every Block) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler