Generate All Combinations Sum K in DSA Java - Build from Scratch

Generate All Combinations Sum K

📖 Scenario: You are organizing a small event and want to create different groups of people. Each group should have a total number of members equal to a specific number k. You have a list of possible group sizes, and you want to find all the ways to combine these sizes to reach exactly k.

🎯 Goal: Build a Java program that finds and prints all combinations of numbers from a given list that add up to a target sum k. Each number can be used multiple times in the combinations.

📋 What You'll Learn

Create an integer array called candidates with the exact values {2, 3, 6, 7}.

Create an integer variable called target and set it to 7.

Write a recursive method called findCombinations that finds all combinations of numbers from candidates that sum to target.

Print all the found combinations as lists of integers.

💡 Why This Matters

🌍 Real World

Finding combinations that sum to a target is useful in budgeting, resource allocation, and planning tasks where exact totals are needed.

💼 Career

This problem helps develop skills in recursion, backtracking, and working with lists, which are common in software development and algorithm design roles.

1

Create the candidates array

Create an integer array called candidates with the exact values {2, 3, 6, 7}.

DSA Java

// Create the candidates array with values {2, 3, 6, 7}
// Your code here

Hint

Use int[] candidates = {2, 3, 6, 7}; to create the array.

2

Set the target sum

Create an integer variable called target and set it to 7 inside the main method.

DSA Java

public class CombinationSum {
    public static void main(String[] args) {
        int[] candidates = {2, 3, 6, 7};
        // Create the target variable and set it to 7
        // Your code here
    }
}

Hint

Use int target = 7; to create the target variable.

3

Write the recursive method to find combinations

Write a recursive method called findCombinations that takes these parameters: int[] candidates, int target, int start, List<Integer> current, and List<List<Integer>> result. This method should find all combinations of numbers from candidates starting at index start that sum to target. Add each valid combination to result. Call this method from main with an empty current list and an empty result list.

DSA Java

import java.util.*;

public class CombinationSum {
    public static void main(String[] args) {
        int[] candidates = {2, 3, 6, 7};
        int target = 7;
        // Create result list and call findCombinations
        // Your code here
    }

    // Write the recursive method findCombinations here
    // Your code here
}

Hint

Use recursion to try each candidate starting from start. Add candidates to current and subtract from target. When target is zero, add a copy of current to result.

4

Print all combinations found

Add code in the main method to print all the combinations stored in result. Each combination should be printed on its own line as a list of integers.

DSA Java

import java.util.*;

public class CombinationSum {
    public static void main(String[] args) {
        int[] candidates = {2, 3, 6, 7};
        int target = 7;
        List> result = new ArrayList();
        findCombinations(candidates, target, 0, new ArrayList(), result);
        // Print all combinations in result
        // Your code here
    }

    public static void findCombinations(int[] candidates, int target, int start, List current, List> result) {
        if (target == 0) {
            result.add(new ArrayList(current));
            return;
        }
        if (target < 0) {
            return;
        }
        for (int i = start; i < candidates.length; i++) {
            current.add(candidates[i]);
            findCombinations(candidates, target - candidates[i], i, current, result);
            current.remove(current.size() - 1);
        }
    }
}

Hint

Use a for loop to print each list in result using System.out.println().

Practice

1. What does the problem "Generate All Combinations Sum K" ask you to find?

easy

A. All unique combinations of numbers that add up to K

B. The largest number less than K

C. The sum of all numbers from 1 to K

D. The product of all numbers that divide K

Solution

1. Step 1: Understand the problem goal

   The problem asks to find all unique sets of numbers that add exactly to the target sum K.

2. Step 2: Clarify what combinations mean

   Combinations mean selecting numbers without caring about order, but each combination must sum to K.

3. Final Answer:

   All unique combinations of numbers that add up to K -> Option A

4. Quick Check:

   Sum of combinations = K [OK]

Hint: Focus on sums equal to K, not order or multiplication [OK]

Common Mistakes:

• Confusing combinations with permutations
• Looking for product instead of sum
• Ignoring uniqueness of combinations

2. Which of the following Java method signatures is correct for a function that generates all combinations summing to K using backtracking?

easy

A. public void findCombinations(int[] nums, int target, List<Integer> current, List result, int start)

B. public int findCombinations(int[] nums, int target)

C. void findCombinations(int target, int[] nums, List result)

D. public List<Integer> findCombinations(int target, int[] nums)

Solution

1. Step 1: Identify parameters needed for backtracking

   We need the array, target sum, current combination list, result list, and start index to avoid duplicates.

2. Step 2: Match method signature with these parameters

   public void findCombinations(int[] nums, int target, List<Integer> current, List result, int start) matches all needed parameters and returns void as it fills the result list.

3. Final Answer:

   public void findCombinations(int[] nums, int target, List<Integer> current, List result, int start) -> Option A

4. Quick Check:

   Correct parameters for backtracking method [OK]

Hint: Backtracking needs current, result lists, and start index [OK]

Common Mistakes:

• Missing start index parameter
• Wrong return type for backtracking method
• Incorrect parameter order

3. What will be the output of the following Java code snippet?

List result = new ArrayList<>();
int[] nums = {2, 3, 6, 7};
int target = 7;
findCombinations(nums, target, new ArrayList<>(), result, 0);
System.out.println(result);

Assuming findCombinations correctly finds all unique combinations summing to target.

medium

A. [[2, 3, 6], [7]]

B. [[7]]

C. [[2, 2, 3], [7]]

D. [[2, 2, 2, 3], [7]]

Solution

1. Step 1: Identify combinations that sum to 7

   From nums, 7 alone sums to 7, and 2+2+3 also sums to 7.

2. Step 2: Confirm no other combinations sum to 7

   3+6=9, 2+3+6=11, 2+2+2+3=9 (too large), so only [2,2,3] and [7] are valid.

3. Final Answer:

   [[2, 2, 3], [7]] -> Option C

4. Quick Check:

   Valid combinations sum to 7 [OK]

Hint: Check sums carefully; only valid combos appear [OK]

Common Mistakes:

• Including invalid sums
• Missing repeated elements allowed
• Confusing order of elements

4. Identify the error in this Java backtracking code snippet for generating combinations summing to K:

void findCombinations(int[] nums, int target, List<Integer> current, List result, int start) {
    if (target == 0) {
        result.add(new ArrayList<>(current));
        return;
    }
    for (int i = start; i < nums.length; i++) {
        if (nums[i] > target) continue;
        current.add(nums[i]);
        findCombinations(nums, target - nums[i], current, result, i);
        current.remove(current.size());
    }
}

medium

A. The recursive call should use i + 1 instead of i

B. The base case should check if target < 0 instead of target == 0

C. The loop should start from 0 instead of start

D. Removing element with current.remove(current.size()) causes IndexOutOfBoundsException

Solution

1. Step 1: Check the remove method usage

   List indices start at 0, so last element index is current.size() - 1, not current.size().

2. Step 2: Identify correct remove call

   Using current.remove(current.size()) causes IndexOutOfBoundsException because index is out of range.

3. Final Answer:

   Removing element with current.remove(current.size()) causes IndexOutOfBoundsException -> Option D

4. Quick Check:

   List remove index must be size-1 [OK]

Hint: Remove last element with index size-1, not size [OK]

Common Mistakes:

• Removing element at wrong index
• Ignoring base case correctness
• Wrong loop start index

5. Given the array nums = {1, 2, 3} and target sum 4, which of the following is the correct set of all unique combinations where numbers can be repeated and sum to 4?

hard

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

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

C. [[1,1,1,1], [1,1,2], [1,3], [2,2], [4]]

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

Solution

1. Step 1: List all combinations summing to 4 with repeats allowed

   Possible combos: [1,1,1,1], [1,1,2], [1,3], [2,2]. Note [3,1] is same as [1,3] and duplicates are not allowed.

2. Step 2: Check options for duplicates and invalid elements

   [[1,1,1,1], [1,1,2], [1,3], [2,2], [3,1]] includes [3,1] duplicate of [1,3]. [[1,1,1,1], [1,1,2], [1,3], [2,2], [4]] includes [4] which is not in nums. [[1,1,1,1], [1,1,2], [2,2], [3,1]] misses [1,3]. [[1,1,1,1], [1,1,2], [1,3], [2,2]] correctly lists unique combinations.

3. Final Answer:

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

4. Quick Check:

   Unique combos sum to 4 without duplicates [OK]

Hint: Avoid duplicates by sorting or fixed order in combos [OK]

Common Mistakes:

• Counting duplicates as separate combinations
• Including numbers not in the array
• Ignoring repeated use of numbers