Subsets Generation Using Bitmask in DSA Typescript - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is the main idea behind generating subsets using bitmask?

Each subset can be represented by a binary number where each bit indicates whether an element is included (1) or excluded (0) from the subset.

beginner

How many subsets does a set with n elements have?

A set with n elements has 2^n subsets, including the empty set and the set itself.

beginner

In bitmask subset generation, what does the bit at position i represent?

The bit at position i represents whether the element at index i in the original set is included (1) or excluded (0) in the current subset.

intermediate

Why is bitmasking an efficient way to generate all subsets?

Because it uses simple binary counting from 0 to 2^n - 1, allowing direct mapping of bits to element inclusion without recursion or extra data structures.

intermediate

What is the time complexity of generating all subsets using bitmask for a set of size n?

The time complexity is O(n * 2^n) because there are 2^n subsets and each subset can take up to n steps to build.

How many subsets will be generated for a set with 3 elements using bitmask?

A 8

B 6

C 3

D 9

A set with 3 elements has 2^3 = 8 subsets.

In bitmask subset generation, what does the bit value 0 at position i mean?

A Exclude the element at index i

B Repeat the element at index i

C Toggle the element at index i

D Include the element at index i

Bit value 0 means the element at index i is excluded from the subset.

Which of the following is NOT a benefit of using bitmask for subset generation?

A Directly maps bits to element inclusion

B Uses binary counting

C Avoids recursion

D Generates subsets in sorted order by size

Bitmask generates subsets in binary order, not necessarily sorted by subset size.

What is the maximum bitmask value for a set of size 4?

A 16

B 15

C 8

D 4

Maximum bitmask is 2^4 - 1 = 15 (binary 1111).

If the bitmask is 5 (binary 0101) for a set [a, b, c, d], which elements are included?

A a and d

B b and d

C a and c

D b and c

Binary 0101 means bits 0 and 2 are set, so elements at index 0 (a) and 2 (c) are included.

Explain how bitmasking helps generate all subsets of a set.

Think about how binary numbers can represent yes/no choices for each element.

Describe the steps to generate subsets using bitmask for a set of size n.

Focus on the loop and bit checking process.

Practice

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

easy

A. Only the largest subset

B. Only subsets with odd number of elements

C. Only subsets with even number of elements

D. All possible subsets of the set

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 through all bitmasks from 0 to 2^n - 1, we cover all combinations of elements, thus all subsets.

3. Final Answer:

   All possible subsets of the set -> Option D

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 even or odd subsets
• Confusing subsets with permutations
• Assuming bitmask generates only largest subsets

2. Which of the following TypeScript code snippets correctly initializes the bitmask loop for generating subsets of an array arr of length n?

easy

A. for (let mask = 0; mask <= n; mask++) {}

B. for (let mask = 1; mask <= n; mask++) {}

C. for (let mask = 0; mask < (1 << n); mask++) {}

D. for (let mask = 0; 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 code.

2. Step 2: Check loop correctness

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

3. Final Answer:

   for (let mask = 0; mask < (1 << n); mask++) {} -> Option C

4. Quick Check:

   Loop 0 to 2^n-1 = for (let mask = 0; mask < (1 << n); mask++) {} [OK]

Hint: Use (1 << n) for total subsets count [OK]

Common Mistakes:

• Using mask <= n instead of mask < 2^n
• Starting loop from 1 misses empty subset
• Using mask < n only covers single elements

3. What is the output of the following TypeScript code?

const arr = ["a", "b", "c"];
const subsets: string[][] = [];
const n = arr.length;
for (let mask = 0; mask < (1 << n); mask++) {
  const subset: string[] = [];
  for (let i = 0; i < n; i++) {
    if ((mask & (1 << i)) !== 0) {
      subset.push(arr[i]);
    }
  }
  subsets.push(subset);
}
console.log(subsets);

medium

A. [["a"], ["b", "a"], ["c", "b"], ["a", "b", "c"]]

B. [[], ["a"], ["b"], ["a", "b"], ["c"], ["a", "c"], ["b", "c"], ["a", "b", "c"]]

C. [[], ["a", "b", "c"]]

D. [["a"], ["b"], ["c"]]

Solution

1. Step 1: Understand bitmask iteration

   Loop runs from 0 to 7 (2^3 - 1), generating all subsets of 3 elements.

2. Step 2: Trace subsets generated

   Each mask selects elements where bit is set, producing all subsets including empty and full set.

3. Final Answer:

   [[], ["a"], ["b"], ["a", "b"], ["c"], ["a", "c"], ["b", "c"], ["a", "b", "c"]] -> Option B

4. Quick Check:

   All subsets of 3 elements = [[], ["a"], ["b"], ["a", "b"], ["c"], ["a", "c"], ["b", "c"], ["a", "b", "c"]] [OK]

Hint: Bitmask 0 to 7 covers all subsets of 3 elements [OK]

Common Mistakes:

• Missing empty subset []
• Incorrect order or missing subsets
• Confusing subsets with permutations

4. Identify the error in this TypeScript code for generating subsets using bitmask:

const arr = [1, 2, 3];
const n = arr.length;
for (let mask = 0; mask <= (1 << n); mask++) {
  const subset = [];
  for (let i = 0; i < n; i++) {
    if (mask & (1 << i)) {
      subset.push(arr[i]);
    }
  }
  console.log(subset);
}

medium

A. The outer loop should run while mask < (1 << n), not <=

B. The inner loop should run from i = 1 to n

C. The bitwise AND condition should be == 0 instead of truthy check

D. The subset array should be declared outside the loops

Solution

1. Step 1: Check outer loop range

   Loop runs from 0 to (1 << n) inclusive, which is one too many iterations (should be less than).

2. Step 2: Understand consequences

   When mask equals (1 << n), it exceeds the maximum bitmask for subsets, causing an extra invalid iteration.

3. Final Answer:

   The outer loop should run while mask < (1 << n), not <= -> Option A

4. Quick Check:

   Loop limit off by one = The outer loop should run while mask < (1 << n), not <= [OK]

Hint: Use mask < 2^n, not <= 2^n [OK]

Common Mistakes:

• Using <= instead of < in loop condition
• Changing inner loop range incorrectly
• Misusing bitwise condition checks

5. Given an array arr = [1, 2, 2], which code modification correctly generates all unique subsets using bitmask technique?

hard

A. Use a Set to store stringified subsets to avoid duplicates

B. Sort the array and skip adding duplicates inside inner loop

C. Increase bitmask range to (1 << (n+1)) to cover duplicates

D. No modification needed; bitmask handles duplicates automatically

Solution

1. Step 1: Understand duplicates in subsets

   Bitmask generates subsets by position, so duplicates in array cause duplicate subsets.

2. Step 2: Avoid duplicates using a Set

   Storing subsets as strings in a Set removes duplicates by keeping only unique subsets.

3. Final Answer:

   Use a Set to store stringified subsets to avoid duplicates -> Option A

4. Quick Check:

   Set removes duplicate subsets [OK]

Hint: Use Set to filter duplicate subsets from duplicates in array [OK]

Common Mistakes:

• Assuming bitmask alone removes duplicates
• Increasing bitmask range unnecessarily
• Trying to skip duplicates without sorting or tracking