Subsets - Practice Coding Problems

Subsets - Problem

Generate All Possible Subsets (Power Set)

Given an integer array nums containing unique elements, your task is to return all possible subsets of the array, also known as the power set.

A subset is any combination of elements from the original array, including the empty set and the array itself. The order of subsets in the result doesn't matter, but each subset should appear exactly once.

Example: For array [1,2,3], the power set contains 8 subsets: [], [1], [2], [3], [1,2], [1,3], [2,3], [1,2,3]

💡 Fun fact: An array of n elements always has exactly 2ⁿ subsets!

Input & Output

example_1.py — Basic Case

$ Input: [1,2,3]

› Output: [[],[1],[2],[1,2],[3],[1,3],[2,3],[1,2,3]]

💡 Note: For 3 elements, we get 2³ = 8 subsets. Each element can either be included or excluded from each subset.

example_2.py — Single Element

$ Input: [0]

› Output: [[],[0]]

💡 Note: With one element, we have 2¹ = 2 subsets: the empty set and the set containing the single element.

example_3.py — Empty Array Edge Case

$ Input: []

› Output: [[]]

💡 Note: An empty array has only one subset: the empty set itself. This follows 2⁰ = 1.

Constraints

1 ≤ nums.length ≤ 10
-10 ≤ nums[i] ≤ 10
All the numbers of nums are unique

Visualization

Tap to expand

Understanding the Visualization

Binary Choice

Each element has 2 options: include or exclude

Systematic Generation

Use either backtracking or bit manipulation to explore all 2^n possibilities

Complete Power Set

Collect all generated subsets from empty set to full set

Key Takeaway

🎯 Key Insight: Every element has exactly 2 choices (include/exclude), giving us 2^n total combinations. Both bit manipulation and backtracking systematically explore all possibilities.

Asked in

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

The backtracking approach is most intuitive - recursively decide to include/exclude each element. For better performance, bit manipulation treats each number 0 to 2ⁿ-1 as a bitmask representing which elements to include. Both achieve O(2ⁿ) time complexity since there are exactly 2ⁿ possible subsets.

Common Approaches

Approach	Time	Space	Notes
✓ Backtracking (Recursive)	O(2^n)	O(n × 2^n)	Use recursion to build subsets by including/excluding each element

Backtracking (Recursive) — Algorithm Steps

Start with empty subset and first element index
For each element, make two recursive calls:
- Include current element in subset
- Exclude current element from subset
Add complete subset to result when all elements processed
Backtrack by removing added elements

Visualization

Tap to expand

Step-by-Step Walkthrough

Decision Point

At each level, decide whether to include current element

Recursive Exploration

Explore both include and exclude branches

Backtrack

Remove element and try next possibility

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>

void backtrack(int start, int* nums, int numsSize, int* currentSubset, int currentSize, int*** result, int** returnColumnSizes, int* returnSize, int* capacity) {
    // Resize result array if needed
    if (*returnSize >= *capacity) {
        *capacity *= 2;
        *result = (int**)realloc(*result, (*capacity) * sizeof(int*));
        *returnColumnSizes = (int*)realloc(*returnColumnSizes, (*capacity) * sizeof(int));
    }
    
    // Add current subset to result
    (*result)[*returnSize] = (int*)malloc(currentSize * sizeof(int));
    for (int i = 0; i < currentSize; i++) {
        (*result)[*returnSize][i] = currentSubset[i];
    }
    (*returnColumnSizes)[*returnSize] = currentSize;
    (*returnSize)++;
    
    // Try adding each remaining element
    for (int i = start; i < numsSize; i++) {
        currentSubset[currentSize] = nums[i];
        backtrack(i + 1, nums, numsSize, currentSubset, currentSize + 1, result, returnColumnSizes, returnSize, capacity);
    }
}

int** subsets(int* nums, int numsSize, int* returnSize, int** returnColumnSizes) {
    *returnSize = 0;
    int capacity = 8;
    int** result = (int**)malloc(capacity * sizeof(int*));
    *returnColumnSizes = (int*)malloc(capacity * sizeof(int));
    int* currentSubset = (int*)malloc(numsSize * sizeof(int));
    
    backtrack(0, nums, numsSize, currentSubset, 0, &result, returnColumnSizes, returnSize, &capacity);
    
    free(currentSubset);
    return result;
}

int main() {
    int nums[] = {1, 2, 3};
    int returnSize;
    int* returnColumnSizes;
    int** result = subsets(nums, 3, &returnSize, &returnColumnSizes);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("[");
        for (int j = 0; j < returnColumnSizes[i]; j++) {
            printf("%d", result[i][j]);
            if (j < returnColumnSizes[i]-1) printf(",");
        }
        printf("]");
        if (i < returnSize-1) printf(",");
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n)

We make 2^n recursive calls to generate all subsets

⚠ Quadratic Growth

Space Complexity

O(n × 2^n)

Storage for all subsets plus recursion stack depth of O(n)

⚠ Quadratic Space

89.3K Views

Very High Frequency

~15 min Avg. Time

2.8K 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

Constraints

Visualization

Related Problems

Common Approaches

Backtracking (Recursive) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler