bit-manipulation

I saw the following line of code here in C. int mask = ~0; I have printed the value of mask in C and C++. It always prints -1 . So I do have some questions: Why assigning value ~0 to the mask variable? What is the purpose of ~0 ? Can we use -1 instead of ~0 ? It's a portable way to set all the binary bits in an integer to 1 bits without having to know how many bits are in the integer on the current architecture. C and C++ allow 3 different signed integer formats: sign-magnitude, one's complement and two's complement ~0 will produce all-one bits regardless of the sign format the system uses. So

I've got the following task: Compute x/(2^n) , for 0 <= n <= 30 using bit shifting. Requirement: Round toward zero. Examples: divpwr2(15,1) = 7 divpwr2(-33,4) = -2 Legal operators: ! ~ & ^ | + << >> Maximum number of operators: 15 Here is what I've got so far: public int DivideByPowerOf2(int x, int n) { //TODO: find out why DivideByPowerOf2(-33,4) = -3 instead of -2 return x >> n; } DivideByPowerOf2(15,1) = 7 is ok. But DivideByPowerOf2(-33,4) = -3 instead of -2. Why? Kurt Price After looking for a good answer myself, I stumbled across this and was able to get a working snippet. Let me help

unsigned reverse_bits(unsigned input) { //works on 32-bit machine input = (input & 0x55555555) << 1 | (input & 0xAAAAAAAA) >> 1; input = (input & 0x33333333) << 2 | (input & 0xCCCCCCCC) >> 2; input = (input & 0x0F0F0F0F) << 4 | (input & 0xF0F0F0F0) >> 4; input = (input & 0x00FF00FF) << 8 | (input & 0xFF00FF00) >> 8; input = (input & 0x0000FFFF) << 16 | (input & 0xFFFF0000) >> 16; return input; } how does this work? Suppose I have a hand of 8 cards: 7 8 9 10 J Q K A How can we reverse them? One way is to swap adjacent pairs: 8 7 10 9 Q J A K Then, swap adjacent groups of 2: exchange 8 7 and 10

I need to shuffle a 16 bit unsigned integer in a way that the even indexes land in the lower byte, and the odd indexes land in the upper byte. input: fedcba98 76543210 (contiguously numbered) output: fdb97531 eca86420 (even and odd separated) My code looks like this at the moment: typedef unsigned short u16; u16 segregate(u16 x) { u16 g = (x & 0x0001); u16 h = (x & 0x0004) >> 1; u16 i = (x & 0x0010) >> 2; u16 j = (x & 0x0040) >> 3; u16 k = (x & 0x0100) >> 4; u16 l = (x & 0x0400) >> 5; u16 m = (x & 0x1000) >> 6; u16 n = (x & 0x4000) >> 7; u16 o = (x & 0x0002) << 7; u16 p = (x & 0x0008) << 6;

i am interested on this problem Interleave bits the obvious way (from http://graphics.stanford.edu/~seander/bithacks.html ) unsigned short x; // Interleave bits of x and y, so that all of the unsigned short y; // bits of x are in the even positions and y in the odd; unsigned int z = 0; // z gets the resulting Morton Number. for (int i = 0; i < sizeof(x) * CHAR_BIT; i++) // unroll for more speed... { z |= (x & 1U << i) << i | (y & 1U << i) << (i + 1); } can someone explain to me how this works with an example? for example if we have x = 100101 and y = 010101 , what will be result?

I had been studying the algorithm for finding lonely integers in an array, and here is the implementation: int arr[] = {10, 20, 30, 5, 20, 10, 30}; int LonelyInteger = 0; for(int i=0; i< 7; i++) { LonelyInteger = LonelyInteger ^ arr[i]; } The result is 5 . My question is - supposedly the integers (getting generated by the XOR operation) are too large due to this operation: LonelyInteger ^ arr[i] Which leads to a potentially large integer which cannot be represented by the datatype say int in this case. My questions are: Is it even possible that XOR will generate such a large integer value that