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. You are allowed to perform two types of operations on the string in any sequence:

Type-1: Remove the character at the start of the string s and append it to the end of the string.

Type-2: Pick any character in s and flip its value, i.e., if its value is '0' it becomes '1' and vice-versa.

Return the minimum number of type-2 operations you need to perform such that s becomes alternating.

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.

Input & Output

Example 1 — Basic Case

$ Input: s = "11000"

› Output: 1

💡 Note: We can rotate to get "00011" or "01100", then flip 1 character to make it alternating like "01010" or "10101".

Example 2 — Already Alternating After Rotation

$ Input: s = "10"

› Output: 0

💡 Note: The string is already alternating, so no type-2 operations (flips) are needed.

Example 3 — Single Character

$ Input: s = "1"

› Output: 0

💡 Note: A single character is always alternating by definition.

Constraints

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

Visualization

Tap to expand

Asked in

M Meta 15 G Google 12 M Microsoft 8

The key insight is that we can rotate the string to any position and then count flips needed for alternating patterns. The optimal approach uses incremental cost updates when simulating rotations, achieving O(n) time complexity instead of O(n²).

Common Approaches

✓ Brute Force - Try All Rotations

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

For each possible rotation (0 to n-1), simulate the rotation and count how many flips are needed to make it alternating. Since there are two possible alternating patterns (starting with 0 or 1), check both.

Optimized with Precomputation

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

Pre-calculate the cost of making the original string alternating for both patterns. Then use the insight that when we rotate left by one position, we can update the cost by removing the effect of the first character and adding the effect at the end.

Sliding Window Optimization

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

Instead of creating actual rotated strings, we can simulate rotations by treating the string as circular. We double the string and use a sliding window of size n to represent each rotation, calculating flip costs efficiently.

Brute Force - Try All Rotations — Algorithm Steps

For each rotation position i from 0 to n-1
Create rotated string by moving first i characters to end
Check cost to make it alternating starting with '0'
Check cost to make it alternating starting with '1'
Take minimum of both patterns

Visualization

Tap to expand

Step-by-Step Walkthrough

Original String

Start with given binary string

Try Rotations

Test each rotation position

Count Flips

For each rotation, count flips needed for alternating pattern

Code -

solution.c — C

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

int solution(char* s) {
    int n = strlen(s);
    int minFlips = INT_MAX;
    char rotated[1001];
    
    for (int rotation = 0; rotation < n; rotation++) {
        // Create rotated string
        strcpy(rotated, s + rotation);
        strncat(rotated, s, rotation);
        rotated[n] = '\0';
        
        // Try pattern starting with '0'
        int flips0 = 0;
        for (int i = 0; i < n; i++) {
            char expected = i % 2 == 0 ? '0' : '1';
            if (rotated[i] != expected) {
                flips0++;
            }
        }
        
        // Try pattern starting with '1'
        int flips1 = 0;
        for (int i = 0; i < n; i++) {
            char expected = i % 2 == 0 ? '1' : '0';
            if (rotated[i] != expected) {
                flips1++;
            }
        }
        
        if (flips0 < minFlips) minFlips = flips0;
        if (flips1 < minFlips) minFlips = flips1;
    }
    
    return minFlips;
}

int main() {
    char s[1001];
    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²)

For each of n rotations, we scan the entire string of length n

⚠ Quadratic Growth

Space Complexity

O(n)

Creating rotated string copies requires O(n) space

⚡ Linearithmic Space

28.4K Views

Medium Frequency

~25 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 Rotations — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler