从有限列表中轻松选择

Question

I have three variables that need to be set in a certain way. For example,

int a, b, c;
a = choose(1, 2,  3);   // a can take the value 1 to 3 inclusive
b = choose(1, 2,  3);   // b can take the value 1 to 3 inclusive
c = ??????              // c can't take either of the values in a or b.

The easiest way I can think of for setting c is to use a loop:

do
{
    c = choose(1, 2,  3);
}
while(c == a || c == b);

Alternatively I could use ifs or a switch, or a switch/if combo:

a = choose(1, 2,  3);   
b = choose(1, 2,  3);   

switch(a){
    case 1:
        switch(b){
            case 1:
                c = choose(2, 3)
                break;
            case 2:
                c = 3;
                break;
            case 3:
                c = 2;
                break;
        }
        break;
    case 2:
        …

Neither of these seems elegant, and the latter is just bloody ugly.

I had another similar situation in a project where I've used std::set and set_difference , but I can't use that here, and have to use a rather less STL like and more old school C++ solution.

Any ideas please?

Answer 1

You may consider this, as an improvement (elegance-wise) of your second solution:

switch ((1<<a)|(1<<b))
{
    case  2: // a,b == 1,1
        c = choose(2,3);
        break;
    case  4: // a,b == 2,2
        c = choose(1,3);
        break;
    case  6: // a,b == 1,2 or 2,1
        c = 3;
        break;
    case  8: // a,b == 3,3
        c = choose(1,2);
        break;
    case 10: // a,b == 1,3 or 3,1
        c = 2;
        break;
    case 12: // a,b == 2,3 or 3,2
        c = 1;
        break;
}

You can further improve it by mapping two values to choose from, for each value of (1<<a)|(1<<b) :

static int first[]  = {2,1,3,1,2,1};
static int second[] = {3,3,3,2,2,1};
int index = ((1<<a)|(1<<b))/2-1; // reduce from [2,4,6,8,10,12] to [0,1,2,3,4,5]
c = choose(first[index],second[index]);

And there you have an elegant solution without switch , while or any other conditional statement...

Answer 2

Edit

On second look, it makes more sense to pick the unique element first , followed by the other two. It's cleaner this way, though maybe still not elegant.

If you stick with the discrete variable implementation of choose , it might look something like this:

int choose(int, int); // two choice overload
int choose(int, int, int); // three choice overload

int main()
{
    int c = choose(1, 2, 3);

    int x = 1 + c % 3;
    int y = 1 + (c + 1) % 3;

    int a = choose(x, y);
    int b = choose(x, y);
}

Using an array is even cleaner and can be made a little more general with little effort:

int choose(int[], int); // takes an array and its (effective) size

int main()
{
    constexpr int maxNum = 3;

    int choices[maxNum] = {1, 2, 3};

    //for larger values of maxNum, loop initialize:
    //for(int i = 0; i < maxNum; i++)
    //{
    //    choices[i] = i + 1;
    //}

    int c = choose(choices, maxNum);

    choices[c-1] = maxNum;

    int a = choose(choices, maxNum - 1);
    int b = choose(choices, maxNum - 1);
}

---

For only three variables, I would take the simplest approach and use the while loop you posted:

do
{
    c = choose(1, 2,  3);
}
while(c == a || c == b);

If you really need that guarantee of deterministic run-time, you could try something like the following. However, I'm not sure everyone would find it more "elegant" and I don't think the maintainability hit is worth it.

if(a != b)
{
    c = 6 - (a + b);
}
else
{
    c = choose(0, 1);

    c = 1 + (a + c) % 3;
}

Neither is all that scalable given how the question is set up, but until a need to make it more general arises, I'd assume YAGNI .

Answer 3

Do you really just have 3 values like this or is this a minimized example? For this case I'd straight-forward exclude taken values

int a, b, c;
a = choose(1, 2,  3);   // a can take the value 1 to 3 inclusive
b = choose(1, 2,  3);   // b can take the value 1 to 3 inclusive
c = 1;
if(a == c || b == c)
  c = 2;
if(a == c || b == c)
  c = 3;

If the values are 1,2,3 you could replace that with a while loop that does c++ similar to yours:

c = 1;
while(a == c || b == c)
    c++;

If c needs to be chosen the while loop you presented seems fine to me.

Answer 4

An easy solution would be to pass a linked list (by reference) into the choose function. An element that is chosen would be removed from the list and returned. Subsequent calls to the function would have fewer and fewer elements to choose from.

You would have to take note of when the list is empty and handle it accordingly.

If a and b are allowed to be the same, then choose would not be the function you are using for determining c . In that case, have a separate function chooseC that takes a list of chosen values (by constant reference) and a list of available values (by value). Remove the chosen values from the available values, and pick from what is left.

Answer 5

Maybe something like this:

int a, b, c;
int myList[]= {1, 2, 3};

a = choose(myList);   // if choose can take a list as input
b = choose(myList);

myList.remove(a);
myList.remove(b);

c = choose(myList);  // the selection from a and b are out of the list at this point

This solution ensures that

a != b && a != c