Generate All Combinations Sum K in DSA C# - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

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

DSA C#

List<IList<int>> result = new List<IList<int>>();
Backtrack(new List<int>(), 1, [1], result);

void Backtrack(List<int> combination, int start, int target, List<IList<int>> result) {
    // implementation
}

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

Asum

Bn

Ck

D0

Attempts:

3 left

💡 Hint

Common Mistakes

Starting backtracking with 0 instead of k.

Using n instead of k as the target.

We start backtracking with the target sum k to find combinations that sum to k.

2fill in blank

medium

Complete the condition to stop backtracking when the target is reached.

DSA C#

void Backtrack(List<int> combination, int start, int target, List<IList<int>> result) {
    if ([1] == 0) {
        result.Add(new List<int>(combination));
        return;
    }
    // continue backtracking
}

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

Atarget

Bcombination.Count

Cstart

Dresult.Count

Attempts:

3 left

💡 Hint

Common Mistakes

Checking combination.Count instead of target.

Checking start or result.Count incorrectly.

When target reaches zero, the current combination sums to k and should be added to results.

3fill in blank

hard

Fix the error in the loop to avoid exceeding the target sum.

DSA C#

for (int i = start; i <= 9; i++) {
    if (i > [1]) break;
    combination.Add(i);
    Backtrack(combination, i + 1, target - i, result);
    combination.RemoveAt(combination.Count - 1);
}

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

Astart

Btarget

Ccombination.Count

Dresult.Count

Attempts:

3 left

💡 Hint

Common Mistakes

Comparing i with start or combination.Count instead of target.

Not breaking the loop causing unnecessary recursion.

We break the loop if the current number i exceeds the remaining target to avoid invalid sums.

4fill in blank

hard

Fill both blanks to correctly update the combination and recurse.

DSA C#

combination.[1](i);
Backtrack(combination, i [2] 1, target - i, result);
combination.RemoveAt(combination.Count - 1);

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

AAdd

B+

C-

DInsert

Attempts:

3 left

💡 Hint

Common Mistakes

Using Insert instead of Add.

Using subtraction instead of addition for start.

Add i to combination, then recurse with start as i + 1 to avoid duplicates.

5fill in blank

hard

Fill both blanks to complete the LINQ expression for filtering combinations.

DSA C#

var filtered = combinations.Where(c => c.Sum() [1] [2]).ToList();

// Print filtered combinations
foreach (var combo in filtered) {
    Console.WriteLine(string.Join(", ", combo));
}

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

A==

Bk

C>

D<

Attempts:

3 left

💡 Hint

Common Mistakes

Using > or < instead of == for exact sum match.

Comparing with wrong variable.

Filter combinations whose sum equals k using == operator and k value.

Practice

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

easy

A. The largest number less than K

B. The sum of all numbers from 1 to K

C. All unique combinations of numbers that add up 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 K.

2. Step 2: Identify the correct description

   All unique combinations of numbers that add up to K correctly describes finding all unique combinations summing to K.

3. Final Answer:

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

4. Quick Check:

   Combinations sum K = all sets adding to K [OK]

Hint: Look for options describing sets adding exactly to K [OK]

Common Mistakes:

• Confusing sum with product
• Thinking about single numbers instead of combinations
• Choosing options about divisors or ranges

2. Which of the following is the correct C# syntax to start a recursive method named FindCombinations that takes a list of integers and a target sum?

easy

A. void FindCombinations(List nums, int target) { }

B. void FindCombinations(List<int> nums, int target) { }

C. void FindCombinations(int nums[], int target) { }

D. void FindCombinations(List<int> nums; int target) { }

Solution

1. Step 1: Check parameter types and syntax

   In C#, a list of integers is declared as List<int>. The method parameters must be separated by commas.

2. Step 2: Identify correct syntax

   void FindCombinations(List<int> nums, int target) { } uses List<int> and comma-separated parameters correctly. Others have syntax errors or wrong types.

3. Final Answer:

   void FindCombinations(List<int> nums, int target) { } -> Option B

4. Quick Check:

   Correct C# method syntax = void FindCombinations(List<int> nums, int target) { } [OK]

Hint: Remember C# uses List<int> and commas between parameters [OK]

Common Mistakes:

• Using array syntax int nums[] in method parameters
• Missing commas between parameters
• Using untyped List without <int>

3. What is the output of the following C# code snippet that generates all combinations of numbers from 1 to 3 that sum to 3?

void Generate(int start, int target, List<int> current, List result) {
  if (target == 0) {
    result.Add(new List<int>(current));
    return;
  }
  for (int i = start; i <= 3; i++) {
    if (i <= target) {
      current.Add(i);
      Generate(i + 1, target - i, current, result);
      current.RemoveAt(current.Count - 1);
    }
  }
}

var result = new List();
Generate(1, 3, new List<int>(), result);
foreach(var combo in result) {
  Console.WriteLine(string.Join(",", combo));
}

medium

A. 3
2,1

B. 1,1,1
3

C. 1,2
2,1
3

D. 1,2
3

Solution

1. Step 1: Trace recursive calls and combinations

   The code tries numbers from start to 3, adding to current if <= target. It avoids repeats by increasing start each call.

2. Step 2: Identify valid combinations summing to 3

   Possible combinations are [1,2] and [3]. The code prints these two lines: "1,2" and "3".

3. Final Answer:

   1,2 3 -> Option D

4. Quick Check:

   Unique combos summing 3 = 1,2 and 3 [OK]

Hint: Check recursion start index to avoid duplicates [OK]

Common Mistakes:

• Expecting repeated numbers like 1,1,1
• Confusing order of output lines
• Including reversed duplicates like 2,1

4. The following code is intended to generate all combinations of numbers from 1 to 4 that sum to 5. What is the main error causing it to miss some combinations?

void Generate(int start, int target, List<int> current, List result) {
  if (target == 0) {
    result.Add(new List<int>(current));
    return;
  }
  for (int i = start; i < 4; i++) {
    if (i <= target) {
      current.Add(i);
      Generate(i + 1, target - i, current, result);
      current.RemoveAt(current.Count - 1);
    }
  }
}

medium

A. The loop condition should be <= 4, not < 4

B. The recursive call should use i, not i + 1

C. The target check should be target < i, not i <= target

D. The current list should not be copied when adding to result

Solution

1. Step 1: Analyze the for loop range

   The loop runs from start to i < 4, so it stops at i=3, missing i=4.

2. Step 2: Identify impact on combinations

   Because 4 is excluded, combinations including 4 are missed. Changing to i <= 4 fixes this.

3. Final Answer:

   The loop condition should be <= 4, not < 4 -> Option A

4. Quick Check:

   Loop range excludes 4, missing combos [OK]

Hint: Check loop boundaries carefully for inclusive ranges [OK]

Common Mistakes:

• Using wrong loop end condition
• Changing recursion start incorrectly
• Not copying list before adding to result

5. You want to generate all combinations of numbers from 1 to 7 that sum to 7, but each number can be used multiple times. Which change to the recursive call in this C# code will allow repeated numbers?

void Generate(int start, int target, List<int> current, List result) {
  if (target == 0) {
    result.Add(new List<int>(current));
    return;
  }
  for (int i = start; i <= 7; i++) {
    if (i <= target) {
      current.Add(i);
      Generate(??? , target - i, current, result);
      current.RemoveAt(current.Count - 1);
    }
  }
}

hard

A. Use i to allow repeats

B. Use start to allow repeats

C. Use i + 1 to avoid repeats

D. Use 1 to restart from beginning

Solution

1. Step 1: Understand how recursion controls repeats

   Using i + 1 moves start forward, preventing repeats. Using i keeps start same, allowing repeats.

2. Step 2: Choose correct recursive call argument

   To allow repeated numbers, pass i as start in recursive call.

3. Final Answer:

   Use i to allow repeats -> Option A

4. Quick Check:

   Passing i keeps current number available [OK]

Hint: Pass current index to allow repeats, increment to avoid [OK]

Common Mistakes:

• Using i + 1 disables repeats
• Using start (unchanged) may cause infinite loops
• Restarting from 1 causes duplicates and inefficiency