Maximum Binary String After Change

Maximum Binary String After Change - Problem

String Greedy Medium

You are given a binary string binary consisting of only 0's and 1's. You can apply each of the following operations any number of times:

Operation 1: If the string contains the substring "00", you can replace it with "10".
For example, "00010" → "10010"

Operation 2: If the string contains the substring "10", you can replace it with "01".
For example, "00010" → "00001"

Return the maximum binary string you can obtain after any number of operations. Binary string x is greater than binary string y if x's decimal representation is greater than y's decimal representation.

Input & Output

Example 1 — Basic Case

$ Input: binary = "000110"

› Output: "111011"

💡 Note: Apply operations: 000110 → 100110 → 110110 → 111010 → 111001. No more beneficial operations possible.

Example 2 — Single Zero

$ Input: binary = "01"

› Output: "10"

💡 Note: Direct application of Operation 2: 01 becomes 10 using the 10→01 rule in reverse.

Example 3 — No Zeros

$ Input: binary = "111"

› Output: "111"

💡 Note: String contains no zeros, so no operations can be applied. Return unchanged.

Constraints

1 ≤ binary.length ≤ 10⁵
binary consists of only '0' and '1'

Visualization

Tap to expand

Asked in

G Google 15 f Facebook 12

The key insight is that all zeros can be moved to the right using Operation 2 (10→01), except we need exactly one zero to remain for the maximum binary value. The optimal position for this zero is at first_zero_position + zero_count - 1. Best approach uses greedy strategy with Time: O(n), Space: O(n).

Common Approaches

✓ Brute Force - Simulate All Operations

⏱️ Time: O(n³) Space: O(n)

Keep applying Operation 1 (00→10) and Operation 2 (10→01) in all possible positions until the string cannot be improved further. This explores all possible transformation sequences.

Greedy - Pattern Recognition

⏱️ Time: O(n) Space: O(n)

Recognize that Operation 2 can move any 0 to the rightmost position, and Operation 1 can convert pairs of 0's to start with 1. The optimal strategy is to keep exactly one 0 at the leftmost possible position.

Brute Force - Simulate All Operations — Algorithm Steps

Scan string for "00" and "10" patterns
Apply operations and track if string improved
Repeat until no more beneficial operations found

Visualization

Tap to expand

Step-by-Step Walkthrough

Find Patterns

Search for "00" and "10" substrings

Apply Operations

Transform patterns and check if result is better

Repeat

Continue until no improvements possible

Code -

solution.c — C

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

char* solution(char* binary) {
    int n = strlen(binary);
    int zeroCount = 0;
    int firstZeroPos = -1;
    
    // Count zeros and find first zero position
    for (int i = 0; i < n; i++) {
        if (binary[i] == '0') {
            zeroCount++;
            if (firstZeroPos == -1) {
                firstZeroPos = i;
            }
        }
    }
    
    char* result = (char*)malloc((n + 1) * sizeof(char));
    result[n] = '\0';
    
    if (zeroCount == 0) {
        strcpy(result, binary);
        return result;
    }
    
    // Fill with all 1's
    for (int i = 0; i < n; i++) {
        result[i] = '1';
    }
    
    // Place one 0 at optimal position
    result[firstZeroPos + zeroCount - 1] = '0';
    
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

Each operation can be applied O(n) times, with O(n) positions to check, and O(n) string comparisons

⚠ Quadratic Growth

Space Complexity

O(n)

Store current string and temporary modifications

⚡ Linearithmic Space

30.0K Views

Medium Frequency

~25 min Avg. Time

856 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 - Simulate All Operations — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler