Brick Wall - Practice Coding Problems

Brick Wall - Problem

Brick Wall Challenge: You're standing in front of a rectangular brick wall with n rows of bricks. Each row contains bricks of the same height (1 unit) but different widths. All rows have the same total width.

Your goal is to draw a vertical line from top to bottom that crosses the minimum number of bricks. Here's the catch: if your line passes through the edge between two bricks, those bricks are not counted as crossed.

Constraints: You cannot draw the line along the leftmost or rightmost edges of the wall.

Input: A 2D array wall where wall[i] contains the widths of bricks in row i
Output: The minimum number of bricks crossed by the optimal vertical line

Input & Output

example_1.py — Basic Wall

$ Input: wall = [[1,2,2,1],[3,1,2],[1,3,2],[2,4],[3,1,2],[1,3,1,1]]

› Output: 2

💡 Note: The optimal vertical line can be drawn at position 4, which only crosses 2 bricks. Most edges align at position 4, so drawing the line there minimizes brick crossings.

example_2.py — Single Row

$ Input: wall = [[1,1,1]]

› Output: 1

💡 Note: With only one row of bricks, any vertical line (except at the boundaries) will cross exactly 1 brick. There are only 2 possible positions, and both cross 1 brick.

example_3.py — Aligned Edges

$ Input: wall = [[1,2,3],[1,2,3],[1,2,3]]

› Output: 0

💡 Note: All three rows have identical brick patterns, so edges align perfectly at positions 1 and 3. Drawing a line at either position crosses 0 bricks.

Visualization

Tap to expand

Understanding the Visualization

Identify All Edges

Map out where brick boundaries occur in each row

Count Alignments

Track how many rows share the same edge positions

Choose Optimal Cut

Cut through the edge that appears in the most rows

Key Takeaway

🎯 Key Insight: The minimum crossings occur where the most brick edges align vertically

Time & Space Complexity

Time Complexity

⏱️

O(n × m)

n rows × average m bricks per row, visiting each brick once

✓ Linear Growth

Space Complexity

O(w)

Hash map storing at most w edge positions where w is wall width

✓ Linear Space

Constraints

1 ≤ wall.length ≤ 10⁴
1 ≤ wall[i].length ≤ 10⁴
1 ≤ sum(wall[i].length) ≤ 2 × 10⁴
1 ≤ wall[i][j] ≤ 10⁴
All rows have the same total width

Asked in

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

The optimal solution uses a hash map to count edge positions across all rows. Instead of trying every possible cut position, we realize that the best cut goes through the most frequent edge alignment. The answer is simply total_rows - max_edge_frequency, achieving O(n×m) time complexity in a single pass.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try Every Position)	O(n × w)	O(1)	Check every possible vertical position and count crossed bricks
One-Pass Hash Map (Optimal)	O(n × m)	O(w)	Count edge positions in one pass to find the most frequent edge

Brute Force (Try Every Position) — Algorithm Steps

Calculate the total width of the wall
For each possible vertical position (1 to width-1)
Count how many bricks are crossed at this position
A brick is crossed if the line passes through its interior
Return the minimum count found

Visualization

Tap to expand

Step-by-Step Walkthrough

Try Position 1

Count bricks crossed at x=1

Try Position 2

Count bricks crossed at x=2

Find Minimum

Return position with least crossings

Code -

solution.c — C

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

int leastBricks(int** wall, int wallSize, int* wallColSize) {
    if (wallSize == 0 || wallColSize[0] == 0) return 0;
    
    int totalWidth = 0;
    for (int i = 0; i < wallColSize[0]; i++) {
        totalWidth += wall[0][i];
    }
    
    int minCrossed = wallSize;
    
    for (int pos = 1; pos < totalWidth; pos++) {
        int crossed = 0;
        
        for (int i = 0; i < wallSize; i++) {
            int currentPos = 0;
            int brickCrossed = 0;
            
            for (int j = 0; j < wallColSize[i]; j++) {
                if (currentPos < pos && pos < currentPos + wall[i][j]) {
                    brickCrossed = 1;
                    break;
                }
                currentPos += wall[i][j];
                if (currentPos >= pos) break;
            }
            
            if (brickCrossed) crossed++;
        }
        
        if (crossed < minCrossed) {
            minCrossed = crossed;
        }
    }
    
    return minCrossed;
}

int main() {
    // Parse input and call solution
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × w)

n rows × w width, checking each position across all rows

✓ Linear Growth

Space Complexity

O(1)

Only using variables to track current minimum

✓ Linear Space

Constraints

1 ≤ wall.length ≤ 10⁴
1 ≤ wall[i].length ≤ 10⁴
1 ≤ sum(wall[i].length) ≤ 2 × 10⁴
1 ≤ wall[i][j] ≤ 10⁴
All rows have the same total width

89.5K Views

Medium-High Frequency

~18 min Avg. Time

2.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 (Try Every Position) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler