Minimum Number of Swaps to Make the Binary String Alternating

Minimum Number of Swaps to Make the Binary String Alternating - Problem

String Greedy Medium

Given a binary string s, your task is to transform it into an alternating pattern using the minimum number of character swaps. An alternating string has no two adjacent characters that are the same - think patterns like "010101" or "101010".

You can swap any two characters in the string, regardless of their positions. If it's impossible to create an alternating pattern, return -1.

For example, "110" can become "101" with just 1 swap, but "111" is impossible to make alternating since we need equal or near-equal counts of 0s and 1s.

Input & Output

example_1.py — Python

$ Input: s = "111"

› Output: -1

💡 Note: It's impossible to make "111" alternating since we need both 0s and 1s. An alternating string requires roughly equal counts of each character.

example_2.py — Python

$ Input: s = "010"

› Output: 0

💡 Note: The string "010" is already alternating (no adjacent characters are the same), so 0 swaps are needed.

example_3.py — Python

$ Input: s = "1110"

› Output: 1

💡 Note: We can make "1110" alternating by swapping one character. For example, swap positions 1 and 3 to get "1010" or "0101" with 1 swap.

Constraints

1 ≤ s.length ≤ 10⁵
s[i] is either '0' or '1'
The string contains only binary characters

Visualization

Tap to expand

Understanding the Visualization

Count Dancers

Count red and blue dancers (0s and 1s)

Check Feasibility

Verify counts differ by at most 1

Try Both Patterns

Test RBRBRB... and BRBRBR... arrangements

Calculate Swaps

Count misplaced dancers for each pattern

Choose Optimal

Pick the pattern requiring fewer moves

Key Takeaway

🎯 Key Insight: Only 2 possible alternating patterns exist! Count characters, verify feasibility, then test both patterns and choose the one requiring minimum swaps.

Asked in

G Google 45 a Amazon 38 ⊞ Microsoft 32 f Meta 28

The optimal solution uses a greedy approach recognizing that only two alternating patterns exist: starting with '0' (010101...) or starting with '1' (101010...). We count the characters, verify alternating is possible when |count0 - count1| ≤ 1, then test both patterns and return the minimum swaps needed. This achieves O(n) time and O(1) space complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Greedy Pattern Matching (Optimal)	O(n)	O(1)	Count characters and try both alternating patterns, choosing the one with fewer mismatches
Brute Force (Try All Permutations)	O(n! × n)	O(n!)	Generate all possible permutations and check which ones are alternating

Greedy Pattern Matching (Optimal) — Algorithm Steps

Count total zeros and ones in the string
Check if alternating pattern is possible (counts differ by at most 1)
Try pattern starting with '0': 010101...
Try pattern starting with '1': 101010...
For each pattern, count positions that need to be swapped
Return minimum swaps needed, or -1 if impossible

Visualization

Tap to expand

Step-by-Step Walkthrough

Count Characters

Count total 0s and 1s to verify alternating is possible

Check Feasibility

Ensure |count0 - count1| ≤ 1 for valid alternating pattern

Try Pattern 010101

Count mismatches when forcing pattern to start with 0

Try Pattern 101010

Count mismatches when forcing pattern to start with 1

Choose Optimal

Return minimum swaps needed from both patterns

Code -

solution.c — C

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

int countSwapsForPattern(char* s, char startChar) {
    int mismatches = 0;
    int len = strlen(s);
    for (int i = 0; i < len; i++) {
        char expected = (i % 2 == 0) ? startChar : (startChar == '0' ? '1' : '0');
        if (s[i] != expected) {
            mismatches++;
        }
    }
    // Each swap fixes 2 mismatches
    return mismatches / 2;
}

int minimumSwaps(char* s) {
    int n = strlen(s);
    int count0 = 0;
    for (int i = 0; i < n; i++) {
        if (s[i] == '0') count0++;
    }
    int count1 = n - count0;
    
    // Check if alternating pattern is possible
    if (abs(count0 - count1) > 1) {
        return -1;
    }
    
    // Try both patterns
    int swapsStart0 = countSwapsForPattern(s, '0');
    int swapsStart1 = countSwapsForPattern(s, '1');
    
    // If counts are equal, both patterns are valid
    if (count0 == count1) {
        return (swapsStart0 < swapsStart1) ? swapsStart0 : swapsStart1;
    }
    // If more 0s, must start with 0
    else if (count0 > count1) {
        return swapsStart0;
    }
    // If more 1s, must start with 1
    else {
        return swapsStart1;
    }
}

int main() {
    char s[100001];
    scanf("%s", s);
    printf("%d\n", minimumSwaps(s));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass to count characters, then one more pass to check each pattern

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables to track counts and mismatches

✓ Linear Space

41.3K Views

Medium-High Frequency

~15 min Avg. Time

1.8K 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 Pattern Matching (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler