Generate All Subsets Powerset in DSA Typescript - Time & Space Complexity

Time Complexity: Generate All Subsets Powerset

O(n * 2^n)

Understanding Time Complexity

We want to understand how the time needed grows when we find all subsets of a set.

How does the work increase as the input set gets bigger?

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

function generateSubsets(nums: number[]): number[][] {
  const result: number[][] = [];
  function backtrack(start: number, subset: number[]) {
    result.push([...subset]);
    for (let i = start; i < nums.length; i++) {
      subset.push(nums[i]);
      backtrack(i + 1, subset);
      subset.pop();
    }
  }
  backtrack(0, []);
  return result;
}
    

This code finds all subsets (the powerset) of the input array by exploring choices recursively.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: Recursive calls that explore each subset possibility.
• How many times: Each element can be either included or excluded, so about 2ⁿ subsets are generated.

How Execution Grows With Input

As the input size grows, the number of subsets doubles for each new element.

Input Size (n)	Approx. Operations
10	About 1,024 subsets
20	About 1,048,576 subsets
30	About 1,073,741,824 subsets

Pattern observation: The work doubles with each added element, growing very fast.

Final Time Complexity

Time Complexity: O(n * 2n)

This means the time grows very fast because we must build all subsets, and each subset can take up to n steps to copy.

Common Mistake

[X] Wrong: "Generating all subsets is just O(n) because we just loop through the array once."

[OK] Correct: We actually explore every combination of elements, which grows exponentially, not linearly.

Interview Connect

Understanding this exponential growth helps you explain why some problems take longer and shows you can reason about complex recursive solutions.

Self-Check

"What if we only wanted subsets of a fixed size k? How would the time complexity change?"

Practice

1. What does the term powerset mean in the context of sets?

easy

A. All possible subsets of a given set, including empty and full set

B. Only the subsets with exactly half the elements of the set

C. The set of elements that are not in the original set

D. The set containing only the largest element of the original set

Solution

1. Step 1: Understand the definition of powerset

   The powerset of a set is the collection of all subsets, including the empty set and the set itself.

2. Step 2: Compare options with definition

   All possible subsets of a given set, including empty and full set correctly describes all subsets, while others describe partial or unrelated sets.

3. Final Answer:

   All possible subsets of a given set, including empty and full set -> Option A

4. Quick Check:

   powerset = all subsets [OK]

Hint: Remember powerset means every subset possible [OK]

Common Mistakes:

• Thinking powerset excludes empty set
• Confusing powerset with complement set
• Assuming powerset only has subsets of certain size

2. Which of the following TypeScript function signatures correctly represents a function that generates all subsets of an array of numbers?

easy

A. function generateSubsets(nums: number[][]): number[]

B. function generateSubsets(nums: number): number[]

C. function generateSubsets(nums: string[]): string

D. function generateSubsets(nums: number[]): number[][]

Solution

1. Step 1: Analyze the input and output types

   The input is an array of numbers, so nums: number[] is correct. The output is all subsets, so an array of arrays of numbers number[][] is expected.

2. Step 2: Match options with correct types

   function generateSubsets(nums: number[]): number[][] matches input and output types correctly. Others have mismatched types or wrong return types.

3. Final Answer:

   function generateSubsets(nums: number[]): number[][] -> Option D

4. Quick Check:

   Input array, output array of arrays [OK]

Hint: Input array, output array of arrays for subsets [OK]

Common Mistakes:

• Returning a flat array instead of array of arrays
• Using wrong input type like number instead of number[]
• Returning a string instead of array

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

function subsets(nums: number[]): number[][] {
  const result: number[][] = [[]];
  for (const num of nums) {
    const newSubsets = result.map(subset => [...subset, num]);
    result.push(...newSubsets);
  }
  return result;
}

console.log(subsets([1, 2]));

medium

A. [[], [1], [2], [1, 2]]

B. [[1], [2], [1, 2]]

C. [[], [1, 2]]

D. [[], [1], [2]]

Solution

1. Step 1: Trace the initial state and loop

   Start with result = [[]]. For num=1, newSubsets = [[1]], result becomes [[], [1]]. For num=2, newSubsets = [[2], [1, 2]], result becomes [[], [1], [2], [1, 2]].

2. Step 2: Confirm final output

   The function returns all subsets: empty, single elements, and full set.

3. Final Answer:

   [[], [1], [2], [1, 2]] -> Option A

4. Quick Check:

   All subsets of [1,2] listed [OK]

Hint: Each loop doubles subsets by adding current number [OK]

Common Mistakes:

• Forgetting to include empty subset
• Not spreading new subsets correctly
• Returning partial subsets only

4. Identify the error in this TypeScript code that tries to generate all subsets:

function getSubsets(nums: number[]): number[][] {
  let result: number[][] = [];
  for (const num of nums) {
    const newSubsets = result.map(subset => [...subset, num]);
    result = [...result, ...newSubsets];
  }
  return result;
}

console.log(getSubsets([1, 2]));

medium

A. The spread operator is missing in the return statement

B. The map function is used incorrectly

C. The initial result should contain the empty subset [[]]

D. The function should return a flat array, not array of arrays

Solution

1. Step 1: Check initial value of result

   The code starts with result = [], missing the empty subset []. This causes no subsets to be generated.

2. Step 2: Understand impact on loop

   Since result is empty initially, result.map returns empty array each time, so no subsets are added.

3. Final Answer:

   The initial result should contain the empty subset [[]] -> Option C

4. Quick Check:

   Start with [[]] to build subsets [OK]

Hint: Always start subsets with empty set [[]] [OK]

Common Mistakes:

• Starting with empty array instead of array with empty subset
• Misusing map without initial subsets
• Expecting output without base case

5. Given an array nums = [1, 2, 2], which of the following outputs correctly represents all unique subsets (powerset without duplicates) generated by a function that handles duplicates?

hard

A. [[], [1], [2], [2, 2]]

B. [[], [1], [2], [1, 2], [2, 2], [1, 2, 2]]

C. [[], [1], [2], [1, 2], [1, 2, 2]]

D. [[], [1], [2], [1, 2], [2, 2], [1, 2, 2], [2, 1]]

Solution

1. Step 1: Understand duplicates in input

   The input has duplicate '2's. The powerset must include subsets with one or two '2's but no repeated subsets.

2. Step 2: List all unique subsets

   Subsets are: empty [], single elements [1], [2], pairs [1,2], [2,2], and triple [1,2,2]. [[], [1], [2], [1, 2], [2, 2], [1, 2, 2]] lists all correctly without duplicates.

3. Final Answer:

   [[], [1], [2], [1, 2], [2, 2], [1, 2, 2]] -> Option B

4. Quick Check:

   Include duplicates subsets once [OK]

Hint: Handle duplicates by sorting and skipping repeats [OK]

Common Mistakes:

• Including duplicate subsets multiple times
• Missing subsets with two duplicates
• Adding permutations like [2,1] as separate subset