Minimum Number of Changes to Make Binary String Beautiful

Minimum Number of Changes to Make Binary String Beautiful - Problem

String Medium

Given a binary string s with an even length, you need to make it beautiful with the minimum number of character changes.

A binary string is considered beautiful if it can be partitioned into one or more substrings where:

Each substring has an even length
Each substring contains only 1's or only 0's (homogeneous)

Goal: Find the minimum number of character flips (0→1 or 1→0) needed to make the string beautiful.

Example: "1001" can become "1100" with 1 change, creating substrings "11" and "00".

Input & Output

example_1.py — Basic Case

$ Input: s = "1001"

› Output: 2

💡 Note: We can change "1001" to "1100" by changing positions 2 and 3. This creates two beautiful substrings: "11" and "00". Total changes needed: 2.

example_2.py — Already Beautiful

$ Input: s = "10"

› Output: 1

💡 Note: The string "10" needs 1 change to become beautiful. We can change it to "11" or "00", both are valid beautiful strings of even length with homogeneous characters.

example_3.py — Longer String

$ Input: s = "11000111"

› Output: 1

💡 Note: Analyzing pairs: (1,1)=same, (0,0)=same, (0,1)=different, (1,1)=same. Only one pair needs changing, so minimum changes = 1.

Constraints

2 ≤ s.length ≤ 10⁵
s.length is even
s consists only of characters '0' and '1'

Visualization

Tap to expand

Understanding the Visualization

Identify Pairs

Group consecutive buckets into pairs of 2

Check Compatibility

See if both buckets in each pair have the same paint color

Fix Mismatches

Change one bucket's paint in each mismatched pair

Count Changes

Sum up all the paint changes needed

Key Takeaway

🎯 Key Insight: Processing pairs greedily is optimal because any valid beautiful partition must have even-length substrings, and length-2 substrings are the most flexible and require minimal changes.

Asked in

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

The optimal solution uses a greedy approach processing the string in pairs. Since we need even-length homogeneous substrings, pairs of length 2 are always optimal. Simply count pairs with different characters - each needs exactly 1 change. Time: O(n), Space: O(1).

Common Approaches

Approach	Time	Space	Notes
✓ Greedy Pair-by-Pair (Optimal)	O(n)	O(1)	Process adjacent pairs greedily, making each pair homogeneous

Greedy Pair-by-Pair (Optimal) — Algorithm Steps

Iterate through the string in steps of 2 (processing pairs)
For each pair at positions i and i+1, check if characters are different
If different, increment the change counter by 1
Continue until all pairs are processed
Return the total number of changes needed

Visualization

Tap to expand

Step-by-Step Walkthrough

Pair Analysis

Check each consecutive pair of characters

Count Mismatches

If pair characters differ, increment change counter

Optimal Result

Total changes needed for beautiful string

Code -

solution.c — C

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

int minChangesToMakeBeautiful(const char* s) {
    int changes = 0;
    int n = strlen(s);
    // Process string in pairs
    for (int i = 0; i < n; i += 2) {
        // If pair has different characters, need 1 change
        if (s[i] != s[i + 1]) {
            changes++;
        }
    }
    return changes;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the string, checking n/2 pairs

✓ Linear Growth

Space Complexity

O(1)

Only using a constant amount of extra space for the counter

✓ Linear Space

23.4K Views

Medium Frequency

~12 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

Greedy Pair-by-Pair (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler