Separate Black and White Balls - Practice Coding Problems

Separate Black and White Balls - Problem

🔴⚫ Separate Black and White Balls

Imagine you have n balls arranged in a line on a table, where each ball is either black (1) or white (0). You're given a binary string s of length n representing this arrangement.

Your goal is to rearrange the balls so that:

All white balls (0s) are grouped on the left side
All black balls (1s) are grouped on the right side

The only operation allowed is to swap two adjacent balls in each step. Find the minimum number of swaps needed to achieve this separation.

Example: "101" → "011" requires 1 swap (swap positions 0 and 1)

Input & Output

example_1.py — Basic case

$ Input: s = "101"

› Output: 1

💡 Note: We can swap positions 0 and 1: "101" → "011". The black ball at position 0 needs to jump over 1 white ball.

example_2.py — Multiple swaps

$ Input: s = "100"

› Output: 2

💡 Note: The black ball at position 0 needs to move past 2 white balls: "100" → "010" → "001". Total: 2 swaps.

example_3.py — Already sorted

$ Input: s = "0011"

› Output: 0

💡 Note: Already in correct order (white balls left, black balls right). No swaps needed.

Constraints

1 ≤ n ≤ 10⁵
s[i] is either '0' or '1'
The string contains at least one character

Visualization

Tap to expand

Understanding the Visualization

Count White Balls

As we scan left to right, keep count of white balls (0s) seen

Process Black Balls

When we see a black ball (1), it must pass all white balls to its left

Add to Result

Add the white ball count to our total swaps - that's exactly how many swaps this black ball needs

Continue Scanning

Repeat for all characters in the string

Key Takeaway

🎯 Key Insight: Each black ball must cross exactly all white balls to its left - count these crossings efficiently in one pass!

Asked in

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

The optimal solution uses a greedy approach in O(n) time. Key insight: each black ball must pass through all white balls to its left exactly once. Simply count white balls seen so far and add to result for each black ball encountered.

Common Approaches

Approach	Time	Space	Notes
✓ Single Pass Greedy (Optimal)	O(n)	O(1)	Count white balls encountered while scanning, add to result for each black ball
Brute Force (Bubble Sort Style)	O(n²)	O(1)	Repeatedly scan and swap adjacent misplaced balls until sorted

Single Pass Greedy (Optimal) — Algorithm Steps

Initialize counters for swaps and white balls seen
Scan string from left to right
When we see '0' (white ball), increment white ball counter
When we see '1' (black ball), add white ball count to total swaps
Return total swaps

Visualization

Tap to expand

Step-by-Step Walkthrough

Scan Position 0

See '1' (black), white_count=0, add 0 to swaps

Scan Position 1

See '0' (white), increment white_count to 1

Scan Position 2

See '1' (black), white_count=1, add 1 to swaps

Final Result

Total swaps = 0 + 1 = 1

Code -

solution.c — C

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

long long minimumSteps(char* s) {
    long long swaps = 0;
    long long whiteBalls = 0;
    
    for (int i = 0; s[i]; i++) {
        if (s[i] == '0') {
            whiteBalls++;
        } else {
            swaps += whiteBalls;
        }
    }
    
    return swaps;
}

int main() {
    char s[100001];
    fgets(s, sizeof(s), stdin);
    
    // Remove newline and quotes
    s[strcspn(s, "\n")] = 0;
    if (s[0] == '"') {
        int len = strlen(s);
        memmove(s, s + 1, len - 1);
        s[len - 2] = '\0';
    }
    
    printf("%lld\n", minimumSteps(s));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the string, checking each character once

✓ Linear Growth

Space Complexity

O(1)

Only using two variables to track counts

✓ Linear Space

38.9K Views

Medium Frequency

~15 min Avg. Time

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

🔴⚫ Separate Black and White Balls

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Single Pass Greedy (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler