Time Needed to Rearrange a Binary String - Practice Coding Problems

Time Needed to Rearrange a Binary String - Problem

Transform Binary String Through Bubble Swapping

You are given a binary string s containing only '0' and '1' characters. Your goal is to determine how long it takes for all the '1's to "bubble up" to the right side of the string.

The transformation follows a specific rule: In each second, all occurrences of the pattern "01" are simultaneously replaced with "10". This process continues until no more "01" patterns exist in the string.

Example:
"0110" → "1010" → "1100"
This takes 2 seconds to complete.

Return the minimum number of seconds needed to complete this rearrangement process.

Input & Output

example_1.py — Basic Case

$ Input: s = "0110"

› Output: 2

💡 Note: After 1 second: "0110" → "1010". After 2 seconds: "1010" → "1100". No more "01" patterns exist, so we return 2.

example_2.py — No Transformation Needed

$ Input: s = "11100"

› Output: 0

💡 Note: The string already has all '1's before all '0's, so no transformations are needed. Return 0.

example_3.py — Multiple Swaps

$ Input: s = "010110"

› Output: 3

💡 Note: Second 1: "010110" → "100110" → "101100". Second 2: "101100" → "110100" → "111000". Second 3: "111000" (done). Total: 3 seconds.

Visualization

Tap to expand

Understanding the Visualization

Initial Setup

Identify all '1' bubbles and '0' heavy particles in the string

Simultaneous Swapping

In each second, all adjacent '01' pairs swap to become '10'

Calculate Mathematically

Instead of simulation, calculate how many '0's each '1' needs to pass

Account for Timing

Use max(time + 1, zeros) to handle sequential movement timing

Key Takeaway

🎯 Key Insight: Instead of simulating each second, calculate the maximum time any '1' needs to reach its final position by counting the zeros to its right and accounting for sequential movement timing.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the string from right to left

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables to track counts and time

✓ Linear Space

Constraints

1 ≤ s.length ≤ 10⁵
s consists only of characters '0' and '1'
The string is guaranteed to be non-empty

Asked in

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

The optimal solution uses mathematical calculation instead of simulation. By traversing the string from right to left, we can calculate how long each '1' takes to move past all the '0's to its right. The key insight is using time = max(time + 1, zeros) to account for both the number of zeros to pass and the sequential timing of movements. This achieves O(n) time complexity with O(1) space.

Common Approaches

Approach	Time	Space	Notes
✓ Simulation (String Replacement)	O(n²)	O(n)	Simulate the process by repeatedly replacing all "01" with "10" until no changes occur
Mathematical Calculation (Optimal)	O(n)	O(1)	Calculate the result mathematically by determining how many steps each '1' needs to reach its final position

Simulation (String Replacement) — Algorithm Steps

Initialize a counter for seconds
While the string contains "01" patterns:
Replace all "01" occurrences with "10" simultaneously
Increment the seconds counter
Return the total seconds counted

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial State

Start with the original binary string

Find Patterns

Identify all '01' patterns in the current string

Simultaneous Swap

Replace all '01' patterns with '10' at the same time

Check Completion

If no '01' patterns remain, we're done; otherwise repeat

Code -

solution.c — C

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

int secondsToRemoveOccurrences(char* s) {
    int seconds = 0;
    int len = strlen(s);
    
    while (strstr(s, "01") != NULL) {
        char* newS = (char*)malloc((len + 1) * sizeof(char));
        int j = 0;
        
        for (int i = 0; i < len; i++) {
            if (i < len - 1 && s[i] == '0' && s[i+1] == '1') {
                newS[j++] = '1';
                newS[j++] = '0';
                i++;
            } else {
                newS[j++] = s[i];
            }
        }
        newS[j] = '\0';
        strcpy(s, newS);
        free(newS);
        seconds++;
    }
    return seconds;
}

int main() {
    char s[1001];
    scanf("%s", s);
    // Remove quotes if present
    if (s[0] == '"') {
        int len = strlen(s);
        memmove(s, s+1, len-2);
        s[len-2] = '\0';
    }
    printf("%d\n", secondsToRemoveOccurrences(s));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

In worst case, we need O(n) iterations and each iteration takes O(n) time to scan and replace

⚠ Quadratic Growth

Space Complexity

O(n)

Need to store the modified string in each iteration

⚡ Linearithmic Space

Constraints

1 ≤ s.length ≤ 10⁵
s consists only of characters '0' and '1'
The string is guaranteed to be non-empty

28.4K Views

Medium Frequency

~15 min Avg. Time

890 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

Simulation (String Replacement) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler