Summary of bit operations

Bit operation application tips
Use or
To reverse and exchange, you can easily use an exception or
Shift operation
Key Aspect 1: They are binary operators, both of which are integers, and the result is also an integer.
2 "<" Left shift: Fill 0 on the right blank bit. The left bit will be squeezed out from the header, and its value is equal to 2.
3 ">" right shift: The right bit is squeezed out. For the vacant positions removed from the left, if it is a positive number, the vacant space is supplemented with 0. If it is a negative number, it may be supplemented with 0 or 1, depending on the computer system used.
4 ">>>" operator, the right bit is squeezed out, and 0 is added for the left removed space.
Application of bitwise operators (source operand s mask)
(1) bitwise AND --&
1. Reset the special location (0 for a specific position in the mask, 1 for other bits, s = s & mask)
2. Locate a specified position in a specified number (1 in mask, 0 for other bits, s = s & mask)
(2) bitwise OR -- |
It is often used to set the source operand to some positions of 1, and the other BITs remain unchanged. (In mask, the specific position is 1, and the other bit is 0 s = s | mask)
(3) bitwise OR -- ^
1. Reverse the value of the specific location (1 in a specific position in mask and 0 s = s ^ mask in other bits)
2. If the third variable is not introduced, the values of the two variables are exchanged (set a = a1, B = b1)
Status after Operation
A = a1 ^ b1 a = a ^ B a = a1 ^ b1, B = b1
B = a1 ^ b1 ^ b1 B = a ^ B a = a1 ^ b1, B = a1
A = b1 ^ a1 ^ a1 a = a ^ B a = b1, B = a1
Binary complement calculation formula:
-X = ~ X + 1 = ~ X-1)
~ X =-X-1
-(~ X) = x + 1
~ (-X) = X-1
X + y = x -~ Y-1 = (x | y) + (x & y)
X-y = x ++ ~ Y + 1 = (x | ~ Y )-(~ X & y)
X ^ y = (x | y)-(x & y)
X | y = (x &~ Y) + y
X & y = (~ X | y )-~ X
X = y :~ (X-y | y-x)
X! = Y: x-y | y-x
X <y: (x-y) ^ (x ^ y) & (x-y) ^ x ))
X <= y: (x | ~ Y) & (x ^ y) | ~ (Y-x ))
X <y :(~ X & y) | ((~ X | y) & (x-y) // comparison of unsigned x and y
X <= y :(~ X | y) & (x ^ y) | ~ (Y-x) // unsigned x, y comparison
Application Example
(1) judge whether int variable a is an odd or even number.
A & 1 = 0 even
A & 1 = 1 odd
(2) Take the k-bit (k =, 2…) of int-type variable ...... Sizeof (int), that is, a> k & 1
(3) Clear the k bit of int variable a by 0, that is, a = &~ (1 <k)
(4) Place the k position of int type variable a 1, that is, a = a | (1 <k)
(5) int type variable loops are shifted k times left, that is, a = a <k | a> 16-k (set sizeof (int) = 16)
(6) int type variable a shifts k times to the right, that is, a = a> k | a <16-k (set sizeof (int) = 16)
(7) Average integer
If two integers x and y are used to calculate the average value (x + y)/2, the overflow will occur, because x + y may be greater than INT_MAX, however, we know that their average values will certainly not overflow. We use the following algorithm:
Int average (int x, int y) // returns the average value of X and Y.
{
Return (x & y) + (x ^ y)> 1 );
}
(8) judge whether an integer is the power of 2. For a number x> = 0, determine whether it is the power of 2.
Boolean power2 (int x)
{
Return (x & (x-1) = 0) & (x! = 0 );
}
(9) two integers are not exchanged using temp.
Void swap (int x, int y)
{
X ^ = y;
Y ^ = x;
X ^ = y;
}
(10) Calculate the absolute value
Int abs (int x)
{
Int y;
Y = x> 31;
Return (x ^ y)-y; // or: (x + y) ^ y
}
(11) modulo operation into bitwise operation (without Overflow)
A % (2 ^ n) is equivalent to a & (2 ^ n-1)
(12) multiplication is converted into bitwise operations (without Overflow)
A * (2 ^ n) is equivalent to a <n
(13) Division operations are converted into bitwise operations (without Overflow)
A/(2 ^ n) is equivalent to a> n
For example: 12/8 = 12> 3
(14) a % 2 is equivalent to a & 1
(15) if (x = a) x = B;
Else x =;
It is equivalent to x = a ^ B ^ x;
(16) The opposite number of x is expressed (~ X + 1)

 

Instance

Function | example | bitwise operation
---------------------- + --------------------------- + --------------------
Remove the last digit. | (101101-> 10110) | x> 1
Add 0 | (101101-> 1011010) | x <1
Add 1 | (101101-> 1011011) | x <1 + 1
Change the last digit to 1 | (101100-> 101101) | x | 1
Change the last digit to 0 | (101101-> 101100) | x | 1-1
The last bitwise is reversed. | (101101-> 101100) | x ^ 1
Change right k to 1 | (101001-> 101101, k = 3) | x | (1 <(k-1 ))
Change the right k to 0 | (101101-> 101001, k = 3) | x &~ (1 <(k-1 ))
Right k decimal | (101001-> 101101, k = 3) | x ^ (1 <(k-1 ))
Last three digits | (1101101-> 101) | x & 7
Last k bit | (1101101-> 1101, k = 5) | x & (1 <k)-1)

Right k bit | (1101101-> 1, k = 4) | x> (k-1) & 1

Turn the last k bit into 1 | (101001-> 101111, k = 4) | x | (1 <k-1)
Last k bit inversion | (101001-> 100110, k = 4) | x ^ (1 <k-1)
Change 1 on the right to 0. | (100101111-> 100100000) | x & (x + 1)
Change the first 0 from the right to 1 | (100101111-> 100111111) | x | (x + 1)
Change the continuous 0 on the right to 1 | (11011000-> 11011111) | x | (x-1)
Take 1 consecutive on the right | (100101111-> 1111) | (x ^ (x + 1)> 1
Remove the left of the first 1 from the right | (100101000-> 1000) | x & (x ^ (x-1 ))
Returns an odd number (x & 1) = 1.
Returns an even number (x & 1) = 0.

For example, calculate the total number of values from x (high) to y (low ).

Public static int FindChessNum (int x, int y, ushort k)
{
Int re = 0;
For (int I = y; I <= x; I ++)
{
Re + = (k> (I-1) & 1 );
}
Return re;
}