Number of Times Binary String Is Prefix-Aligned

Number of Times Binary String Is Prefix-Aligned - Problem

Array Medium

Imagine you're controlling a row of smart light switches that start in the OFF position. You have a special remote control that can turn ON switches in a specific sequence, but here's the catch: you can't choose which switch to turn on next — the sequence is predetermined!

You start with a binary string of length n where all bits are initially 0 (switches OFF). You're given a 1-indexed array flips where flips[i] tells you which switch position to turn ON during the i-th step.

A configuration is called "prefix-aligned" when, after step i, the first i switches are all ON (positions 1 through i are all 1s) and all remaining switches are OFF (all 0s).

Goal: Count how many times during the entire flipping process the switches become prefix-aligned.

Example: If flips = [3,2,4,1,5] and n = 5:
• Step 1: Turn ON position 3 → 00100 (not prefix-aligned)
• Step 2: Turn ON position 2 → 01100 (not prefix-aligned)
• Step 3: Turn ON position 4 → 01110 (not prefix-aligned)
• Step 4: Turn ON position 1 → 11110 (prefix-aligned! First 4 positions are 1111)
• Step 5: Turn ON position 5 → 11111 (prefix-aligned! All 5 positions are 11111)

Answer: 2 times prefix-aligned.

Input & Output

example_1.py — Basic Case

$ Input: flips = [3,2,4,1,5]

› Output: 2

💡 Note: Step 1: Position 3 → '00100' (not aligned). Step 2: Position 2 → '01100' (not aligned). Step 3: Position 4 → '01110' (not aligned). Step 4: Position 1 → '11110' (aligned! positions 1-4 are all 1s). Step 5: Position 5 → '11111' (aligned! all positions 1-5 are 1s). Total: 2 times.

example_2.py — Sequential Order

$ Input: flips = [1,2,3,4]

› Output: 4

💡 Note: Perfect sequential flipping: Step 1: '1000' (aligned). Step 2: '1100' (aligned). Step 3: '1110' (aligned). Step 4: '1111' (aligned). Every step creates prefix alignment, so answer is 4.

example_3.py — Single Element

$ Input: flips = [1]

› Output: 1

💡 Note: Only one switch to flip. After step 1: position 1 becomes '1', which is perfectly prefix-aligned for step 1. Answer: 1.

Visualization

Tap to expand

Understanding the Visualization

Initial Setup

All 5 stage lights are OFF, sequence is [3,2,4,1,5]

Turn ON Light 3

Pattern: OFF-OFF-ON-OFF-OFF (not consecutive from left)

Turn ON Light 2

Pattern: OFF-ON-ON-OFF-OFF (still not consecutive from left)

Turn ON Light 4

Pattern: OFF-ON-ON-ON-OFF (not consecutive from position 1)

Turn ON Light 1

Pattern: ON-ON-ON-ON-OFF (perfect! First 4 lights consecutive)

Turn ON Light 5

Pattern: ON-ON-ON-ON-ON (perfect! All 5 lights consecutive)

Key Takeaway

🎯 Key Insight: Instead of maintaining the entire light state, just track the rightmost light that's been turned ON. When this equals the step number, you have perfect prefix alignment!

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the flips array, constant time operations per step

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables to track maximum position and counter

✓ Linear Space

Constraints

n == flips.length
1 ≤ n ≤ 5 × 10⁴
flips is a permutation of the integers in the range [1, n]
All flip positions are 1-indexed

Asked in

G Google 25 a Amazon 18 ⊞ Microsoft 12 f Meta 8

The optimal solution uses a maximum position tracking approach with O(n) time and O(1) space. The key insight is that prefix-alignment occurs exactly when the maximum position flipped so far equals the current step number. This eliminates the need to maintain the actual binary array or check each position individually.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Simulate Array)	O(n²)	O(n)	Maintain actual binary array and check prefix condition after each flip
Maximum Position Tracking (Optimal)	O(n)	O(1)	Track maximum flipped position and compare with current step number

Brute Force (Simulate Array) — Algorithm Steps

Initialize binary array of size n with all 0s
For each flip operation, set the specified position to 1
After each flip, check if positions [1...current_step] are all 1s
If yes, increment the prefix-aligned counter
Return the total count

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Create binary array filled with 0s

Flip Bit

Set position flips[i]-1 to 1

Check Prefix

Verify positions 0 to i are all 1s

Check Suffix

Verify positions i+1 to n-1 are all 0s

Code -

solution.c — C

int numTimesAllBlue(int* flips, int flipsSize) {
    int* binaryString = (int*)calloc(flipsSize, sizeof(int));
    int count = 0;
    
    for (int i = 0; i < flipsSize; i++) {
        // Flip the bit (convert to 0-indexed)
        binaryString[flips[i] - 1] = 1;
        
        // Check if prefix-aligned
        int isPrefixAligned = 1;
        
        // Check positions 0 to i should be 1
        for (int j = 0; j <= i; j++) {
            if (binaryString[j] != 1) {
                isPrefixAligned = 0;
                break;
            }
        }
        
        // Check positions i+1 to flipsSize-1 should be 0
        if (isPrefixAligned) {
            for (int j = i + 1; j < flipsSize; j++) {
                if (binaryString[j] != 0) {
                    isPrefixAligned = 0;
                    break;
                }
            }
        }
        
        if (isPrefixAligned) {
            count++;
        }
    }
    
    free(binaryString);
    return count;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n steps, we potentially check up to n positions to verify prefix alignment

⚠ Quadratic Growth

Space Complexity

O(n)

We maintain a binary array of size n to track the current state

⚡ Linearithmic Space

Constraints

n == flips.length
1 ≤ n ≤ 5 × 10⁴
flips is a permutation of the integers in the range [1, n]
All flip positions are 1-indexed

28.5K Views

Medium Frequency

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Simulate Array) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler