Design Bitset - Practice Coding Problems

Design Bitset - Problem

Design a Bitset Data Structure

A Bitset is a memory-efficient data structure that stores a collection of bits (0s and 1s). Think of it as a compact array of boolean values where each position can be either on (1) or off (0).

Your task is to implement a Bitset class that supports the following operations:

Bitset(int size) - Initialize with size bits, all set to 0
void fix(int idx) - Set the bit at index idx to 1
void unfix(int idx) - Set the bit at index idx to 0
void flip() - Flip all bits (0→1, 1→0)
boolean all() - Check if all bits are 1
boolean one() - Check if at least one bit is 1
int count() - Count how many bits are 1
String toString() - Return string representation

Challenge: The flip() operation should be efficient even for large bitsets!

Input & Output

example_1.py — Basic Operations

$ Input: ["Bitset", "fix", "fix", "flip", "all", "unfix", "flip", "one", "unfix", "count", "toString"] [[5], [3], [1], [], [], [0], [], [], [0], [], []]

› Output: [null, null, null, null, false, null, null, true, null, 4, "11011"]

💡 Note: Initialize bitset of size 5: "00000" → fix(3): "00010" → fix(1): "01010" → flip(): "10101" → all(): false (not all 1s) → unfix(0): "00101" → flip(): "11010" → one(): true (has 1s) → unfix(0): "01010" → count(): 3 ones → toString(): "01010"

example_2.py — Flip Performance

$ Input: ["Bitset", "flip", "flip", "fix", "flip", "count"] [[3], [], [], [1], [], []]

› Output: [null, null, null, null, null, 2]

💡 Note: Initialize: "000" → flip(): "111" → flip(): "000" → fix(1): "010" → flip(): "101" → count(): 2 ones. Shows how multiple flips are handled efficiently.

example_3.py — Edge Case Single Bit

$ Input: ["Bitset", "fix", "all", "flip", "all", "toString"] [[1], [0], [], [], [], []]

› Output: [null, null, true, null, false, "0"]

💡 Note: Single bit bitset: Initialize "0" → fix(0): "1" → all(): true → flip(): "0" → all(): false → toString(): "0"

Visualization

Tap to expand

Understanding the Visualization

Initialize

Start with all lights off (bits = 0) and normal mode (flipped = false)

Fix/Unfix

Manually change individual switches, accounting for current building mode

Flip

Instead of changing every switch, just toggle the building mode

Query

To check actual light status, apply building mode to switch positions

Key Takeaway

🎯 Key Insight: The lazy flip optimization transforms an O(n) operation into O(1) by changing how we interpret data rather than modifying it directly

Time & Space Complexity

Time Complexity

⏱️

O(1) for all operations

Flip is O(1) due to lazy evaluation, queries use cached count

✓ Linear Growth

Space Complexity

O(n)

Still need O(n) space for bits plus O(1) for flip flag and counters

⚡ Linearithmic Space

Constraints

1 ≤ size ≤ 10⁵
0 ≤ idx < size
At most 10⁵ calls will be made to fix, unfix, flip, all, one, count, and toString
Performance requirement: flip() should be efficient for large bitsets

Asked in

G Google 42 f Meta 35 ⊞ Microsoft 28 a Amazon 22

The optimal solution uses a flip flag with lazy evaluation to achieve O(1) time complexity for all operations. Instead of actually flipping all bits during flip(), we maintain a boolean flag and interpret bit values dynamically using XOR. This approach also maintains a count of ones to optimize query operations, making it perfect for scenarios with frequent flip operations.

Common Approaches

Approach	Time	Space	Notes
✓ Direct Array Implementation	O(n) for flip, O(1) for others except count/all/one which are O(n)	O(n)	Store bits in an array and perform all operations directly
Optimized with Flip Flag (Optimal)	O(1) for all operations	O(n)	Use a flip flag to make flip operation O(1) through lazy evaluation

Direct Array Implementation — Algorithm Steps

Initialize an array of size n with all zeros
For fix/unfix, directly modify the array at given index
For flip, iterate through entire array and flip each bit
For queries, iterate through array to count or check conditions
Maintain the array in its actual state at all times

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Create array of zeros

Fix/Unfix

Directly modify specific indices

Flip

Iterate through entire array flipping each bit

Query

Scan array to compute result

Code -

solution.c — C

typedef struct {
    int* bits;
    int size;
} Bitset;

Bitset* bitsetCreate(int size) {
    Bitset* obj = (Bitset*)malloc(sizeof(Bitset));
    obj->bits = (int*)calloc(size, sizeof(int));
    obj->size = size;
    return obj;
}

void bitsetFix(Bitset* obj, int idx) {
    obj->bits[idx] = 1;
}

void bitsetUnfix(Bitset* obj, int idx) {
    obj->bits[idx] = 0;
}

void bitsetFlip(Bitset* obj) {
    for (int i = 0; i < obj->size; i++) {
        obj->bits[i] = 1 - obj->bits[i];
    }
}

bool bitsetAll(Bitset* obj) {
    for (int i = 0; i < obj->size; i++) {
        if (obj->bits[i] != 1) return false;
    }
    return true;
}

bool bitsetOne(Bitset* obj) {
    for (int i = 0; i < obj->size; i++) {
        if (obj->bits[i] == 1) return true;
    }
    return false;
}

int bitsetCount(Bitset* obj) {
    int count = 0;
    for (int i = 0; i < obj->size; i++) {
        count += obj->bits[i];
    }
    return count;
}

char* bitsetToString(Bitset* obj) {
    char* result = (char*)malloc((obj->size + 1) * sizeof(char));
    for (int i = 0; i < obj->size; i++) {
        result[i] = '0' + obj->bits[i];
    }
    result[obj->size] = '\0';
    return result;
}

void bitsetFree(Bitset* obj) {
    free(obj->bits);
    free(obj);
}

Time & Space Complexity

Time Complexity

⏱️

O(n) for flip, O(1) for others except count/all/one which are O(n)

Flip requires updating every bit, queries need to scan entire array

✓ Linear Growth

Space Complexity

O(n)

Need to store n bits plus some auxiliary variables

⚡ Linearithmic Space

Constraints

1 ≤ size ≤ 10⁵
0 ≤ idx < size
At most 10⁵ calls will be made to fix, unfix, flip, all, one, count, and toString
Performance requirement: flip() should be efficient for large bitsets

28.4K Views

Medium-High Frequency

~25 min Avg. Time

856 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

Direct Array Implementation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler