Combinations

Combinations - Problem

Backtracking Medium

Given two integers n and k, return all possible combinations of k numbers chosen from the range [1, n].

You may return the answer in any order.

A combination is a selection of items without regard to the order of selection.

Input & Output

Example 1 — Basic Case

$ Input: n = 4, k = 2

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

💡 Note: All possible combinations of 2 numbers from range [1,4]: choose 2 from {1,2,3,4}

Example 2 — Single Element

$ Input: n = 1, k = 1

› Output: [[1]]

💡 Note: Only one way to choose 1 number from range [1,1]: just [1]

Example 3 — Choose All

$ Input: n = 3, k = 3

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

💡 Note: Only one way to choose all 3 numbers from range [1,3]: take everything

Constraints

1 ≤ n ≤ 20
1 ≤ k ≤ n

Visualization

Tap to expand

Asked in

G Google 35 a Amazon 28 M Microsoft 22 f Facebook 18

The key insight is to use backtracking to generate combinations incrementally. Build each combination one number at a time, and when we reach the target size k, add it to the result. Best approach is backtracking with Time: O(C(n,k) × k), Space: O(k).

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force - Generate All Subsets	O(2ⁿ × n)	O(2ⁿ × k)	Generate all possible subsets and filter those with exactly k elements
Backtracking	O(C(n,k) × k)	O(k)	Build combinations incrementally by making choices and backtracking

Brute Force - Generate All Subsets — Algorithm Steps

Generate all possible subsets using bit manipulation
Filter subsets that have exactly k elements
Return the filtered combinations

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate All

Create all possible subsets using bit manipulation

Filter

Keep only subsets with exactly k elements

Result

Return filtered combinations

Code -

solution.c — C

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

void solution(int n, int k) {
    printf("[");
    int first = 1;
    
    // Generate all possible subsets using bit manipulation
    for (int i = 0; i < (1 << n); i++) { // 2^n possibilities
        int subset[20];
        int count = 0;
        
        for (int j = 0; j < n; j++) {
            if (i & (1 << j)) {
                subset[count++] = j + 1;
            }
        }
        
        // Keep only subsets with exactly k elements
        if (count == k) {
            if (!first) printf(",");
            printf("[");
            for (int j = 0; j < count; j++) {
                printf("%d", subset[j]);
                if (j < count - 1) printf(",");
            }
            printf("]");
            first = 0;
        }
    }
    printf("]\n");
}

int main() {
    int n, k;
    scanf("%d", &n);
    scanf("%d", &k);
    solution(n, k);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2ⁿ × n)

Generate 2^n subsets, each taking O(n) time to process

✓ Linear Growth

Space Complexity

O(2ⁿ × k)

Store all subsets before filtering, each combination takes O(k) space

✓ Linear Space

32.0K Views

Medium Frequency

~15 min Avg. Time

890 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

Brute Force - Generate All Subsets — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler