Question

This is a trivial algorithmic question, I believe, but I don’t seem to be able to find an efficient and elegant solution.

We have 3 arrays of int (Aa, Ab, Ac) and 3 cursors (Ca, Cb, Cc) that indicate an index in the corresponding array. I want to identify and increment the cursor pointing to the smallest value. If this cursor is already at the end of the array, I will exclude it and increment the cursor pointing to the second smallest value. If there is only 1 cursor that is not at the end of the array, we increment this one.

The only solutions I can come up are complicated and/or not optimal. For example, I always end up with a huge if…else…

Does anyone see a neat solution to this problem ?

I am programming in C++ but feel free to discuss it in pseudo-code or any language you like.

Thank you

Answer 1

Pseudo-java code:

int[] values = new int[3];
values[0] = aa[ca];
values[1] = ab[cb];
values[2] = ac[cc];
Arrays.sort(values);

boolean done = false;
for (int i = 0; i < 3 && !done; i++) {
    if (values[i] == aa[ca] && ca + 1 < aa.length) {
        ca++;
        done = true;
    }
    else if (values[i] == ab[cb] && cb + 1 < ab.length) {
        cb++;
        done = true;
    }
    else if (cc + 1 < ac.length) {
        cc++;
        done = true;
    }
}
if (!done) {
    System.out.println("cannot increment any index");
    stop = true;
}

Essentially, it does the following:

1. initialize an array values with aa[ca], ab[cb] and ac[cc]

2. sort values

3. scan values and increment if possible (i.e. not already at the end of the array) the index of the corresponding value

I know, sorting is at best O(n lg n), but I’m only sorting an array of 3 elements.