#bit operation

Java : Bitwise Logical Operators

Java supports several bitwise operators, which can be applied to the integer types, long, int, short, char, and byte. These Bitwise operator works on bits and performs the bit-by-bit operation.

For Example: Assume if a = 60 and b = 13; now in the binary format they will define follows:

a = 0011 1100 b = 0000 1101 ----------------- a&b = 0000 1100 a|b = 0011 1101 a^b = 0011 0001 ~a = 1100 0011

H…

Java : Bitwise Logical Operators

Java supports several bitwise operators, which can be applied to the integer types, long, int, short, char, and byte. These Bitwise operator works on bits and performs the bit-by-bit operation.

For Example: Assume if a = 60 and b = 13; now in the binary format they will define follows:

a = 0011 1100 b = 0000 1101 ----------------- a&b = 0000 1100 a|b = 0011 1101 a^b = 0011 0001 ~a = 1100 0011

H…

Given an array of integers, every element appears twice except for one. Find that single one.

This is a bit operation trick, thinking an integer as a bit vector. For any bit value x, x ^ x = 0. It means that all the integers appears twice will turns back to zero when doing a XOR operation. And the final result is the single one.

Given an array of integers, every element appears three times except for one. Find that single one.

I didn't get the solution myself, but found one from Internet. The key of this solution is not to think of array of integers, but array of bit vectors. For element appears three times except for one, it means that there is a list of bit position which has count one either mod 3 = 1, or mod 3 = 2. What we need to do is to eliminate the bits which have count mod 3 = 0 and return the rest bits.

All the operations is done via bit operation and I did heavy comment in the code itself. I hope it is sufficiently explained.

You can read my code here.

Divide two integers without using multiplication, division and mod operator.

Use minus and bit operation to simulate division.

For example, we are going to simulate 50 / 4, we can keep doing minus like 

50 - 4 = 46

46 - 4 = 42

...

6 - 4 = 2

until the reminder 2 is smaller than 4, so the result will be 12, for 50 = 4 * 12 + 2. This is a linear complexity which will not be able to pass when dividend is very large (e.g. 2^32 - 1) and divisor (e.g. 1) is very small.

One way we could do is instead of doing linear minus, we do exponential minus by using << operation.

So for any integer a, a << 1  means a * 2, and we do another time it will be a << 1 << 1 -> a * 4. This will be much faster than linear minus.

We can use this technique to do the minus and iteratively we stop when the reminder is smaller than the divisor. This can also be illustrated as following:

For a / b, we can see

a = b * 2^ k1 + b * 2^ k2 + .... m, where m < b

The division result is Sum(2^k1 + 2^k2 ....2^kn)

In addition, there are some tricky data to be careful

negative numbers

Integer overflow when you do the bit operation. I changed to long type to overcome this.

You can read my code here. 

https://gist.github.com/zyzyis/3c60af9318ac7807594e

PS:

In additional to use bit operation there is another way I found out works. For divide a / b, we can change to logarithm where

log(a/b) = log(a) - log(b)