Number of Times Binary String Is Prefix-Aligned

Number of Times Binary String Is Prefix-Aligned - Problem

Array Medium

You have a 1-indexed binary string of length n where all the bits are 0 initially. We will flip all the bits of this binary string (i.e., change them from 0 to 1) one by one.

You are given a 1-indexed integer array flips where flips[i] indicates that the bit at index flips[i] will be flipped in the ith step.

A binary string is prefix-aligned if, after the ith step, all the bits in the inclusive range [1, i] are ones and all the other bits are zeros.

Return the number of times the binary string is prefix-aligned during the flipping process.

Input & Output

Example 1 — Basic Case

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

› Output: 2

💡 Note: Step 1: flip bit 3 → [0,0,1,0,0], max=3≠1. Step 2: flip bit 2 → [0,1,1,0,0], max=3≠2. Step 3: flip bit 4 → [0,1,1,1,0], max=4≠3. Step 4: flip bit 1 → [1,1,1,1,0], max=4=4 ✓. Step 5: flip bit 5 → [1,1,1,1,1], max=5=5 ✓. 2 prefix-aligned states.

Example 2 — Sequential Order

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

› Output: 3

💡 Note: Step 1: flip bit 1 → [1,0,0], max=1=1 ✓. Step 2: flip bit 2 → [1,1,0], max=2=2 ✓. Step 3: flip bit 3 → [1,1,1], max=3=3 ✓. All steps are prefix-aligned.

Example 3 — Reverse Order

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

› Output: 1

💡 Note: Step 1: flip bit 4 → [0,0,0,1], max=4≠1. Step 2: flip bit 3 → [0,0,1,1], max=4≠2. Step 3: flip bit 2 → [0,1,1,1], max=4≠3. Step 4: flip bit 1 → [1,1,1,1], max=4=4 ✓. Only the last step is prefix-aligned.

Constraints

1 ≤ flips.length ≤ 3 × 10⁴
flips is a permutation of the range [1, n]

Visualization

Tap to expand

Asked in

G Google 15 f Facebook 12

Brief HTML summary: The key insight is that a binary string is prefix-aligned after step i if and only if the maximum position flipped so far equals i. Best approach is tracking maximum position in O(n) time with O(1) space, avoiding redundant prefix checking.

Common Approaches

✓ Simulate and Check Every Step

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

For each flip operation, update the binary string and then check if positions [1, i] are all ones. This requires checking the entire prefix pattern after every flip.

Track Maximum Position

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

Instead of checking the entire prefix every time, we observe that a string is prefix-aligned after step i if and only if the maximum position flipped so far equals i. This eliminates redundant checking.

Simulate and Check Every Step — Algorithm Steps

Step 1: Initialize binary array with all zeros
Step 2: For each flip, set the bit to 1
Step 3: Check if positions [1, current_step] are all ones
Step 4: Count valid prefix-aligned states

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Start with all zeros

Flip & Check

After each flip, verify prefix pattern

Count

Increment when prefix is aligned

Code -

solution.c — C

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

int solution(int* flips, int n) {
    int* bits = (int*)calloc(n + 1, sizeof(int)); // 1-indexed
    int count = 0;
    
    for (int i = 0; i < n; i++) {
        // Flip the bit at position flips[i]
        bits[flips[i]] = 1;
        
        // Check if positions [1, i+1] are all ones
        int isPrefixAligned = 1;
        for (int j = 1; j <= i + 1; j++) {
            if (bits[j] != 1) {
                isPrefixAligned = 0;
                break;
            }
        }
        
        if (isPrefixAligned) {
            count++;
        }
    }
    
    free(bits);
    return count;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Simple parsing for array
    int flips[1000];
    int n = 0;
    char* token = strtok(line + 1, ",]");
    while (token != NULL) {
        flips[n++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    int result = solution(flips, n);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

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

⚠ Quadratic Growth

Space Complexity

O(n)

Binary array to track flipped positions

⚡ Linearithmic Space

12.0K Views

Medium Frequency

~15 min Avg. Time

456 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

Simulate and Check Every Step — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler