Minimum Number of Flips to Make the Binary String Alternating

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

You are given a binary string s and need to transform it into an alternating pattern using the minimum number of flips.

Two operations are allowed:

Type-1 (Rotate): Remove the first character and append it to the end
Type-2 (Flip): Change any '0' to '1' or '1' to '0'

An alternating string has no two adjacent characters that are the same. Examples: "010", "1010", "10101"

Goal: Find the minimum number of Type-2 operations (flips) needed after performing any number of Type-1 operations (rotations) to make the string alternating.

Example: For s = "111000", we can rotate to get "110001", then flip 2 characters to get "101010" (alternating).

Input & Output

example_1.py — Basic Case

$ Input: s = "111000"

› Output: 2

💡 Note: We can rotate to position 2 to get "100011", then flip 2 characters to make "101010" (alternating pattern starting with '1'). This gives us the minimum number of flips needed.

example_2.py — Already Alternating After Rotation

$ Input: s = "010"

› Output: 0

💡 Note: The string is already alternating, so no flips are needed. We can achieve this with 0 rotations and 0 flips.

example_3.py — Single Character

$ Input: s = "1"

› Output: 0

💡 Note: A single character is always alternating by definition, so no flips are needed regardless of rotations.

Visualization

Tap to expand

Understanding the Visualization

Original Necklace

We start with a necklace that may not follow the alternating pattern

Try Different Starting Points

We can rotate the necklace to start from any bead position

Count Repainting Needed

For each starting position, count how many beads need color changes

Find Optimal Solution

Choose the starting position that requires minimum repainting

Key Takeaway

🎯 Key Insight: By using a sliding window on the doubled string, we can efficiently examine all possible rotations and find the optimal starting position that minimizes the number of flips needed to create an alternating pattern.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the doubled string with sliding window

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables to track counts and minimum

✓ Linear Space

Constraints

1 ≤ s.length ≤ 10⁵
s[i] is either '0' or '1'
Time limit: 1 second per test case

Asked in

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

The optimal solution uses a sliding window technique on a doubled string to efficiently simulate all possible rotations. By creating s + s, we can examine all rotations in O(n) time without actually rotating the string multiple times. For each rotation, we count the flips needed for both alternating patterns ('010...' and '101...') and return the minimum across all possibilities.

Common Approaches

Approach	Time	Space	Notes
✓ Sliding Window (Optimal)	O(n)	O(1)	Use sliding window on doubled string to simulate all rotations efficiently
Brute Force (Try All Rotations)	O(n²)	O(n)	Try every possible rotation and count flips needed for each

Sliding Window (Optimal) — Algorithm Steps

Double the string: s + s to simulate all rotations
Use sliding window of size n to examine each possible rotation
For each window position, count flips needed for both alternating patterns
Track minimum flips across all windows (rotations)

Visualization

Tap to expand

Step-by-Step Walkthrough

Double the String

Create s + s to contain all possible rotations

Slide Window

Move window of size n across doubled string

Count Flips

For each window position, count flips for both patterns

Track Minimum

Keep track of minimum flips found

Code -

solution.c — C

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

int minFlips(char* s) {
    int n = strlen(s);
    if (n == 1) return 0;
    
    char doubled[2001];
    strcpy(doubled, s);
    strcat(doubled, s);
    
    int min_flips = INT_MAX;
    
    // For each starting position (rotation)
    for (int start = 0; start < n; start++) {
        int flips_pattern0 = 0;  // Pattern starting with '0'
        int flips_pattern1 = 0;  // Pattern starting with '1'
        
        for (int i = 0; i < n; i++) {
            char ch = doubled[start + i];
            char expected0 = i % 2 == 0 ? '0' : '1';
            char expected1 = i % 2 == 0 ? '1' : '0';
            
            if (ch != expected0) flips_pattern0++;
            if (ch != expected1) flips_pattern1++;
        }
        
        if (flips_pattern0 < min_flips) {
            min_flips = flips_pattern0;
        }
        if (flips_pattern1 < min_flips) {
            min_flips = flips_pattern1;
        }
    }
    
    return min_flips;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the doubled string with sliding window

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables to track counts and minimum

✓ Linear Space

Constraints

1 ≤ s.length ≤ 10⁵
s[i] is either '0' or '1'
Time limit: 1 second per test case

26.0K Views

Medium Frequency

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Sliding Window (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler