Subsets Generation Using Bitmask in DSA C - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to calculate the total number of subsets for a set of size n.

DSA C

int total_subsets = 1 << [1];

Drag options to blanks, or click blank then click option'

An

Bsize

Ccount

Dlength

Attempts:

3 left

💡 Hint

Common Mistakes

Using the wrong variable name instead of n.

Using multiplication instead of bit shift.

Using bit shift operator 1 << n calculates 2^n, which is the total number of subsets.

2fill in blank

medium

Complete the for loop to iterate over all subsets represented by bitmasks.

DSA C

for (int mask = 0; mask < (1 << n); mask[1]) {

Drag options to blanks, or click blank then click option'

A+=

B--

C++

D*=

Attempts:

3 left

💡 Hint

Common Mistakes

Using decrement operator which causes an infinite loop.

Using multiplication or addition incorrectly.

The loop increments mask by 1 each time to cover all subsets from 0 to 2^n - 1.

3fill in blank

hard

Fix the error in the condition to check if the j-th element is included in the current subset mask.

DSA C

if (mask & (1 [1] j)) {

Drag options to blanks, or click blank then click option'

A>>

B<<

C&

D|

Attempts:

3 left

💡 Hint

Common Mistakes

Using right shift instead of left shift.

Using bitwise OR or AND incorrectly.

To check if the j-th bit is set, shift 1 left by j positions and bitwise AND with mask.

4fill in blank

hard

Fill both blanks to print all elements of the current subset represented by mask.

DSA C

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

Drag options to blanks, or click blank then click option'

A<

B<=

C++

D--

Attempts:

3 left

💡 Hint

Common Mistakes

Using <= instead of < causing out-of-bounds access.

Using decrement operator causing infinite loop.

The loop runs from j = 0 up to j < n, incrementing j each time to check all elements.

5fill in blank

hard

Fill all three blanks to create a function that generates all subsets of an array using bitmask.

DSA C

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

Drag options to blanks, or click blank then click option'

A<<

B<

C++

D<=

Attempts:

3 left

💡 Hint

Common Mistakes

Using <= in loop conditions causing out-of-bounds errors.

Using wrong bit shift direction.

Not incrementing loop variables properly.

Use bit shift to calculate total subsets, loop mask from 0 to total-1, and increment j to check each element.

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