Where Will the Ball Fall - Practice Coding Problems

Where Will the Ball Fall - Problem

Imagine a pinball machine box with diagonal boards that redirect balls left or right! You have an m × n grid representing this box, where each cell contains a diagonal board:

Value 1: Board redirects ball to the right (top-left to bottom-right diagonal)
Value -1: Board redirects ball to the left (top-right to bottom-left diagonal)

Drop one ball from the top of each column. Each ball will either:

✅ Fall out the bottom - reaching the bottom row and exiting
❌ Get stuck - hitting a "V" shape pattern or bouncing into a wall

Goal: For each ball dropped from column i, return which column it exits from at the bottom, or -1 if it gets stuck.

Think of it as simulating gravity with bouncing balls in a maze of diagonal mirrors!

Input & Output

example_1.py — Basic Grid

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

› Output: [1,-1,-1,-1,-1]

💡 Note: Ball from column 0 exits at column 1. Balls from columns 1-4 get stuck due to V-shaped traps or wall collisions.

example_2.py — Single Row

$ Input: grid = [[-1]]

› Output: [-1]

💡 Note: The single ball hits the left wall immediately and gets stuck.

example_3.py — All Right Direction

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

› Output: [-1,-1,-1,-1,-1,1]

💡 Note: All balls slide right. Only the rightmost ball can exit, others hit the right wall.

Visualization

Tap to expand

Understanding the Visualization

Initialize

Place ball at top of each column

Move Down

Ball follows diagonal board direction

Check Collision

Detect walls and V-traps

Result

Record exit column or -1 if stuck

Key Takeaway

🎯 Key Insight: This is a pure simulation problem where we trace each ball's path through diagonal boards, checking for collision conditions at each step.

Time & Space Complexity

Time Complexity

⏱️

O(m × n)

For each of n balls, we simulate at most m rows

✓ Linear Growth

Space Complexity

O(1)

Only using variables to track current position

✓ Linear Space

Constraints

m == grid.length
n == grid[i].length
1 ≤ m, n ≤ 100
grid[i][j] is 1 or -1

Asked in

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

The optimal approach is simulation - trace each ball's path through the grid row by row. Key insight: balls get stuck when they hit walls (boundaries) or V-shaped traps (adjacent cells with opposite directions). Time complexity: O(m × n).

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force Simulation	O(m × n)	O(1)	Simulate each ball's path row by row, checking for collisions

Brute Force Simulation — Algorithm Steps

For each starting column, initialize ball position
For each row, calculate next column based on current board value
Check if ball hits wall (column < 0 or >= n)
Check if ball hits V-shaped trap (adjacent boards both point inward)
If ball reaches bottom row without getting stuck, return final column

Visualization

Tap to expand

Step-by-Step Walkthrough

Drop Ball

Start ball at top of column

Follow Direction

Move according to board direction (1=right, -1=left)

Check Collision

Verify ball doesn't hit walls or V-traps

Continue or Stop

Either continue to next row or mark as stuck

Code -

solution.c — C

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

int* findBall(int** grid, int gridSize, int* gridColSize, int* returnSize) {
    int m = gridSize, n = gridColSize[0];
    int* result = (int*)malloc(n * sizeof(int));
    *returnSize = n;
    
    for (int startCol = 0; startCol < n; startCol++) {
        int col = startCol;
        
        for (int row = 0; row < m; row++) {
            int direction = grid[row][col];
            int nextCol = col + direction;
            
            // Check if ball hits wall
            if (nextCol < 0 || nextCol >= n) {
                col = -1;
                break;
            }
            
            // Check if ball hits V-shaped trap
            if (grid[row][nextCol] != direction) {
                col = -1;
                break;
            }
            
            col = nextCol;
        }
        
        result[startCol] = col;
    }
    
    return result;
}

int main() {
    // Implementation for input parsing
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m × n)

For each of n balls, we simulate at most m rows

✓ Linear Growth

Space Complexity

O(1)

Only using variables to track current position

✓ Linear Space

Constraints

m == grid.length
n == grid[i].length
1 ≤ m, n ≤ 100
grid[i][j] is 1 or -1

42.0K Views

Medium Frequency

~15 min Avg. Time

1.9K 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 Simulation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler