Codestin Search App

Combinations - Problem

Backtracking Medium

Imagine you're organizing a team selection process where you need to pick exactly k people from a group of n candidates numbered from 1 to n. Your task is to generate all possible team combinations that can be formed.

Given two integers n and k, return all possible combinations of k numbers chosen from the range [1, n]. The order of combinations in your result doesn't matter, but each combination should contain unique numbers.

Example: If n=4 and k=2, you could form teams like [1,2], [1,3], [1,4], [2,3], [2,4], [3,4] - that's 6 different combinations!

Input & Output

example_1.py — Basic Combination

$ Input: n = 4, k = 2

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

💡 Note: All possible ways to choose 2 numbers from [1,2,3,4]. We get C(4,2) = 6 combinations total.

example_2.py — Single Element

$ Input: n = 1, k = 1

› Output: [[1]]

💡 Note: Only one way to choose 1 number from [1] - the combination [1] itself.

example_3.py — Larger Set

$ Input: n = 5, k = 3

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

💡 Note: All possible ways to choose 3 numbers from [1,2,3,4,5]. We get C(5,3) = 10 combinations total.

Constraints

1 ≤ k ≤ n ≤ 20
k cannot exceed n (you can't choose more items than available)
Output size grows exponentially - C(n,k) can be up to C(20,10) = 184,756

Visualization

Tap to expand

Understanding the Visualization

Start Empty

Begin with an empty team and list of all available players [1,2,3,4]

Fill Positions

For position 1, try player 1, then explore all possibilities for position 2

Complete & Backtrack

When team is full (k players), save it. Then backtrack and try next player

Systematic Exploration

Continue until all possible team combinations are found

Key Takeaway

🎯 Key Insight: Backtracking with ordered selection ensures we generate all unique combinations exactly once, while pruning optimizations eliminate impossible paths early for better performance.

Asked in

G Google 45 a Amazon 38 ⊞ Microsoft 32 f Meta 28

The optimal solution uses backtracking with pruning to generate all combinations efficiently. Key insights: build combinations incrementally, maintain sorted order to avoid duplicates, and prune branches early when it's impossible to complete a valid combination. Time complexity is O(C(n,k) × k) which is optimal since we must generate all C(n,k) combinations.

Common Approaches

Approach	Time	Space	Notes
✓ Optimized Backtracking	O(C(n,k) * k)	O(C(n,k) * k + k)	Efficient backtracking with early termination and pruning optimizations

Optimized Backtracking — Algorithm Steps

Start building combination from number 1
For each position, try numbers from current position to n
Prune early: if remaining numbers + current combination < k, skip
When combination size equals k, add to result
Backtrack by removing last number and continue with next option
Use optimizations to reduce unnecessary recursive calls

Visualization

Tap to expand

Step-by-Step Walkthrough

Start & Prune

Begin with [], check if we can reach k=2 from each starting position

Build Systematically

For [1], we need 1 more number from {2,3,4} - all possible

Early Termination

For [2], we need 1 more from {3,4} - still possible

Pruning in Action

For [4], we need 1 more but no numbers left - prune this branch!

Code -

solution.c — C

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

#define MAX_RESULTS 10000
#define MAX_K 20

int results[MAX_RESULTS][MAX_K];
int resultSizes[MAX_RESULTS];
int resultCount = 0;
int current[MAX_K];
int currentSize = 0;

void backtrack(int start, int n, int k) {
    // Pruning: if we can't complete combination even with all remaining numbers
    if (currentSize + (n - start + 1) < k) {
        return;
    }
    
    // Base case: found a valid combination
    if (currentSize == k) {
        for (int i = 0; i < k; i++) {
            results[resultCount][i] = current[i];
        }
        resultSizes[resultCount] = k;
        resultCount++;
        return;
    }
    
    // Try each number from start to n
    for (int i = start; i <= n; i++) {
        current[currentSize] = i;
        currentSize++;
        backtrack(i + 1, n, k);
        currentSize--;
    }
}

int main() {
    int n, k;
    char input[100];
    fgets(input, sizeof(input), stdin);
    sscanf(input, "{\"n\":%d,\"k\":%d}", &n, &k);
    
    resultCount = 0;
    currentSize = 0;
    backtrack(1, n, k);
    
    printf("[");
    for (int i = 0; i < resultCount; i++) {
        printf("[");
        for (int j = 0; j < resultSizes[i]; j++) {
            printf("%d", results[i][j]);
            if (j < resultSizes[i] - 1) printf(",");
        }
        printf("]");
        if (i < resultCount - 1) printf(",");
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(C(n,k) * k)

We generate exactly C(n,k) combinations, and each takes O(k) time to construct. The pruning optimization doesn't change worst-case but improves average performance.

✓ Linear Growth

Space Complexity

O(C(n,k) * k + k)

We store C(n,k) combinations each of size k, plus O(k) space for recursion stack depth

⚡ Linearithmic Space

52.0K Views

High Frequency

~15 min Avg. Time

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

Constraints

Visualization

Related Problems

Common Approaches

Optimized Backtracking — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler