bit-manipulation

Given an array, arr , of length n , find how many subsets of arr there are such that XOR(^) of those subsets is equal to a given number, ans . I have this dp approach but is there a way to improve its time complexity. ans is always less than 1024. Here ans is the no. such that XOR(^) of the subsets is equal to it. arr[n] contains all the numbers memset(dp, 0, sizeof(dp)); dp[0][0] = 1; for(i = 1; i <= n; i++){ for(j = 0; j < 1024; j++) { dp[i][j] = (dp[i-1][j] + dp[i-1][j^arr[i]]); } } cout << (dp[n][ans]); Mohit Jain From user3386109 's comment, building on top of your code: /* Warning:

Given XOR & SUM of two numbers. How to find the numbers? For example, x = a+b, y = a^b; if x,y are given, how to get a, b? And if can't, give the reason. This cannot be done reliably. A single counter-example is enough to destroy any theory and, in your case, that example is 0, 100 and 4, 96 . Both of these sum to 100 and xor to 100 as well: 0 = 0000 0000 4 = 0000 0100 100 = 0110 0100 96 = 0110 0000 ---- ---- ---- ---- xor 0110 0100 = 100 xor 0110 0100 = 100 Hence given a sum of 100 and an xor of 100 , you cannot know which of the possibilities generated that situation. For what it's worth,

Are there any built in utilities or macros in the objective-c libraries for iOS that will allow you to convert bytes to and from integers with respect to endianess? Please don't tell me to use bit-shifting operations. I am trying to avoid writing custom code to do this if it already exists. I would like the code to convert NSData* to primitive types (int, uint, short, etc) and to convert primitive types back to NSData*. You can get the bytes from NSData by accessing the bytes property. Then just cast that to a pointer to whatever type you want. Obviously you'll need to ensure you know the

Let's say that data is 1011 1001 and the mask is 0111 0110 , then you have: input data: 1011 1001 input mask: 0111 0110 apply mask: 0011 0000 (based on `input mask`) bits selected: -011 -00- (based on `input mask`) right packed: ---0 1100 expected result: 0000 1100 (set left `8 - popcount('input mask')` bits to zero) So the final output is 0000 1100 (note that the 3 positions on the left which are unspecified are zero-filled). You can see that wherever the bits in input mask is 1 the corresponding value in input data is selected (in bits selected above) and then all selected bits are packed

An interesting problem I ran into today: what is the fastest way to count the number of 1s in an n-bit integer? Is it possible to beat O(n)? For example: 42 = 0b101010 => 3 ones 512 = 0b1000000000 => 1 one Clearly, the naive algorithm is to simply count. But, are there any tricks to speed it up? (This is merely an academic question; there is no expected performance gain by implementing such a strategy.) See the fabulous Bit Twiddling Hacks article . Probably the fastest way on x86 processors would be to use the POPCNT class of instructions. The fastest way (without using special processor

In here When converting from bytes buffer back to unsigned long int: unsigned long int anotherLongInt; anotherLongInt = ( (byteArray[0] << 24) + (byteArray[1] << 16) + (byteArray[2] << 8) + (byteArray[3] ) ); where byteArray is declared as unsigned char byteArray[4]; Question: I thought byteArray[1] would be just one unsigned char (8 bit). When left-shifting by 16, wouldn't that shift all the meaningful bits out and fill the entire byte with 0? Apparently it is not 8 bit. Perhaps it's shifting the entire byteArray which is a consecutive 4 byte? But I don't see how that works. In that

This question already has an answer here: How do you set, clear, and toggle a single bit? 27 answers I would like to set the i-th bit to zero no matter what the i-th bit is. unsigned char pt = 0b01100001; pt[0] = 0; // its not how we do this... Setting it to one, we can use a mask pt | (1 << i) but i'm not sure how to create a mask for setting 0, if thats possible. You just have to replace the logical OR with a logical AND operation. You would use the & operator for that: pt = pt & ~(1 << i); You have to invert your mask because logical AND ing with a 1 will maintain the bit while 0 will clear

I have just found that in ES6 there's a new math method: Math.trunc . I have read its description in MDN article , and it sounds like using |0 . Moreover, <<0 , >>0 , &-1 , ^0 also do similar things (thanks @kojiro & @Bergi). After some tests, it seems that the only differences are: Math.trunc returns -0 with numbers in interval (-1,-0] . Bitwise operators return 0 . Math.trunc returns NaN with non numbers. Bitwise operators return 0 . Are there more differences (among all of them)? n | Math.trunc | Bitwise operators ---------------------------------------- 42.84 | 42 | 42 13.37 | 13 | 13 0