Subsets Generation Using Bitmask in DSA C - Time & Space Complexity

Time Complexity: Subsets Generation Using Bitmask

O(n * 2^n)

Understanding Time Complexity

We want to understand how the time needed to generate all subsets grows as the input size increases.

Specifically, how does the number of operations change when we use bitmasking to create subsets?

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

void generateSubsets(int arr[], int n) {
    int total = 1 << n; // 2^n subsets
    for (int mask = 0; mask < total; mask++) {
        for (int i = 0; i < n; i++) {
            if (mask & (1 << i)) {
                // include arr[i] in current subset
            }
        }
    }
}
    

This code generates all subsets of an array by using bitmasking to decide which elements to include.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: The inner loop checks each element for every subset mask.
• How many times: The outer loop runs 2^n times, and the inner loop runs n times for each outer loop.

How Execution Grows With Input

As the input size n grows, the total subsets double each time, and for each subset, we check n elements.

Input Size (n)	Approx. Operations
10	About 10 * 2^10 = 10,240
20	About 20 * 2^20 = 20,971,520
30	About 30 * 2^30 = 32,212,254,720

Pattern observation: The operations grow very fast, doubling with each increase in n, multiplied by n.

Final Time Complexity

Time Complexity: O(n * 2^n)

This means the time needed grows very fast as input size increases, because we generate all subsets and check each element.

Common Mistake

[X] Wrong: "Generating subsets is just O(2^n) because there are 2^n subsets."

[OK] Correct: We also check each element for every subset, so the inner loop adds a factor of n, making it O(n * 2^n).

Interview Connect

Understanding this complexity helps you explain why generating all subsets is expensive and shows your grasp of exponential growth in algorithms.

Self-Check

"What if we only printed subsets of a fixed size k instead of all sizes? How would the time complexity change?"

Practice

1. What does the bitmask technique help to generate when applied to a set of elements?

easy

A. All possible subsets of the set

B. Only the largest subset of the set

C. Only subsets with even number of elements

D. Only subsets with odd number of elements

Solution

1. Step 1: Understand bitmask representation

   Each bit in the bitmask represents whether an element is included (1) or excluded (0) in a subset.

2. Step 2: Generate subsets using bitmask

   By iterating from 0 to 2^n - 1, all combinations of included/excluded elements are covered, producing all subsets.

3. Final Answer:

   All possible subsets of the set -> Option A

4. Quick Check:

   Bitmask = All subsets [OK]

Hint: Bitmask from 0 to 2^n-1 covers all subsets [OK]

Common Mistakes:

• Thinking bitmask generates only largest subsets
• Confusing bitmask with subsets of fixed size
• Assuming bitmask excludes empty subset

2. Which of the following C code snippets correctly initializes the loop to generate all subsets of an array of size n using bitmask?

easy

A. for (int mask = 0; mask < n; mask++)

B. for (int mask = 0; mask < (1 << n); mask++)

C. for (int mask = 0; mask <= n; mask++)

D. for (int mask = 1; mask <= n; mask++)

Solution

1. Step 1: Understand bitmask range

   Bitmask must cover all numbers from 0 to 2^n - 1, which is (1 << n) in C.

2. Step 2: Check loop conditions

   Loop from 0 to less than (1 << n) correctly iterates all subsets.

3. Final Answer:

   for (int mask = 0; mask < (1 << n); mask++) -> Option B

4. Quick Check:

   Loop from 0 to 2^n-1 [OK]

Hint: Use (1 << n) for 2^n in bitmask loops [OK]

Common Mistakes:

• Using mask <= n instead of mask < 2^n
• Starting loop from 1 excludes empty subset
• Using mask < n only covers n subsets

3. What is the output of the following C code snippet?

int arr[] = {1, 2};
int n = 2;
for (int mask = 0; mask < (1 << n); mask++) {
    printf("{");
    for (int i = 0; i < n; i++) {
        if (mask & (1 << i)) {
            printf("%d", arr[i]);
        }
    }
    printf("}\n");
}

medium

A. {}
{1}
{2}
{1, 2}

B. {}
{1}
{2}
{1 2}

C. {}
{1}
{2}
{12}

D. {}
{1}
{2}
{1}{2}

Solution

1. Step 1: Understand bitmask iterations

   mask goes from 0 to 3 (binary 00 to 11), representing subsets: empty, {1}, {2}, {1,2}.

2. Step 2: Trace output formatting

   Elements printed without spaces or commas, so subsets print as {}, {1}, {2}, {12}.

3. Final Answer:

   {} {1} {2} {12} -> Option C

4. Quick Check:

   Bitmask subsets printed without separators [OK]

Hint: Check print format carefully for separators [OK]

Common Mistakes:

• Assuming spaces or commas between elements
• Confusing bitmask order of elements
• Missing empty subset output

4. Identify the error in the following C code that attempts to generate subsets using bitmask:

int arr[] = {1, 2, 3};
int n = 3;
for (int mask = 0; mask <= (1 << n); mask++) {
    for (int i = 0; i < n; i++) {
        if (mask & (1 << i)) {
            printf("%d ", arr[i]);
        }
    }
    printf("\n");
}

medium

A. Loop condition should be mask < (1 << n), not <=

B. Bitwise AND operator is incorrect

C. Loop should start from 0 to include empty subset

D. Array indexing is out of bounds

Solution

1. Step 1: Check loop range correctness

   Loop runs from 0 to (1 << n) inclusive, which is 0 to 8 for n=3, but max mask should be 7 (0 to 7).

2. Step 2: Identify off-by-one error

   Using mask <= (1 << n) causes mask=8, which is out of valid subset range, causing incorrect behavior.

3. Final Answer:

   Loop condition should be mask < (1 << n), not <= -> Option A

4. Quick Check:

   Loop must run from 0 to 2^n - 1 [OK]

Hint: Use mask < (1 << n), not <= [OK]

Common Mistakes:

• Starting loop from 1 excludes empty subset
• Using <= causes out-of-range mask
• Misunderstanding bitwise AND usage

5. Given an array arr = {1, 2, 3, 4}, how many subsets generated by bitmask will have exactly two elements?

medium

A. 12

B. 4

C. 8

D. 6

Solution

1. Step 1: Calculate total subsets of size 2

   Number of subsets with exactly 2 elements from 4 elements is combination 4 choose 2 = 6.

2. Step 2: Understand bitmask filtering

   Among all 2^4=16 subsets, exactly 6 have two bits set in their bitmask representing two elements included.

3. Final Answer:

   6 -> Option D

4. Quick Check:

   Combination(4,2) = 6 [OK]

Hint: Count subsets with 2 bits set = C(n,2) [OK]

Common Mistakes:

• Counting total subsets instead of size 2
• Confusing subsets with permutations
• Miscounting bitmask bits set