Combination Sum III - Practice Coding Problems

Combination Sum III - Problem

Array Backtracking Medium

Imagine you're a mathematician tasked with finding all possible ways to select k distinct digits from 1 through 9 that add up to exactly n. This is a classic combinatorial problem that tests your ability to explore all valid combinations systematically.

The Challenge:

You can only use digits 1, 2, 3, 4, 5, 6, 7, 8, 9
Each digit can be used at most once in any combination
You must find exactly k numbers that sum to n
Return all valid combinations (order doesn't matter)

Example: If k = 3 and n = 7, you need 3 distinct digits that sum to 7. The only solution is [1, 2, 4] because 1 + 2 + 4 = 7.

Input & Output

example_1.py — Basic case

$ Input: k = 3, n = 7

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

💡 Note: We need 3 distinct numbers from 1-9 that sum to 7. Only [1,2,4] works: 1+2+4=7

example_2.py — Multiple solutions

$ Input: k = 3, n = 9

› Output: [[1,2,6],[1,3,5],[2,3,4]]

💡 Note: Three different combinations work: 1+2+6=9, 1+3+5=9, and 2+3+4=9

example_3.py — No solution

$ Input: k = 4, n = 1

› Output: []

💡 Note: Impossible: we need 4 distinct positive digits, minimum sum would be 1+2+3+4=10, which exceeds target 1

Visualization

Tap to expand

Understanding the Visualization

Start with Empty Set

Begin with no digits selected, sum = 0

Try Each Digit

For each position, try adding digits from current minimum to 9

Check Constraints

Verify: sum ≤ n, combo length ≤ k, still possible to reach target

Backtrack if Invalid

If constraints violated, remove last digit and try next option

Found Solution

When k digits selected and sum = n, add to results

Key Takeaway

🎯 Key Insight: Backtracking with early pruning transforms an exponential search space into a much more manageable exploration by eliminating impossible branches before fully exploring them.

Time & Space Complexity

Time Complexity

⏱️

O(2^9)

In worst case, we explore all subsets of 9 digits, but pruning makes it much faster in practice

✓ Linear Growth

Space Complexity

O(k)

Recursion depth is at most k, and we store current combination of size k

✓ Linear Space

Constraints

2 ≤ k ≤ 9
1 ≤ n ≤ 60
Only digits 1 through 9 can be used
Each digit can be used at most once per combination

Asked in

G Google 25 a Amazon 20 f Meta 15 ⊞ Microsoft 12

The optimal solution uses backtracking to systematically explore all possible combinations while pruning invalid branches early. Key optimizations include stopping when sum exceeds target and when remaining digits can't reach target. Time complexity is O(2^9) worst case but much faster with pruning.

Common Approaches

Approach	Time	Space	Notes
✓ Backtracking (Optimal)	O(2^9)	O(k)	Use backtracking to build combinations incrementally, pruning invalid paths early

Backtracking (Optimal) — Algorithm Steps

Start with an empty combination and sum = 0
Try adding each digit from current position onwards
If current sum > n, prune this branch (backtrack)
If we have k digits and sum = n, add to results
If we have k digits but sum ≠ n, backtrack
Continue until all possibilities explored

Visualization

Tap to expand

Step-by-Step Walkthrough

Start Empty

Begin with empty combination, try adding digits 1-9

Build Incrementally

Add one digit at a time, ensuring no duplicates by using start position

Prune Early

If sum > target or impossible to reach target, backtrack immediately

Found Solution

When k digits and sum = n, add combination to results

Code -

solution.c — C

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

int result[200][9];
int resultSize = 0;
int resultSizes[200];
int current[9];
int currentSize = 0;

void backtrack(int start, int k, int n, int currentSum) {
    // Base cases
    if (currentSize == k) {
        if (currentSum == n) {
            for (int i = 0; i < k; i++) {
                result[resultSize][i] = current[i];
            }
            resultSizes[resultSize] = k;
            resultSize++;
        }
        return;
    }
    
    // Pruning: if current sum exceeds target
    if (currentSum > n) {
        return;
    }
    
    // Pruning: if maximum possible sum can't reach target
    int remainingPositions = k - currentSize;
    int maxPossibleSum = currentSum;
    for (int i = 0; i < remainingPositions; i++) {
        maxPossibleSum += (9 - i);
    }
    if (maxPossibleSum < n) {
        return;
    }
    
    // Try each digit from start to 9
    for (int digit = start; digit <= 9; digit++) {
        current[currentSize++] = digit;
        backtrack(digit + 1, k, n, currentSum + digit);
        currentSize--;
    }
}

int main() {
    int k, n;
    scanf("%d %d", &k, &n);
    
    resultSize = 0;
    currentSize = 0;
    backtrack(1, k, n, 0);
    
    printf("[");
    for (int i = 0; i < resultSize; i++) {
        if (i > 0) printf(",");
        printf("[");
        for (int j = 0; j < resultSizes[i]; j++) {
            if (j > 0) printf(",");
            printf("%d", result[i][j]);
        }
        printf("]");
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^9)

In worst case, we explore all subsets of 9 digits, but pruning makes it much faster in practice

✓ Linear Growth

Space Complexity

O(k)

Recursion depth is at most k, and we store current combination of size k

✓ Linear Space

Constraints

2 ≤ k ≤ 9
1 ≤ n ≤ 60
Only digits 1 through 9 can be used
Each digit can be used at most once per combination

58.0K Views

Medium Frequency

~15 min Avg. Time

2.9K 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Backtracking (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler