Minimum Changes To Make Alternating Binary String

Minimum Changes To Make Alternating Binary String - Problem

String Easy

You are given a string s consisting only of the characters '0' and '1'. In one operation, you can change any '0' to '1' or vice versa.

The string is called alternating if no two adjacent characters are equal. For example, the string "010" is alternating, while the string "0100" is not.

Your goal is to transform the given binary string into an alternating pattern using the minimum number of operations. An alternating pattern means characters alternate between '0' and '1' throughout the string.

Return the minimum number of operations needed to make s alternating.

Key Insight: There are only two possible alternating patterns for any string - one starting with '0' (like "010101...") and one starting with '1' (like "101010..."). The answer is the minimum changes needed for either pattern.

Input & Output

example_1.py — Basic Alternating Pattern

$ Input: s = "0100"

› Output: 1

💡 Note: We can change s[3] from '0' to '1' to get "0101", which is alternating. This requires only 1 operation, which is the minimum possible.

example_2.py — Already Alternating

$ Input: s = "10"

› Output: 0

💡 Note: The string "10" is already alternating (no two adjacent characters are the same), so no operations are needed.

example_3.py — All Same Characters

$ Input: s = "1111"

› Output: 2

💡 Note: We can change s to "1010" (2 changes) or "0101" (2 changes). Both require 2 operations, which is the minimum.

Constraints

1 ≤ s.length ≤ 10⁴
s[i] is either '0' or '1'

Visualization

Tap to expand

Understanding the Visualization

Identify Two Patterns

There are only 2 valid checkerboard patterns: Black-first or White-first

Count Tile Flips

For each pattern, count how many tiles need to be flipped

Choose Minimum

Pick the pattern that requires fewer flips

Key Takeaway

🎯 Key Insight: Since there are only 2 possible alternating patterns, we can solve this optimally in O(n) time by counting mismatches for both patterns simultaneously!

Asked in

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

The optimal solution recognizes that there are only two possible alternating patterns: starting with '0' (010101...) or starting with '1' (101010...). By counting mismatches against both patterns in a single pass and returning the minimum, we achieve O(n) time complexity with O(1) space.

Common Approaches

Approach	Time	Space	Notes
✓ Single Pass Pattern Matching (Optimal)	O(n)	O(1)	Count mismatches for both possible alternating patterns in one pass
Brute Force (Try All Combinations)	O(2^n * n)	O(n)	Generate all possible alternating patterns and find minimum operations

Single Pass Pattern Matching (Optimal) — Algorithm Steps

Initialize counters for both patterns (starting with '0' and starting with '1')
Iterate through the string once
For each position, determine what character should be there for each pattern
Count mismatches for both patterns simultaneously
Return the minimum of the two counts

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Counters

Set up counters for both possible alternating patterns

Single Pass

Go through string once, checking both patterns at each position

Count Mismatches

Increment counters when current character doesn't match expected pattern

Return Minimum

Choose the pattern that requires fewer changes

Code -

solution.c — C

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

int minOperations(char* s) {
    int n = strlen(s);
    
    // Count changes needed for pattern starting with '0': 010101...
    int changesStart0 = 0;
    // Count changes needed for pattern starting with '1': 101010...
    int changesStart1 = 0;
    
    for (int i = 0; i < n; i++) {
        // For pattern starting with '0': even positions should be '0', odd should be '1'
        char expectedForStart0 = i % 2 == 0 ? '0' : '1';
        // For pattern starting with '1': even positions should be '1', odd should be '0'
        char expectedForStart1 = i % 2 == 0 ? '1' : '0';
        
        if (s[i] != expectedForStart0) {
            changesStart0++;
        }
        if (s[i] != expectedForStart1) {
            changesStart1++;
        }
    }
    
    return changesStart0 < changesStart1 ? changesStart0 : changesStart1;
}

int main() {
    char s[100001];
    fgets(s, sizeof(s), stdin);
    // Remove newline and quotes
    s[strcspn(s, "\n")] = 0;
    if (s[0] == '"') {
        memmove(s, s+1, strlen(s));
        s[strlen(s)-1] = '\0';
    }
    printf("%d\n", minOperations(s));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the string to count mismatches for both patterns

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for counters

✓ Linear Space

42.3K Views

High Frequency

~12 min Avg. Time

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

Single Pass Pattern Matching (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler