Minimum Number of Operations to Move All Balls to Each Box

Minimum Number of Operations to Move All Balls to Each Box - Problem

Imagine you have a row of n boxes lined up in front of you, some empty and some containing exactly one ball. Your task is to figure out: "What's the minimum cost to move all balls to each specific box?"

You're given a binary string boxes where:

boxes[i] = '1' means the i-th box contains one ball
boxes[i] = '0' means the i-th box is empty

In each operation, you can move one ball from any box to an adjacent box (distance of exactly 1). The goal is to calculate, for each box position, how many total operations it would take to move all balls to that specific box.

Example: If boxes = "110", then:
• To move all balls to box 0: move ball from box 1 → box 0 (1 operation)
• To move all balls to box 1: ball is already there, move ball from box 0 → box 1 (1 operation)
• To move all balls to box 2: move both balls rightward (1+2 = 3 operations)

Return an array where answer[i] represents the minimum operations needed to gather all balls at box i.

Input & Output

example_1.py — Basic Case

$ Input: boxes = "110"

› Output: [1, 1, 3]

💡 Note: Box 0: move ball from box 1 to box 0 (1 operation). Box 1: ball already at box 1, move ball from box 0 to box 1 (1 operation). Box 2: move ball from box 0 to box 2 (2 operations) + move ball from box 1 to box 2 (1 operation) = 3 operations total.

example_2.py — Sparse Balls

$ Input: boxes = "001011"

› Output: [11, 8, 5, 4, 3, 4]

💡 Note: There are balls at positions 2, 4, and 5. For each target position, calculate the sum of distances from all balls to that position. For example, to move all balls to position 0: |0-2| + |0-4| + |0-5| = 2 + 4 + 5 = 11 operations.

example_3.py — Single Ball

$ Input: boxes = "010"

› Output: [1, 0, 1]

💡 Note: Only one ball at position 1. To gather at position 0: 1 operation. To gather at position 1: 0 operations (already there). To gather at position 2: 1 operation.

Constraints

n == boxes.length
1 ≤ n ≤ 2000
boxes[i] is either '0' or '1'
Each box contains at most one ball
At least one box contains a ball

Visualization

Tap to expand

Understanding the Visualization

Identify Ball Positions

Mark all positions that currently contain balls

Left Pass Calculation

For each position, calculate operations needed from balls to the left

Right Pass Calculation

For each position, calculate operations needed from balls to the right

Combine Results

Sum left and right contributions to get total operations for each position

Key Takeaway

🎯 Key Insight: Instead of recalculating distances for each position from scratch, we can use prefix sums to track how the total operations change as we move from one target position to the next, achieving optimal O(n) time complexity.

Asked in

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

The optimal solution uses a two-pass prefix sum approach with O(n) time complexity. In the first pass (left to right), we calculate how many operations are needed from balls on the left. In the second pass (right to left), we calculate contributions from balls on the right. The key insight is that as we move from position to position, we can incrementally update the total operations rather than recalculating from scratch.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Nested Loops)	O(n²)	O(1)	For each target position, calculate distance from every ball individually
Two-Pass Prefix Sum	O(n)	O(1)	Calculate contributions from left balls and right balls separately

Brute Force (Nested Loops) — Algorithm Steps

For each target box position i (0 to n-1)
Iterate through all boxes to find balls (where boxes[j] == '1')
For each ball at position j, add |i - j| to the total cost
Store the total cost in result[i]

Visualization

Tap to expand

Step-by-Step Walkthrough

Target Position 0

Calculate distance from each ball (positions 0,1) to target position 0

Target Position 1

Calculate distance from each ball to target position 1

Target Position 2

Calculate distance from each ball to target position 2

Code -

solution.c — C

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

int* minOperations(char* boxes, int* returnSize) {
    int n = strlen(boxes);
    int* result = (int*)malloc(n * sizeof(int));
    *returnSize = n;
    
    for (int i = 0; i < n; i++) {
        int totalOps = 0;
        for (int j = 0; j < n; j++) {
            if (boxes[j] == '1') {
                totalOps += abs(i - j);
            }
        }
        result[i] = totalOps;
    }
    
    return result;
}

int main() {
    char boxes[1001];
    scanf("%s", boxes);
    // Remove quotes if present
    if (boxes[0] == '"') {
        int len = strlen(boxes);
        memmove(boxes, boxes + 1, len - 2);
        boxes[len - 2] = '\0';
    }
    
    int returnSize;
    int* result = minOperations(boxes, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("%d", result[i]);
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n positions, we check all n boxes to find balls and calculate distances

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space beyond the output array

✓ Linear Space

28.9K Views

Medium Frequency

~15 min Avg. Time

1.3K 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

Brute Force (Nested Loops) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler