Iterate to find all combinations of character array size k (N chooses K)

Here is another iterative solution:

You can create an array of integers of size K to use as a counter to keep track of distances passed through the combination, and a char array to store the current combination.

After printing each one, move on to the next combination by incrementing the counter value, if it "overflows" by reaching a value equal to the number of elements in E, reset it to zero and perform a carry by incrementing the counter In the next position, also check there for overflow and so on. Kind of like an odometer in a car, except the numbers are related to the values ​​in E. Once the last position overflows, all possible combinations are generated.

I increment the counter starting at the last value of the array and move down to get the same output as your example, but that's certainly not required. The algorithm does not check for duplicates.

You don't have to store the character array with the current combination, you can regenerate it each time in a counter-based for loop, but that might be less efficient. This method only updates the changed value.

public static void buildStrings(char[] root, int length)
{
    // allocate an int array to hold the counts:
    int[] pos = new int[length];
    // allocate a char array to hold the current combination:
    char[] combo = new char[length];
    // initialize to the first value:
    for(int i = 0; i < length; i++)
        combo[i] = root[0];

    while(true)
    {
        // output the current combination:
        System.out.println(String.valueOf(combo));

        // move on to the next combination:
        int place = length - 1;
        while(place >= 0)
        {
            if(++pos[place] == root.length)
            {
                // overflow, reset to zero
                pos[place] = 0;
                combo[place] = root[0];
                place--; // and carry across to the next value
            }
            else
            {
                // no overflow, just set the char value and we're done
                combo[place] = root[pos[place]];
                break;
            }
        }
        if(place < 0)
            break;  // overflowed the last position, no more combinations
    }
}

ideone.com demo