Falling Squares - Practice Coding Problems

Falling Squares - Problem

Imagine you're building a digital Tetris-like simulation where squares are dropped one by one onto a 2D plane! 🎮

You're given a series of squares that fall from above and land on the X-axis or on top of other squares. Each square is defined by its left edge position and side length. The squares fall straight down until they hit either the ground (X-axis) or another square below them.

Key Rules:

Squares fall one at a time in the order given
A square stops falling when it hits the X-axis or lands on top of another square
Squares only "land on" other squares if they overlap vertically - brushing sides doesn't count
Once landed, squares freeze in place forever

Your Mission: After each square lands, report the maximum height of all stacked squares. Return an array where result[i] is the tallest stack height after dropping the i-th square.

Input: positions[i] = [leftEdge, sideLength] - the left coordinate and size of each square

Output: Array of maximum heights after each drop

Input & Output

example_1.py — Basic Square Dropping

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

› Output: [2, 5, 5]

💡 Note: First square [1,2] lands on ground: height = 2. Second square [4,3] lands on ground (no overlap): height = 3, max = 5. Third square [2,2] overlaps with first square, lands on top: height = 2+2 = 4, max stays 5.

example_2.py — Single Square

$ Input: positions = [[100,100]]

› Output: [100]

💡 Note: Only one square drops and lands on the X-axis at height 100. The maximum height is 100.

example_3.py — Overlapping Stack

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

› Output: [2, 3, 3]

💡 Note: First square [0,2] creates height 2. Second square [1,1] overlaps and stacks: height 2+1=3. Third square [0,1] also overlaps first square, creating another stack of height 2+1=3. Max remains 3.

Visualization

Tap to expand

Understanding the Visualization

Drop the square

Each square falls vertically until it hits something

Check for collisions

Find all existing squares that overlap horizontally

Find landing height

Land on the highest overlapping square (or ground if none)

Update maximum

Track the tallest tower height after each drop

Key Takeaway

🎯 Key Insight: Use coordinate compression to handle large coordinate ranges efficiently, then segment trees for fast range queries - reducing time from O(n²) to O(n log n)

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n squares, we check overlap with all previously dropped squares

⚠ Quadratic Growth

Space Complexity

O(n)

Store information for all n dropped squares

⚡ Linearithmic Space

Constraints

1 ≤ positions.length ≤ 1000
1 ≤ left_i ≤ 10⁸
1 ≤ sideLength_i ≤ 10⁶
All squares have positive side lengths
Coordinates can be very large, requiring coordinate compression

Asked in

G Google 35 f Facebook 28 ⊞ Microsoft 22 a Amazon 18

The optimal approach uses coordinate compression to map large coordinates to a manageable range, then applies a segment tree for efficient range maximum queries and updates. This achieves O(n log n) time complexity compared to the brute force O(n²) approach.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check All Previous Squares)	O(n²)	O(n)	For each new square, check collision with all previously dropped squares
Coordinate Compression + Segment Tree	O(n log n)	O(n)	Use coordinate compression to map coordinates to smaller range, then segment tree for range queries

Brute Force (Check All Previous Squares) — Algorithm Steps

Store all dropped squares with their coordinates and heights
For each new square, check overlap with all existing squares
Find the maximum height among overlapping squares
Place new square at that height + its side length
Update the global maximum height

Visualization

Tap to expand

Step-by-Step Walkthrough

Drop first square

First square lands on ground at height = side length

Check overlaps

New square checks overlap with all existing squares

Find landing height

Lands on the highest overlapping square

Update maximum

Track the tallest stack height

Code -

solution.c — C

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

int max(int a, int b) {
    return a > b ? a : b;
}

int* fallingSquares(int** positions, int positionsSize, int* positionsColSize, int* returnSize) {
    int squares[positionsSize][3]; // {left, right, height}
    int* result = (int*)malloc(positionsSize * sizeof(int));
    int squareCount = 0;
    int maxHeight = 0;
    
    for (int i = 0; i < positionsSize; i++) {
        int left = positions[i][0];
        int side = positions[i][1];
        int right = left + side;
        int currentHeight = 0;
        
        // Check collision with all existing squares
        for (int j = 0; j < squareCount; j++) {
            int sqLeft = squares[j][0];
            int sqRight = squares[j][1];
            int sqHeight = squares[j][2];
            
            // Check if ranges overlap
            if (left < sqRight && right > sqLeft) {
                currentHeight = max(currentHeight, sqHeight);
            }
        }
        
        // Place new square
        int newHeight = currentHeight + side;
        squares[squareCount][0] = left;
        squares[squareCount][1] = right;
        squares[squareCount][2] = newHeight;
        squareCount++;
        
        // Update global maximum
        maxHeight = max(maxHeight, newHeight);
        result[i] = maxHeight;
    }
    
    *returnSize = positionsSize;
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n squares, we check overlap with all previously dropped squares

⚠ Quadratic Growth

Space Complexity

O(n)

Store information for all n dropped squares

⚡ Linearithmic Space

Constraints

1 ≤ positions.length ≤ 1000
1 ≤ left_i ≤ 10⁸
1 ≤ sideLength_i ≤ 10⁶
All squares have positive side lengths
Coordinates can be very large, requiring coordinate compression

28.4K Views

Medium Frequency

~25 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 All Previous Squares) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler