Subsets II - Practice Coding Problems

Subsets II - Problem

Subsets II challenges you to generate the power set (all possible subsets) of an array that may contain duplicate elements. Unlike the classic subsets problem, here you must ensure that no duplicate subsets appear in your result.

Given an integer array nums with possible duplicates, return all unique subsets. The order of subsets doesn't matter, but each subset should appear exactly once. For example, if your array is [1, 2, 2], you should include [1, 2] only once, not twice.

Goal: Generate all unique subsets from an array with duplicates
Input: Integer array that may contain duplicate values
Output: List of all unique subsets (in any order)

Input & Output

example_1.py — Basic case with duplicates

$ Input: [1,2,2]

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

💡 Note: The array contains duplicate 2's. We generate all unique subsets: empty set, single elements [1] and [2], pairs [1,2] and [2,2], and the full set [1,2,2]. Note that [1,2] appears only once even though it can be formed in multiple ways.

example_2.py — Multiple duplicates

$ Input: [4,4,4,1,4]

› Output: [[],[1],[1,4],[1,4,4],[1,4,4,4],[1,4,4,4,4],[4],[4,4],[4,4,4],[4,4,4,4]]

💡 Note: With four 4's and one 1, we can form subsets with 0-4 copies of 4, each optionally including the 1. After sorting, duplicates are handled systematically.

example_3.py — No duplicates edge case

$ Input: [1,2,3]

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

💡 Note: When there are no duplicates, this behaves like the classic subsets problem, generating all 2^3 = 8 possible subsets.

Constraints

1 ≤ nums.length ≤ 10
-10 ≤ nums[i] ≤ 10
The solution set must not contain duplicate subsets

Visualization

Tap to expand

Understanding the Visualization

Line Up by Skill

Sort players by skill level to group identical players together

Make Decisions

For each skill level, decide how many players of that skill to include

Skip Smart

When excluding a player, exclude all players with identical skills to avoid duplicate teams

Record Teams

Add each unique team composition to your final roster

Key Takeaway

🎯 Key Insight: Sorting groups duplicates together, allowing us to systematically skip identical elements and generate only unique subsets efficiently.

Asked in

a Amazon 45 ⊞ Microsoft 38 G Google 32 f Meta 28 Apple 22

The optimal approach uses backtracking with duplicate skipping. First sort the array to group duplicates together, then use recursive backtracking to generate subsets. The key insight is: when we decide to skip an element, we must skip all consecutive identical elements to avoid generating duplicate subsets. This ensures O(n × 2^n) time complexity while generating only unique subsets.

Common Approaches

Approach	Time	Space	Notes
✓ Generate All Then Filter	O(n * 2^n)	O(n * 2^n)	Generate all possible subsets, then remove duplicates using a set
Backtracking with Duplicate Skipping (Optimal)	O(n * 2^n)	O(n * 2^n)	Sort array first, then use backtracking while skipping consecutive duplicates

Generate All Then Filter — Algorithm Steps

Generate all 2^n possible subsets using bit manipulation or recursion
Convert each subset to a sorted tuple for consistent comparison
Use a set to automatically filter out duplicate subsets
Convert the set back to a list of lists

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate All Subsets

Use bit manipulation to create all 2^n possible combinations

Sort Each Subset

Sort elements in each subset for consistent comparison

Remove Duplicates

Use set data structure to automatically filter duplicates

Return Unique Results

Convert deduplicated set back to list format

Code -

solution.c — C

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

int compare(const void *a, const void *b) {
    return (*(int*)a - *(int*)b);
}

void generateSubsets(int* nums, int numsSize, int*** result, int* returnSize, int** returnColumnSizes) {
    int totalSubsets = 1 << numsSize;
    *result = (int**)malloc(totalSubsets * sizeof(int*));
    *returnColumnSizes = (int*)malloc(totalSubsets * sizeof(int));
    *returnSize = 0;
    
    char seen[10000][1000] = {0};
    
    for (int i = 0; i < totalSubsets; i++) {
        int* subset = (int*)malloc(numsSize * sizeof(int));
        int subsetSize = 0;
        
        for (int j = 0; j < numsSize; j++) {
            if (i & (1 << j)) {
                subset[subsetSize++] = nums[j];
            }
        }
        
        qsort(subset, subsetSize, sizeof(int), compare);
        
        char key[1000] = "";
        for (int k = 0; k < subsetSize; k++) {
            char temp[20];
            sprintf(temp, "%d,", subset[k]);
            strcat(key, temp);
        }
        
        int isDuplicate = 0;
        for (int k = 0; k < *returnSize; k++) {
            if (strcmp(seen[k], key) == 0) {
                isDuplicate = 1;
                break;
            }
        }
        
        if (!isDuplicate) {
            strcpy(seen[*returnSize], key);
            (*result)[*returnSize] = subset;
            (*returnColumnSizes)[*returnSize] = subsetSize;
            (*returnSize)++;
        } else {
            free(subset);
        }
    }
}

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

Generate 2^n subsets, each taking O(n) time to process and sort for duplicate detection

⚠ Quadratic Growth

Space Complexity

O(n * 2^n)

Store all subsets including duplicates initially, plus set for deduplication

⚠ Quadratic Space

89.5K Views

High Frequency

~25 min Avg. Time

3.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

Generate All Then Filter — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler