Generate All Combinations Sum K in DSA Java - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to start the backtracking with an empty list.

DSA Java

public List<List<Integer>> combinationSum3(int k, int n) {
    List<List<Integer>> result = new ArrayList<>();
    backtrack(1, k, n, new ArrayList<>(), result);
    return result;
}

private void backtrack(int start, int k, int n, List<Integer> tempList, List<List<Integer>> result) {
    if (tempList.size() == k && n == 0) {
        result.add(new ArrayList<>(tempList));
        return;
    }
    for (int i = start; i <= 9; i++) {
        tempList.add(i);
        backtrack(i + 1, k, n - i, tempList, result);
        tempList.remove(tempList.size() - 1);
    }
}

// Call the method with [1]

Drag options to blanks, or click blank then click option'

AcombinationSum3(2, 5)

BcombinationSum3(3, 9)

CcombinationSum3(3, 7)

DcombinationSum3(4, 10)

Attempts:

3 left

💡 Hint

Common Mistakes

Choosing wrong parameters for k and n in the initial call.

Not starting the backtracking with the correct parameters.

The method combinationSum3(3, 7) starts the search for combinations of 3 numbers that sum to 7.

2fill in blank

medium

Complete the code to check if the current combination is valid.

DSA Java

private void backtrack(int start, int k, int n, List<Integer> tempList, List<List<Integer>> result) {
    if (tempList.size() == k && [1]) {
        result.add(new ArrayList<>(tempList));
        return;
    }
    for (int i = start; i <= 9; i++) {
        tempList.add(i);
        backtrack(i + 1, k, n - i, tempList, result);
        tempList.remove(tempList.size() - 1);
    }
}

Drag options to blanks, or click blank then click option'

An == 0

Bn > 0

Cn < 0

DtempList.size() > k

Attempts:

3 left

💡 Hint

Common Mistakes

Checking if n > 0 instead of n == 0.

Not checking the sum condition at all.

The combination is valid only if the sum left (n) is zero when the size matches k.

3fill in blank

hard

Fix the error in the for-loop condition to avoid invalid numbers.

DSA Java

for (int i = start; i [1] 9; i++) {
    tempList.add(i);
    backtrack(i + 1, k, n - i, tempList, result);
    tempList.remove(tempList.size() - 1);
}

Drag options to blanks, or click blank then click option'

A<=

B<

C>=

D>

Attempts:

3 left

💡 Hint

Common Mistakes

Using < excludes 9, missing valid combinations.

Using > or >= causes infinite loops or no iterations.

The loop should include 9, so the condition must be i <= 9.

4fill in blank

hard

Fill both blanks to correctly remove the last added number after backtracking.

DSA Java

tempList.[1](tempList.[2]() - 1);

Drag options to blanks, or click blank then click option'

Aremove

Bsize

Cget

Dadd

Attempts:

3 left

💡 Hint

Common Mistakes

Using add instead of remove.

Using get instead of size for index.

We remove the element at index size() - 1 to backtrack correctly.

5fill in blank

hard

Fill all three blanks to correctly start backtracking and add valid combinations.

DSA Java

if (tempList.size() == [1] && [2] == 0) {
    result.[3](new ArrayList<>(tempList));
    return;
}

Drag options to blanks, or click blank then click option'

Ak

Bn

Cadd

Dsize

Attempts:

3 left

💡 Hint

Common Mistakes

Checking wrong variables for size or sum.

Using wrong method to add to result.

Check if size equals k and sum left (n) is zero, then add the combination to result.

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