如何使用位操作找到第5位，并以整数形式返回1位的数目

Question

Assume Z is an unsigned integer. Using ~, <<, >>, &, | , +, and - provide statements which return the desired result.

I am allowed to introduce new binary values if needed.

I have these problems:

1.Extract the 5th bit from the left Z.

For this I was thinking about doing something like

  x x x x x x x x 
& 0 0 0 0 1 0 0 0 
___________________

  0 0 0 0 1 0 0 0 

Does this make sense for extracting the fifth bit? I am not totally sure how I would make this work by using just Z when I do not know its values. (I am relatively new to all of this). Would this type of idea work though?

2.Return the number of 1 bits in Z

Here I kind of have no idea how to work this out. What I really need to know is how to work on just Z with the operators, but I m not sure exactly how to. 

Like I said I am new to this, so any help is appreciated.

Answer 1

Problem 1

You're right on the money. I'd do an & and a >> so that you get either a nice 0 or 1.

result = (z & 0x08) >> 3;

However, this may not be strictly necessary. For example, if you're trying to check whether the bit is set as part of an if conditional, you can exploit C's definition of anything nonzero as true.

if (z & 0x08)
        do_stuff();

Problem 2

There are a whole variety of ways to do this. According to that page, the following methodology dates from 1960, though it wasn't published in C until 1988.

for (result = 0; z; result++)
        z &= z - 1;

Exactly why this works might not be obvious at first, but if you work through a few examples, you'll quickly see why it does.

It's worth noting that this operation – determining the number of 1 bits in a number – is sufficiently important to have a name (population count or Hamming weight ) and, on recent Intel and AMD processors, a dedicated instruction . If you're using GCC, you can use the __builtin_popcount intrinsic.

Answer 2

Problem 1 looks right, except you should finish it by shifting the result right by 4 to get that bit after the mask.

To implement the mask, you need to know what integer is represented by a single 5th bit. That number is incidentally 2^5 = 32. So you can just AND z with 32 and shift it right by 4.

Problem 2:

int answer = 0;
while (z != 0){  //stop when there are no more 1 bits in z

   //the following masks the lowest bit in z and adds it into answer
   //if z ends with a 0, nothing is added, otherwise 1 is added
   answer += (z & 1);
   //this shifts z right by 1 to get the next higher bit
   z >>= 1;
}
return answer;

Answer 3

To find out the value of the fifth bit, you don't care about the bottom bits so you can get rid of them:

unsigned int answer = z >> 4;

The fifth bit becomes the bottom bit, so you can strip it off with a bitwise-AND:

answer = answer & 1;

To find the number of 1-bits in a number you can apply stakSmashr's solution. You could optimise this further if you know you need to count the number of bits in a lot of integers - precompute the number of bits in every possible 8-bit number and store it in a table. There will only be 256 entries in the table so it won't use much memory. Then, you can loop over your data one byte at a time and find the answer from the table. This lookup will be quicker than looping again over each bit.