Iterator for Combination solution and explanation

from itertools import combinations

class CombinationIterator:
    def __init__(self, characters: str, combinationLength: int):
        self.combinations = list(combinations(characters, combinationLength))
        self.index = 0

    def next(self) -> str:
        comb = self.combinations[self.index]
        self.index += 1
        return ''.join(comb)

    def hasNext(self) -> bool:
        return self.index < len(self.combinations)

#include <vector>
#include <string>
#include <algorithm>

class CombinationIterator {
    std::vector<std::string> combinations;
    size_t index;

    void generate(const std::string& str, int combinationLength) {
        std::string combination;
        generateCombinations(str, combinationLength, 0, combination);
    }

    void generateCombinations(const std::string& str, int length, int start, std::string& combination) {
        if (length == 0) {
            combinations.push_back(combination);
            return;
        }
        for (int i = start; i <= str.size() - length; ++i) {
            combination.push_back(str[i]);
            generateCombinations(str, length - 1, i + 1, combination);
            combination.pop_back();
        }
    }

public:
    CombinationIterator(std::string characters, int combinationLength) : index(0) {
        generate(characters, combinationLength);
    }

    std::string next() {
        return combinations[index++];
    }

    bool hasNext() {
        return index < combinations.size();
    }
};

class CombinationIterator {
    constructor(characters, combinationLength) {
        this.characters = characters;
        this.combinationLength = combinationLength;
        this.combinations = [];
        this.currentIndex = 0;
        this._generateCombinations('', 0);
    }

    _generateCombinations(prefix, start) {
        if (prefix.length === this.combinationLength) {
            this.combinations.push(prefix);
            return;
        }
        for (let i = start; i < this.characters.length; i++) {
            this._generateCombinations(prefix + this.characters[i], i + 1);
        }
    }

    next() {
        return this.combinations[this.currentIndex++];
    }

    hasNext() {
        return this.currentIndex < this.combinations.length;
    }
}

public class CombinationIterator {
    private string characters;
    private int combinationLength;
    private int[] indices;
    private bool hasCombination;

    public CombinationIterator(string characters, int combinationLength) {
        this.characters = characters;
        this.combinationLength = combinationLength;
        this.indices = new int[combinationLength];
        for (int i = 0; i < combinationLength; i++) {
            indices[i] = i;
        }
        hasCombination = true;
    }

    public string Next() {
        if (!hasCombination) return null;
        char[] combination = new char[combinationLength];
        for (int i = 0; i < combinationLength; i++) {
            combination[i] = characters[indices[i]];
        }
        getNextIndices();
        return new string(combination);
    }

    private void getNextIndices() {
        int n = characters.Length;
        for (int i = combinationLength - 1; i >= 0; i--) {
            if (indices[i] != i + n - combinationLength) {
                indices[i]++;
                for (int j = i + 1; j < combinationLength; j++) {
                    indices[j] = indices[j - 1] + 1;
                }
                return;
            }
        }
        hasCombination = false;
    }

    public bool HasNext() {
        return hasCombination;
    }
}

class CombinationIterator {
    private int n;
    private int combinationLength;
    private String characters;
    private StringBuilder t = new StringBuilder();
    private List<String> cs = new ArrayList<>();
    private int idx = 0;

    public CombinationIterator(String characters, int combinationLength) {
        n = characters.length();
        this.combinationLength = combinationLength;
        this.characters = characters;
        dfs(0);
    }

    public String next() {
        return cs.get(idx++);
    }

    public boolean hasNext() {
        return idx < cs.size();
    }

    private void dfs(int i) {
        if (t.length() == combinationLength) {
            cs.add(t.toString());
            return;
        }
        if (i == n) {
            return;
        }
        t.append(characters.charAt(i));
        dfs(i + 1);
        t.deleteCharAt(t.length() - 1);
        dfs(i + 1);
    }
}

/**
 * Your CombinationIterator object will be instantiated and called as such:
 * CombinationIterator obj = new CombinationIterator(characters, combinationLength);
 * String param_1 = obj.next();
 * boolean param_2 = obj.hasNext();
 */

type CombinationIterator struct {
	cs  []string
	idx int
}

func Constructor(characters string, combinationLength int) CombinationIterator {
	t := []byte{}
	n := len(characters)
	cs := []string{}
	var dfs func(int)
	dfs = func(i int) {
		if len(t) == combinationLength {
			cs = append(cs, string(t))
			return
		}
		if i == n {
			return
		}
		t = append(t, characters[i])
		dfs(i + 1)
		t = t[:len(t)-1]
		dfs(i + 1)
	}
	dfs(0)
	return CombinationIterator{cs, 0}
}

func (this *CombinationIterator) Next() string {
	ans := this.cs[this.idx]
	this.idx++
	return ans
}

func (this *CombinationIterator) HasNext() bool {
	return this.idx < len(this.cs)
}

/**
 * Your CombinationIterator object will be instantiated and called as such:
 * obj := Constructor(characters, combinationLength);
 * param_1 := obj.Next();
 * param_2 := obj.HasNext();
 */