Subsets - Practice Coding Problems

Subsets - Problem

Given an integer array nums of unique elements, return all possible subsets (the power set).

The solution set must not contain duplicate subsets. Return the solution in any order.

Note: The power set of a set is the set of all its subsets, including the empty set and the set itself.

Input & Output

Example 1 — Basic Case

$ Input: nums = [1,2,3]

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

💡 Note: All possible combinations of including/excluding each element. Empty set and full set are both included.

Example 2 — Two Elements

$ Input: nums = [0]

› Output: [[],[0]]

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

Example 3 — Larger Array

$ Input: nums = [1,2]

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

💡 Note: With two elements, we have 2² = 4 subsets representing all include/exclude combinations.

Constraints

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

Visualization

Tap to expand

Understanding the Visualization

Input

Array of unique integers [1,2,3]

Process

Generate all combinations of include/exclude

Output

2^n subsets including empty set

Key Takeaway

🎯 Key Insight: Each element has 2 choices (include/exclude), leading to 2^n total combinations

Asked in

F Facebook 45 A Amazon 38 G Google 32 M Microsoft 28

The key insight is that each element has exactly 2 choices: be included or excluded from a subset. This gives us 2^n total subsets. The backtracking approach is most intuitive, building subsets recursively. Bit manipulation is clever, using binary numbers as masks. Both have Time: O(n × 2^n), Space: O(n × 2^n).

Common Approaches

Approach	Time	Space	Notes
✓ Backtracking	O(n × 2^n)	O(n × 2^n)	Recursively build subsets by choosing to include or exclude each element
Brute Force - Bit Manipulation	O(n × 2^n)	O(n × 2^n)	Generate all 2^n binary combinations to represent include/exclude decisions

Backtracking — Algorithm Steps

Start with empty subset
For each element: try including it, then try excluding it
Add complete subsets to result

Visualization

Tap to expand

Step-by-Step Walkthrough

Start

Begin with empty subset []

Decisions

For each element: include or exclude

Generate

All paths lead to unique subsets

Code -

solution.c — C

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

void backtrack(int* nums, int numsSize, int start, int* current, int currentSize, int*** result, int** returnColumnSizes, int* returnSize) {
    // Add current subset to result
    (*returnColumnSizes)[*returnSize] = currentSize;
    (*result)[*returnSize] = (int*)malloc(currentSize * sizeof(int));
    for (int i = 0; i < currentSize; i++) {
        (*result)[*returnSize][i] = current[i];
    }
    (*returnSize)++;
    
    // Try including each remaining element
    for (int i = start; i < numsSize; i++) {
        current[currentSize] = nums[i];  // Include nums[i]
        backtrack(nums, numsSize, i + 1, current, currentSize + 1, result, returnColumnSizes, returnSize);
        // Backtrack happens automatically when we return
    }
}

int** solution(int* nums, int numsSize, int* returnSize, int** returnColumnSizes) {
    int maxSubsets = 1 << numsSize;  // 2^n
    int** result = (int**)malloc(maxSubsets * sizeof(int*));
    *returnColumnSizes = (int*)malloc(maxSubsets * sizeof(int));
    *returnSize = 0;
    
    int* current = (int*)malloc(numsSize * sizeof(int));
    backtrack(nums, numsSize, 0, current, 0, &result, returnColumnSizes, returnSize);
    
    free(current);
    return result;
}

int main() {
    int nums[] = {1, 2, 3};
    int numsSize = 3;
    int returnSize;
    int* returnColumnSizes;
    
    int** result = solution(nums, numsSize, &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(n × 2^n)

2^n subsets generated, each subset copied takes O(n) time

⚠ Quadratic Growth

Space Complexity

O(n × 2^n)

Storing 2^n subsets plus O(n) recursion stack depth

⚠ Quadratic Space

508.9K Views

High Frequency

~15 min Avg. Time

15.4K 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 — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler