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, return the minimum number of character swaps to make it alternating, or -1 if it is impossible.

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

Any two characters may be swapped, even if they are not adjacent.

Input & Output

Example 1 — Equal 0s and 1s

$ Input: s = "111"

› Output: 1

💡 Note: We can swap position 0 and 1 to get "111" → "111" is impossible. We need at least one '0'. Since we have 3 ones and 0 zeros, it's impossible to make alternating. Wait, let me recalculate: "111" has all 1s, we need to make it alternating. The only possible patterns are "010" or "101". For "010": need 2 swaps. For "101": need 2 swaps. But we can't swap to create 0s from 1s. Actually, this should return -1.

Example 2 — Already Alternating

$ Input: s = "010"

› Output: 0

💡 Note: The string is already alternating, so no swaps needed

Example 3 — Need One Swap

$ Input: s = "1110"

› Output: 1

💡 Note: We can swap one '1' with '0' to get "1010" which is alternating. One swap transforms "1110" to "1010"

Constraints

1 ≤ s.length ≤ 1000
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' or '1'. We count 0s and 1s, check if alternating is possible (difference ≤ 1), then compare with both patterns and return minimum swaps. Best approach is Greedy Pattern Matching. Time: O(n), Space: O(1)

Common Approaches

✓ Greedy Pattern Matching

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

Since only two alternating patterns are possible (starting with '0' or '1'), we check both patterns, count mismatches, and return the minimum swaps needed.

Try All Swap Combinations

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

This approach tries every possible combination of swaps to see which one results in an alternating string with minimum swaps. We use BFS to explore all possible states.

Greedy Pattern Matching — Algorithm Steps

Check if alternating is possible (equal 0s and 1s, or difference of 1)
Try pattern starting with '0': "010101..."
Try pattern starting with '1': "101010..."
Count swaps needed for each pattern
Return minimum swaps or -1 if impossible

Visualization

Tap to expand

Step-by-Step Walkthrough

Count

Count 0s and 1s in string

Pattern 1

Try "010101..." pattern

Pattern 2

Try "101010..." pattern

Minimum

Return minimum swaps needed

Code -

solution.c — C

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

int countSwaps(char* s, int patternStart) {
    int swaps = 0;
    int len = strlen(s);
    for (int i = 0; i < len; i++) {
        char expected = '0' + (i + patternStart) % 2;
        if (s[i] != expected) {
            swaps++;
        }
    }
    return swaps / 2;
}

int solution(char* s) {
    int n = strlen(s);
    
    // Count 0s and 1s
    int count0 = 0, count1 = 0;
    for (int i = 0; i < n; i++) {
        if (s[i] == '0') count0++;
        else count1++;
    }
    
    // Check if alternating is possible
    if (abs(count0 - count1) > 1) {
        return -1;
    }
    
    int result = INT_MAX;
    
    // Try pattern starting with '0' (if we have enough 0s)
    if (count0 >= count1) {
        int swaps = countSwaps(s, 0);
        if (swaps < result) result = swaps;
    }
    
    // Try pattern starting with '1' (if we have enough 1s)
    if (count1 >= count0) {
        int swaps = countSwaps(s, 1);
        if (swaps < result) result = swaps;
    }
    
    return result == INT_MAX ? -1 : result;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through string to count 0s and 1s, then another pass to count mismatches

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few variables to store counts

⚠ Quadratic Space

25.0K Views

Medium Frequency

~15 min Avg. Time

847 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 — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler