Iterator for Combination - Practice Coding Problems

Iterator for Combination - Problem

Design a Custom Iterator for String Combinations

You need to implement a CombinationIterator class that generates all possible combinations of a given length from a sorted string of distinct characters. The combinations should be returned in lexicographical order.

Your class should support:
• CombinationIterator(characters, combinationLength) - Initialize with a sorted string and target length
• next() - Return the next combination in lexicographical order
• hasNext() - Check if more combinations exist

For example, with characters "abc" and length 2, you should generate: "ab", "ac", "bc" in that exact order.

This is a classic iterator pattern problem that tests your understanding of combinations, backtracking, and efficient state management.

Input & Output

example_1.py — Basic Usage

$ Input: CombinationIterator iterator = new CombinationIterator("abc", 2); iterator.next(); iterator.hasNext(); iterator.next(); iterator.hasNext(); iterator.next(); iterator.hasNext();

› Output: "ab" true "ac" true "bc" false

💡 Note: Starting with "abc" and length 2, we generate combinations in lexicographical order: "ab", "ac", "bc". After returning all combinations, hasNext() returns false.

example_2.py — Single Character Combinations

$ Input: CombinationIterator iterator = new CombinationIterator("abcd", 1); iterator.next(); iterator.next(); iterator.next(); iterator.next(); iterator.hasNext();

› Output: "a" "b" "c" "d" false

💡 Note: With combination length 1, each character forms its own combination. We get "a", "b", "c", "d" in order.

example_3.py — Maximum Length

$ Input: CombinationIterator iterator = new CombinationIterator("abc", 3); iterator.next(); iterator.hasNext();

› Output: "abc" false

💡 Note: When combination length equals string length, there's only one possible combination: the entire string. After returning it, no more combinations exist.

Constraints

1 ≤ combinationLength ≤ characters.length ≤ 15
characters consists of distinct lowercase English letters
characters is sorted in ascending order
At most 10⁴ calls will be made to next and hasNext
It is guaranteed that all calls to next are valid

Visualization

Tap to expand

Understanding the Visualization

Initialize State

Set up indices array [0,1] for first combination "ab"

Generate Next

Find rightmost incrementable position and update to [0,2] for "ac"

Continue Pattern

Apply same logic to get [1,2] for "bc"

Detect End

When no position can be incremented, hasNext() returns false

Key Takeaway

🎯 Key Insight: Use indices array to represent combinations and apply next-permutation logic for O(k) space complexity with true lazy evaluation.

Asked in

G Google 45 ⊞ Microsoft 38 a Amazon 32 Apple 28

The optimal solution uses on-demand backtracking with state management. Instead of pre-generating all combinations, maintain an indices array that represents the current combination positions. Use a next-permutation-like algorithm to compute the next lexicographical combination in O(k) time and O(k) space. This provides true lazy evaluation and scales well for large inputs.

Common Approaches

Approach	Time	Space	Notes
✓ On-Demand Backtracking (Optimal)	O(k)	O(k)	Generate combinations lazily using backtracking with state management
Pre-generate All Combinations	O(C(n,k) * k)	O(C(n,k) * k)	Generate all combinations at initialization and store them in a list

On-Demand Backtracking (Optimal) — Algorithm Steps

Initialize with characters and target length, set up initial state
For next(), use backtracking to generate the next valid combination
Maintain current positions/indices to track state between calls
For hasNext(), check if we can generate more combinations from current state
Use lexicographical ordering by trying characters in sorted order

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Set up indices array pointing to first combination positions

Generate

Build current combination from indices, then compute next state

State Update

Find rightmost incrementable index and update subsequent positions

Code -

solution.c — C

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

typedef struct {
    char* chars;
    int k, n;
    int* indices;
    bool hasNextFlag;
} CombinationIterator;

void generateNext(CombinationIterator* ci) {
    int i = ci->k - 1;
    while (i >= 0 && ci->indices[i] == ci->n - ci->k + i) {
        i--;
    }
    
    if (i < 0) {
        ci->hasNextFlag = false;
        return;
    }
    
    ci->indices[i]++;
    for (int j = i + 1; j < ci->k; j++) {
        ci->indices[j] = ci->indices[j - 1] + 1;
    }
}

CombinationIterator* combinationIteratorCreate(char* characters, int combinationLength) {
    CombinationIterator* ci = malloc(sizeof(CombinationIterator));
    ci->chars = strdup(characters);
    ci->k = combinationLength;
    ci->n = strlen(characters);
    ci->indices = malloc(combinationLength * sizeof(int));
    ci->hasNextFlag = true;
    
    for (int i = 0; i < combinationLength; i++) {
        ci->indices[i] = i;
    }
    
    return ci;
}

char* combinationIteratorNext(CombinationIterator* obj) {
    if (!obj->hasNextFlag) return "";
    
    char* result = malloc((obj->k + 1) * sizeof(char));
    for (int i = 0; i < obj->k; i++) {
        result[i] = obj->chars[obj->indices[i]];
    }
    result[obj->k] = '\0';
    
    generateNext(obj);
    return result;
}

bool combinationIteratorHasNext(CombinationIterator* obj) {
    return obj->hasNextFlag;
}

Time & Space Complexity

Time Complexity

⏱️

O(k)

Each next() call takes O(k) time to generate next combination

✓ Linear Growth

Space Complexity

O(k)

Only stores current state and combination being built

✓ Linear Space

42.3K Views

Medium Frequency

~25 min Avg. Time

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

On-Demand Backtracking (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler