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.

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

Input & Output

Example 1 — Basic Case

$ Input: s = "0010"

› Output: 1

💡 Note: To make "0010" alternating, we can either match pattern "0101" (needs 2 changes at positions 1 and 3) or pattern "1010" (needs 1 change at position 0). The minimum is 1.

Example 2 — Already Alternating

$ Input: s = "010"

› Output: 0

💡 Note: String is already alternating (0-1-0), so no changes needed.

Example 3 — All Same Characters

$ Input: s = "1111"

› Output: 2

💡 Note: To make alternating: Pattern "0101" needs 4 changes, Pattern "1010" needs 2 changes. Minimum is 2.

Constraints

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

Visualization

Tap to expand

Asked in

G Google 15 f Facebook 12 M Microsoft 8

The key insight is that only two alternating patterns exist: starting with 0 (0101...) or starting with 1 (1010...). We count mismatches for both patterns and return the minimum. Best approach is the optimized single-pass solution. Time: O(n), Space: O(1)

Common Approaches

✓ Brute Force - Try All Patterns

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

For each possible alternating pattern starting with 0 or 1, calculate the number of changes needed by comparing each character position.

Optimized - Single Pass

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

Instead of generating pattern strings, calculate what each position should be based on index parity and count mismatches directly.

Brute Force - Try All Patterns — Algorithm Steps

Generate pattern starting with 0: 010101...
Count changes needed for pattern 0
Generate pattern starting with 1: 101010...
Count changes needed for pattern 1
Return minimum of both counts

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Patterns

Create both possible alternating patterns

Count Differences

Compare input with each pattern

Take Minimum

Return the smaller count

Code -

solution.c — C

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

int solution(char* s) {
    int n = strlen(s);
    char* pattern0 = (char*)malloc((n + 1) * sizeof(char));
    char* pattern1 = (char*)malloc((n + 1) * sizeof(char));
    
    // Generate both patterns
    for (int i = 0; i < n; i++) {
        pattern0[i] = (i % 2 == 0) ? '0' : '1';
        pattern1[i] = (i % 2 == 0) ? '1' : '0';
    }
    pattern0[n] = '\0';
    pattern1[n] = '\0';
    
    // Count changes needed
    int changes0 = 0, changes1 = 0;
    for (int i = 0; i < n; i++) {
        if (s[i] != pattern0[i]) changes0++;
        if (s[i] != pattern1[i]) changes1++;
    }
    
    free(pattern0);
    free(pattern1);
    
    return (changes0 < changes1) ? changes0 : changes1;
}

int main() {
    char s[100001];
    fgets(s, sizeof(s), stdin);
    s[strcspn(s, "\n")] = 0;  // Remove newline
    
    int result = solution(s);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Two passes through string of length n

✓ Linear Growth

Space Complexity

O(n)

Storing two alternating pattern strings

⚡ Linearithmic Space

28.5K Views

Medium Frequency

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

Brute Force - Try All Patterns — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler