Minimum Suffix Flips - Practice Coding Problems

Minimum Suffix Flips - Problem

String Greedy Medium

You have a binary transformation game! You're given a target binary string that you need to match, but you start with a string of all zeros of the same length.

The twist? You can only perform suffix flips - choose any position i and flip all bits from position i to the end of the string. When you flip, all '0's become '1's and all '1's become '0's in that range.

Goal: Find the minimum number of operations to transform your all-zeros string into the target string.

Example: If target = "10", start with "00":
1. Flip from index 1: "00" → "01"
2. Flip from index 0: "01" → "10"
Answer: 2 operations

Input & Output

example_1.py — Basic Case

$ Input: target = "10"

› Output: 2

💡 Note: Start with "00". First flip from index 1: "00" → "01". Then flip from index 0: "01" → "10". Total: 2 operations.

example_2.py — Longer String

$ Input: target = "101"

› Output: 3

💡 Note: Start with "000". Flip from index 2: "000" → "001". Flip from index 1: "001" → "010". Flip from index 0: "010" → "101". Total: 3 operations.

example_3.py — All Zeros

$ Input: target = "00"

› Output: 0

💡 Note: Start with "00" which already matches target "00". No operations needed.

Constraints

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

Visualization

Tap to expand

Understanding the Visualization

Start Position

All switches are OFF (000), target is 101

Rightmost Check

Position 2: current=0, target=1, need to flip!

Middle Check

Position 1: current=0, target=0, matches!

Leftmost Check

Position 0: current=0, target=1, need to flip!

Key Takeaway

🎯 Key Insight: Work backwards! Each position can only be fixed by flipping from that exact position, making the greedy approach optimal.

Asked in

G Google 42 a Amazon 38 f Meta 25 ⊞ Microsoft 18

The optimal approach uses a greedy strategy working from right to left. The key insight is that we can only fix a mismatched bit at position i by flipping from that exact position. This gives us an O(n) time and O(1) space solution.

Common Approaches

Approach	Time	Space	Notes
✓ Greedy Approach (Optimal)	O(n)	O(1)	Work from right to left, flipping only when current bit doesn't match target
Brute Force (Try All Sequences)	O(2^n)	O(n)	Try all possible sequences of operations using recursion

Greedy Approach (Optimal) — Algorithm Steps

Start from the rightmost position and work backwards
Compare current string state with target at each position
If bits don't match, flip from current position and increment counter
Continue until we reach the leftmost position
Return total number of flips needed

Visualization

Tap to expand

Step-by-Step Walkthrough

Start Right

Begin from rightmost bit, compare with target

Check Match

If current bit matches target, move left

Flip if Needed

If mismatch, flip from current position

Update State

Track whether we're in flipped state

Code -

solution.c — C

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

int minFlips(char* target) {
    int n = strlen(target);
    int flips = 0;
    int currentState = 0; // 0 means original, 1 means flipped
    
    // Work backwards from right to left
    for (int i = n - 1; i >= 0; i--) {
        // What should current bit be in our string?
        int currentBit = currentState;
        // What does target want at this position?
        int targetBit = target[i] - '0';
        
        // If they don't match, we need to flip from position i
        if (currentBit != targetBit) {
            flips++;
            currentState = 1 - currentState; // Toggle state
        }
    }
    
    return flips;
}

int main() {
    char target[100001];
    scanf("%s", target);
    // Remove quotes if present
    char* clean = target;
    if (target[0] == '"') clean = target + 1;
    int len = strlen(clean);
    if (clean[len-1] == '"') clean[len-1] = '\0';
    printf("%d\n", minFlips(clean));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the string from right to left

✓ Linear Growth

Space Complexity

O(1)

Only using a counter variable and tracking current state

✓ Linear Space

28.5K Views

Medium Frequency

~15 min Avg. Time

850 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 Approach (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler