Special Binary String - Practice Coding Problems

Special Binary String - Problem

String Recursion Hard

Special Binary Strings are like perfectly balanced parentheses! Think of 1 as an opening bracket and 0 as a closing bracket.

A special binary string has two magical properties:
• Equal Count: Same number of 1's and 0's (like balanced parentheses)
• Valid Prefix: At any point reading left-to-right, you never have more 0's than 1's

For example, "1100" and "1010" are special, but "0110" is not (starts with 0).

Your Mission: You can swap any two consecutive special substrings to make the string lexicographically largest. Since '1' > '0', we want as many 1's as early as possible!

Input: A special binary string s
Output: The lexicographically largest string after optimal swaps

Input & Output

example_1.py — Basic Swap

$ Input: s = "11011000"

› Output: "11100100"

💡 Note: We can decompose this into three special substrings: "1100", "1100", and "10". After recursively optimizing (no change needed), we sort them: "1100" > "1100" > "10", giving us "11001100". Wait - let me recalculate: "11011000" splits into "1101", "10", "00". The "1101" contains "10" inside, becoming "1100". Sorted: "1100", "10", "10" → "11001010".

example_2.py — Simple Case

$ Input: s = "10"

› Output: "10"

💡 Note: This is already the smallest possible special binary string with one '1' and one '0'. No swaps possible or needed.

example_3.py — Nested Structure

$ Input: s = "1100"

› Output: "1100"

💡 Note: This string has the structure where we can't improve it further. It's a single special substring "1100" with empty inner part, so the result remains "1100".

Constraints

1 ≤ s.length ≤ 50
s consists of only '0' and '1' characters
s is guaranteed to be a special binary string

Visualization

Tap to expand

Understanding the Visualization

Identify Trail Segments

Find complete trail segments (special substrings) at the current level

Optimize Inner Trails

For each segment, recursively optimize the inner trail (remove outer uphill/downhill)

Arrange for Best View

Sort segments in descending order to put the most scenic routes first

Combine Trail Map

Concatenate the optimally arranged segments into the final trail

Key Takeaway

🎯 Key Insight: Special binary strings have a recursive structure like balanced parentheses. By decomposing, optimizing recursively, and sorting lexicographically, we achieve the optimal solution in O(n²) time.

Asked in

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

The optimal approach treats special binary strings like balanced parentheses and uses recursive divide-and-conquer. We decompose the string into top-level special substrings, recursively optimize each inner part, then sort in descending order to achieve the lexicographically largest result in O(n²) time.

Common Approaches

Approach	Time	Space	Notes
✓ Recursive Divide & Conquer (Optimal)	O(n²)	O(n)	Recursively decompose and sort special substrings like balanced parentheses

Recursive Divide & Conquer (Optimal) — Algorithm Steps

Find all top-level special substrings (like matching parentheses)
For each substring, remove outer '1' and '0', recursively solve the inner part
Add back the outer '1' and '0' to each solved substring
Sort all substrings in descending order (lexicographically)
Concatenate the sorted substrings

Visualization

Tap to expand

Step-by-Step Walkthrough

Find Top-Level

Identify complete special substrings at current level

Recurse Inner

Recursively solve inner parts

Sort & Combine

Sort results and concatenate

Code -

solution.c — C

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

int compare(const void* a, const void* b) {
    return strcmp(*(char**)b, *(char**)a); // Descending order
}

char* makeLargestSpecial(char* s) {
    int len = strlen(s);
    
    // Base case
    if (len <= 2) {
        char* result = (char*)malloc((len + 1) * sizeof(char));
        strcpy(result, s);
        return result;
    }
    
    // Find all top-level special substrings
    char** substrings = (char**)malloc(len * sizeof(char*));
    int substringCount = 0;
    int count = 0;
    int start = 0;
    
    for (int i = 0; i < len; i++) {
        if (s[i] == '1') {
            count++;
        } else {
            count--;
        }
        
        // Complete special substring found
        if (count == 0) {
            int innerLen = i - start - 1;
            if (innerLen > 0) {
                char* inner = (char*)malloc((innerLen + 1) * sizeof(char));
                strncpy(inner, s + start + 1, innerLen);
                inner[innerLen] = '\0';
                
                char* innerResult = makeLargestSpecial(inner);
                
                int newLen = strlen(innerResult) + 3;
                substrings[substringCount] = (char*)malloc(newLen * sizeof(char));
                sprintf(substrings[substringCount], "1%s0", innerResult);
                
                free(inner);
                free(innerResult);
            } else {
                substrings[substringCount] = (char*)malloc(3 * sizeof(char));
                strcpy(substrings[substringCount], "10");
            }
            substringCount++;
            start = i + 1;
        }
    }
    
    // Sort in descending order
    qsort(substrings, substringCount, sizeof(char*), compare);
    
    // Concatenate result
    int totalLen = 1;
    for (int i = 0; i < substringCount; i++) {
        totalLen += strlen(substrings[i]);
    }
    
    char* result = (char*)malloc(totalLen * sizeof(char));
    result[0] = '\0';
    
    for (int i = 0; i < substringCount; i++) {
        strcat(result, substrings[i]);
        free(substrings[i]);
    }
    
    free(substrings);
    return result;
}

int main() {
    char* testCases[] = {"11011000", "10", "1100"};
    int numTests = sizeof(testCases) / sizeof(testCases[0]);
    
    for (int i = 0; i < numTests; i++) {
        char* result = makeLargestSpecial(testCases[i]);
        printf("Input: %s -> Output: %s\n", testCases[i], result);
        free(result);
    }
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Each character is processed in at most O(n) recursive levels, and sorting takes O(n log n) per level

⚠ Quadratic Growth

Space Complexity

O(n)

Recursion stack depth and temporary arrays for storing substrings

⚡ Linearithmic Space

28.4K Views

Medium Frequency

~25 min Avg. Time

892 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

Recursive Divide & Conquer (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler