Iterator for Combination

Iterator for Combination - Problem

Design a CombinationIterator class that generates all combinations of a given length from a sorted string of distinct characters.

Your class should implement:

CombinationIterator(string characters, int combinationLength) - Initializes the object with a string of sorted distinct lowercase English letters and the desired combination length.
next() - Returns the next combination of the specified length in lexicographical order.
hasNext() - Returns true if and only if there exists a next combination.

Note: You may assume that there is always a next combination when next() is called.

Input & Output

Example 1 — Basic Case

$ Input: operations = ["CombinationIterator", "next", "hasNext", "next", "hasNext", "next", "hasNext"], parameters = [["abc", 2], [], [], [], [], [], []]

› Output: [null, "ab", true, "ac", true, "bc", false]

💡 Note: Create iterator for combinations of length 2 from 'abc'. Returns 'ab', then 'ac', then 'bc'. After 'bc', no more combinations exist.

Example 2 — Single Character Combinations

$ Input: operations = ["CombinationIterator", "next", "hasNext", "next", "hasNext"], parameters = [["abcd", 1], [], [], [], []]

› Output: [null, "a", true, "b", true]

💡 Note: Iterator for single character combinations from 'abcd'. Returns each character in order: 'a', 'b', etc.

Example 3 — Full Length Combination

$ Input: operations = ["CombinationIterator", "next", "hasNext"], parameters = [["xyz", 3], [], []]

› Output: [null, "xyz", false]

💡 Note: Only one combination possible when length equals string length: the string itself.

Constraints

1 ≤ combinationLength ≤ characters.length ≤ 15
characters consists of distinct lowercase English letters
At most 10⁴ calls will be made to next and hasNext

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 f Facebook 8 M Microsoft 6

The key insight is to generate combinations in lexicographical order either by pre-generating all combinations or by maintaining state indices. The pre-generation approach trades memory for speed, while the backtracking approach saves memory at the cost of computation. Best approach depends on usage pattern: Time: O(C(n,k)) for generation, Space: O(C(n,k)) for storage vs O(k) for state-based.

Common Approaches

✓ Bit Manipulation

⏱️ Time: N/A Space: N/A

Backtracking with State Management

⏱️ Time: O(k) Space: O(k)

Instead of pre-generating all combinations, maintain the current state and use backtracking to generate the next combination when needed. This approach saves memory but requires more complex state management.

Pre-generate All Combinations

⏱️ Time: O(C(n,k)) Space: O(C(n,k))

Generate all possible combinations of the given length using backtracking during initialization, store them in a list, and use an index to track the current position for next() and hasNext() operations.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

⚡ Linearithmic Space

32.0K Views

Medium Frequency

~25 min Avg. Time

856 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