Generate All Subsets Powerset in DSA Java - Build from Scratch

Generate All Subsets Powerset

📖 Scenario: Imagine you have a small collection of unique items, like three different colored balls. You want to find all the possible groups you can make from these balls, including the empty group and the group with all balls.

🎯 Goal: You will write a Java program that takes a list of unique integers and generates all possible subsets (the powerset) of that list. This helps understand how to explore all combinations step-by-step.

📋 What You'll Learn

Create an integer array with exact values

Create a list to store all subsets

Write a recursive function to generate subsets

Print all subsets in the required format

💡 Why This Matters

🌍 Real World

Generating all subsets is useful in tasks like finding all possible combinations of features, options, or permissions in software.

💼 Career

Understanding how to generate powersets helps in problem solving, coding interviews, and designing algorithms that explore all possibilities.

1

Create the input array

Create an integer array called nums with these exact values: 1, 2, and 3.

DSA Java

# Create the integer array nums with values 1, 2, 3
// Your code here

Hint

Use curly braces to list the numbers inside the array.

2

Create the list to hold all subsets

Create a variable called result of type List> and initialize it as a new ArrayList<>().

DSA Java

int[] nums = {1, 2, 3};
// Create the list result to hold all subsets
// Your code here

Hint

Remember to import java.util.List and java.util.ArrayList.

3

Write the recursive function to generate subsets

Write a recursive method called backtrack that takes three parameters: int start, List current, and uses the variables nums and result from above. The method should add a copy of current to result, then loop from start to nums.length, add nums[i] to current, call backtrack(i + 1, current), and then remove the last element from current.

DSA Java

import java.util.ArrayList;
import java.util.List;

int[] nums = {1, 2, 3};
List> result = new ArrayList();

// Write the backtrack method below
// Your code here

Hint

Use recursion to explore subsets by adding and removing elements step-by-step.

4

Call the function and print all subsets

Call the backtrack method starting from 0 with an empty ArrayList<>. Then print the result list.

DSA Java

import java.util.ArrayList;
import java.util.List;

int[] nums = {1, 2, 3};
List> result = new ArrayList();

void backtrack(int start, List current) {
    result.add(new ArrayList(current));
    for (int i = start; i < nums.length; i++) {
        current.add(nums[i]);
        backtrack(i + 1, current);
        current.remove(current.size() - 1);
    }
}

// Call backtrack and print result
// Your code here

Hint

Start recursion with an empty list and print the final list of subsets.

Practice

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

easy

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

B. Only the subsets with exactly two elements

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

D. The largest subset of a given set

Solution

1. Step 1: Understand the definition of powerset

   The powerset of a set is the collection of all possible 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 the powerset as all subsets. Other options describe partial or unrelated concepts.

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: Powerset means every subset possible, including empty [OK]

Common Mistakes:

• Thinking powerset excludes empty set
• Confusing powerset with subsets of fixed size
• Assuming powerset means complement sets

2. Which of the following Java method signatures correctly represents a function that returns all subsets of an integer array?

easy

A. public int generateSubsets(int[] nums)

B. public void generateSubsets(int[] nums)

C. public List generateSubsets(int[] nums)

D. public List<Integer> generateSubsets(int nums)

Solution

1. Step 1: Identify return type for all subsets

   All subsets of an integer array require returning a list of lists of integers, so return type should be List.

2. Step 2: Check method parameters and return type

   public List generateSubsets(int[] nums) matches correct return type and parameter. Options A and C have wrong return types, and D has wrong parameter type.

3. Final Answer:

   public List<List<Integer>> generateSubsets(int[] nums) -> Option C

4. Quick Check:

   Return type must hold all subsets = List of List [OK]

Hint: Return type for subsets is List of List of Integers [OK]

Common Mistakes:

• Using int return type instead of list
• Using void return type without output
• Passing single int instead of int array

3. What is the output of the following Java code snippet?

public static List subsets(int[] nums) {
    List result = new ArrayList<>();
    result.add(new ArrayList<>());
    for (int num : nums) {
        int size = result.size();
        for (int i = 0; i < size; i++) {
            List<Integer> subset = new ArrayList<>(result.get(i));
            subset.add(num);
            result.add(subset);
        }
    }
    return result;
}

// Called with nums = {1, 2}

medium

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

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

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

D. [[1], [2]]

Solution

1. Step 1: Initialize result with empty subset

   Initially, result = [[]].

2. Step 2: Iterate over nums and add new subsets

   For num=1, add [1] to result: result = [[], [1]]. For num=2, add [2] and [1,2]: result = [[], [1], [2], [1, 2]].

3. Final Answer:

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

4. Quick Check:

   All subsets of {1,2} = [[], [1], [2], [1, 2]] [OK]

Hint: Start with empty set, add each number to existing subsets [OK]

Common Mistakes:

• Forgetting to include empty subset
• Adding subsets in wrong order
• Missing combined subsets like [1, 2]

4. Identify the error in the following Java code that attempts to generate all subsets of an integer array:

public static List subsets(int[] nums) {
    List result = new ArrayList<>();
    for (int num : nums) {
        int size = result.size();
        for (int i = 0; i < size; i++) {
            List<Integer> subset = new ArrayList<>(result.get(i));
            subset.add(num);
            result.add(subset);
        }
    }
    result.add(new ArrayList<>());
    return result;
}

medium

A. The input array should be converted to a list first

B. The inner loop should run from size-1 to 0

C. The method should return an int, not a list

D. Empty subset is added at the end, should be added before loop

Solution

1. Step 1: Check when empty subset is added

   Empty subset must be added before starting to build subsets, so that initial subsets exist.

2. Step 2: Analyze code flow

   Here, empty subset is added after loops, so result.size() is zero initially and inner loop never runs, producing empty result except empty subset at end.

3. Final Answer:

   Empty subset is added at the end, should be added before loop -> Option D

4. Quick Check:

   Empty subset must be first for subsets to build [OK]

Hint: Add empty subset before loops to start building subsets [OK]

Common Mistakes:

• Adding empty subset after loops
• Incorrect loop ranges causing no subsets
• Returning wrong data type

5. Given an integer array nums that may contain duplicates, which modification to the standard subsets generation algorithm ensures the powerset contains no duplicate subsets?

hard

A. Only generate subsets of fixed size to avoid duplicates

B. Sort the array first and skip adding subsets that duplicate the last added subset

C. Generate subsets normally without changes; duplicates are automatically handled

D. Use a HashSet to store subsets and convert back to list at the end

Solution

1. Step 1: Understand duplicates in subsets

   Duplicates in input cause duplicate subsets if not handled.

2. Step 2: Use sorting and skip duplicates

   Sorting groups duplicates together. While generating subsets, skip adding subsets that duplicate the last added subset to avoid duplicates.

3. Final Answer:

   Sort the array first and skip adding subsets that duplicate the last added subset -> Option B

4. Quick Check:

   Sort + skip duplicates = unique subsets [OK]

Hint: Sort input and skip duplicates during subset generation [OK]

Common Mistakes:

• Ignoring duplicates causing repeated subsets
• Using HashSet but forgetting order or conversion
• Assuming duplicates don't affect subsets