Truth table as the keys for a dictionary

Question

I have six boolean flags that are independent of each other so there are 64 possible combinations. These flags should determine the value of some string. This string can have seven different values. I think implementing this as a large if-statement is a bad idea so I thought of creating a truth table where each combination determines a specific outcome:

Key            Value
0,0,0,0,0,0 -> "A"
0,0,0,0,0,1 -> "A"
0,0,0,0,1,0 -> "B"
0,0,0,0,1,1 -> "C"
0,0,0,1,0,0 -> "A"
...

This looks remarkably like a dictionary but what would be the best key implementation (in C#)? The smallest possible key would be a byte that I mask the options into. However, this wouldn't improve the readability of my code.

Are there other solutions for this?

Answer 1

The simplest way:

struct KeyThing
{
  public int a,b,c,d,e,f;
}

The preferred way would be using bitmasks.

Answer 2

You could represent the 6 bool options as an enum with the FlagsAttribute, and rely on the readability of your enum names.

Edit, for example:

[Flags]
enum MyFlagSet : byte
{
    NoFlags = 0,
    Flag1 = 1 << 0,
    Flag2 = 1 << 1,
    Flag3 = 1 << 2,
    Flag4 = 1 << 3,
    Flag5 = 1 << 4,
    Flag6 = 1 << 5
};

Dictionary MyDictionary = new Dictionary<MyFlagSet, string>()
                          {
                              {MyFlagSet.NoFlags, "Q"},
                              {MyFlagSet.Flag1 | MyFlagSet.Flag2, "A"},
                              {MyFlagSet.Flag3 | MyFlagSet.Flag5 | MyFlagSet.Flag6, "B"}
                          };

Answer 3

You could create an enum with the FlagsAttribute, which may make your code easier to read, but you will have to make up 64 names!

Answer 4

Use a bitmask to create a int and store your values in a regular hash?

ie:
0,0,0,0,0,0 = 0
0,0,0,0,0,1 = 1
0,0,0,0,1,0 = 2

and then hash[0] = "a" and so on

Answer 5

If you encapuslate the six-booleans-to-string function into a separate class, then the readability of the code becomes trivially improved regardless of the implementation details. And the implementation can change based on performance needs that arise.

(I am going to make up a name to illustrate.)

public static class RobotEmotionDescriptions
{
    public static string GetDescription(bool isHurting, bool isAwake, 
           bool isBrightlyLit, bool isInQuitePlace, bool isPlayingChess, 
           bool isTumpedOver)
    {
        ... // Details don’t matter.
    }
}

So I think the bitmapped byte would be an excellent first-pass to an implementation.

Answer 6

You could represent your bool options as strings, e.g.
“011011”
then just use a Dictionary

(this may be a good option if you wish to let the user change the mappings, as reading strings from a file is easy)

However if you will be using them much, use a flags enum as per Luke’s answer.