Adjusting integer based on multiple elements in int array

Question

I'm working with the following code which adjusts an int based on multiple elements of an integer array. I am wondering if there's a cleaner, easier-to-read construct for this:

int Blue = 0;
int[] Adjustments = new int[24];
// ... populate Adjustments

if (Adjustments[0] == 255)
    Blue = 128;
else if (Adjustments[0] == 0)
    Blue = 0;

if (Adjustments[1] == 255)
    Blue += 64;
else if (Adjustments[1] == 0)
    Blue += 0;

if (Adjustments[2] == 255)
    Blue += 32;
else if (Adjustments[2] == 0)
    Blue += 0;

if (Adjustments[3] == 255)
    Blue += 16;
else if (Adjustments[3] == 0)
    Blue += 0;

if (Adjustments[4] == 255)
    Blue += 8;
else if (Adjustments[4] == 0)
    Blue += 0;

if (Adjustments[5] == 255)
    Blue += 4;
else if (Adjustments[5] == 0)
    Blue += 0;

if (Adjustments[6] == 255)
    Blue += 2;
else if (Adjustments[6] == 0)
    Blue += 0;

if (Adjustments[7] == 255)
    Blue += 1;
else if (Adjustments[7] == 0)
    Blue += 0;

Any suggestions?

---

Edit

Here is the revised version based on suggestions provided:

Blue = 0;
Green = 0;
Red = 0;
int[] Adjustments = new int[24];
// ... populate Adjustments

int[] AdjustmentStops = new[] { 128, 64, 32, 16, 8, 4, 2, 1 };
for (int i = 0; i < 8; i++)
{
    Blue += Adjustments[i] == 255 ? AdjustmentStops[i] : 0;
    Green += Adjustments[i + 8] == 255 ? AdjustmentStops[i] : 0;
    Red += Adjustments[i + 12] == 255 ? AdjustmentStops[i] : 0;
}

Answer 1

How about the following?

int Blue = 0;
int[] Adjustments = new int[ 24 ];
int[] BlueAdditions = new int[] { 128, 64, 32, 16, 8, 4, 2, 1 };
// ... populate Adjustments

for ( int i = 0; i < 8; ++i )
{
    if ( Adjustments[ i ] == 255 )
    {
        Blue += BlueAdditions[ i ];
    }
}

Why do you do Blue += 0? That's pretty pointless, so I removed those.

Furthermore, why is Adjustments 24 items long? I'm guessing you use the other items at a later moment, if you don't, you can remove the magic number 8 and change it to Adjustments.Length.

Answer 2

At the risk of being 'clever':

int Blue = 0;
int[] Adjustments = new int[24];
// ... populate Adjustments 

for (int blueIndex=0; blueIndex<8; blueIndex++)
{
   if (Adjustments[blueIndex] == 255)
   {
      Blue |= (1 << (7 - blueIndex));
   }
}

Since in effect you're setting bits anyway I think using bitwise operations is idiomatic here.

Answer 3

Blue = 0; Red = 0; Green = 0;
for(int i = 0; i < 8; i++)
{
    Blue   |= (Adjustments[i] / 255) * (1 << (i-7));
    Red    |= (Adjustments[i+8] / 255) * (1 << (i-7));
    Green  |= (Adjustments[i+16] / 255) * (1 << (i-7));
}

Or

Blue = 0; Red = 0; Green = 0;
a = 1;
for(int i = 7; i >= 0; i--)
{
    Blue   |= (Adjustments[i] / 255) * a;
    Red    |= (Adjustments[i+8] / 255) * a;
    Green  |= (Adjustments[i+16] / 255) * a;
    a = a << 1;
}

Answer 4

Although perhaps less efficient, any time I see an array being used as a half-assed object, I'm inclined to make an object.

struct ColorAdjustment {
    public int Red;
    public int Blue;
    public int Green; 
}

Then make an array of 8 of those.

But since you're only checking two values (255 or 0) a set of bools would be even better. But since you're just doing bit math, @jon_darkstar's answer is even better still because it just does that math directly.

But best of all would probably be to use a BitArray or to do bit boolean logic on a 24-bit value (or an Int32, if you don't mind wasted space) to indicate the state of adjustments, as:

Int24 adjustments = 0xBEAF;
for(int i = 0; i < 8; i++) {
    if((adjustments && (1 << i)) != 0)
        ...do blue stuff...
    if((adjustments && (1 << (i + 8))) != 0)
        ...do red stuff...
...

Edit: Hah, and I just realized I ran the full gamut from clear, object based code to fiddly bit-based code.