Maximum Binary String After Change - Practice Coding Problems

Maximum Binary String After Change - Problem

String Greedy Medium

Imagine you're a master string manipulator working with binary strings (containing only '0's and '1's). Your mission is to transform any given binary string into the lexicographically largest possible binary string using two powerful operations:

Operation 1: Replace any substring "00" with "10"
Example: "00010" → "10010"
Operation 2: Replace any substring "10" with "01"
Example: "00010" → "00001"

You can apply these operations any number of times in any order. Your goal is to find the maximum possible binary string (the one that would have the largest decimal value).

Key Insight: To maximize a binary string, we want as many '1's as possible at the beginning, since earlier positions have higher place values in binary representation.

Input & Output

example_1.py — Basic Transformation

$ Input: binary = "000110"

› Output: "111100"

💡 Note: We can transform "000110" → "111100" by applying operations: "000110" → "001110" → "011110" → "101110" → "110110" → "111010" → "111100". The optimal pattern places all possible 1's at the beginning.

example_2.py — Single Zero

$ Input: binary = "01"

› Output: "01"

💡 Note: With only one zero, we cannot improve the string. "01" is already optimal as we cannot make it lexicographically larger with the given operations.

example_3.py — All Ones

$ Input: binary = "1111"

› Output: "1111"

💡 Note: A string of all ones is already maximum. No operations are needed or possible since there are no '00' or '10' substrings to transform.

Constraints

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

Visualization

Tap to expand

Understanding the Visualization

Analyze Input

Count total zeros and find where the first zero appears

Apply Pattern

Recognize that optimal form is: 1's + 0's + 1's

Direct Construction

Build result using the mathematical pattern rather than simulation

Optimal Result

Return the lexicographically maximum binary string

Key Takeaway

🎯 Key Insight: Instead of simulating operations, recognize that the optimal binary string always follows a specific pattern: maximize 1's at the start, group all 0's together, then place remaining 1's. This mathematical insight transforms an O(n³) simulation into an O(n) pattern construction.

Asked in

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

The optimal solution uses pattern recognition to achieve O(n) time complexity. Key insight: the maximum binary string always follows the pattern of maximum 1's at the start, followed by all zeros grouped together, then remaining 1's. Simply count zeros, find the first zero position, and construct this optimal pattern directly.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Repeated Operations)	O(n³)	O(n)	Keep applying operations until no more improvements possible
Greedy Pattern Recognition (Optimal)	O(n)	O(1)	Recognize the optimal pattern and construct it directly

Brute Force (Repeated Operations) — Algorithm Steps

Start with the original binary string
Repeatedly scan for "00" patterns and replace with "10" (always beneficial)
Look for "10" patterns and replace with "01" if it helps maximize the string
Continue until no more improvements can be made
Return the final maximized string

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial String

Start with the input binary string

Find Pattern

Scan for '00' or '10' patterns

Apply Operation

Replace found pattern with beneficial transformation

Repeat

Continue until no more improvements possible

Code -

solution.c — C

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

char* maximumBinaryString(char* binary) {
    int len = strlen(binary);
    char* s = malloc((len + 1) * sizeof(char));
    strcpy(s, binary);
    
    int changed = 1;
    while (changed) {
        changed = 0;
        
        // First priority: replace "00" with "10"
        for (int i = 0; i < len - 1; i++) {
            if (s[i] == '0' && s[i + 1] == '0') {
                s[i] = '1';
                s[i + 1] = '0';
                changed = 1;
                break;
            }
        }
        
        // Strategic "10" -> "01" replacement
        if (!changed) {
            for (int i = 0; i < len - 1; i++) {
                if (s[i] == '1' && s[i + 1] == '0') {
                    // Check if there's a 0 before position i
                    int hasZeroBefore = 0;
                    for (int j = 0; j < i; j++) {
                        if (s[j] == '0') {
                            hasZeroBefore = 1;
                            break;
                        }
                    }
                    if (hasZeroBefore) {
                        s[i] = '0';
                        s[i + 1] = '1';
                        changed = 1;
                        break;
                    }
                }
            }
        }
    }
    
    return s;
}

int main() {
    char binary[100001];
    scanf("%s", binary);
    // Remove quotes if present
    if (binary[0] == '"') {
        int len = strlen(binary);
        memmove(binary, binary + 1, len - 2);
        binary[len - 2] = '\0';
    }
    char* result = maximumBinaryString(binary);
    printf("\"%s\"\n", result);
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

In worst case, we might need O(n) iterations, each taking O(n) time to scan and O(n) time to rebuild string

⚠ Quadratic Growth

Space Complexity

O(n)

We need space to store the modified string during operations

⚡ Linearithmic Space

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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Repeated Operations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler