# [ACCEPTED]-What are bitwise operators?-boolean-logic

Score: 187

Since nobody has broached the subject of 38 why these are useful:

I use bitwise operations 37 a lot when working with flags. For example, if 36 you want to pass a series of flags to an 35 operation (say, `File.Open()`, with Read mode and Write 34 mode both enabled), you could pass them 33 as a single value. This is accomplished 32 by assigning each possible flag it's own 31 bit in a bitset (byte, short, int, or long). For 30 example:

`````` Read: 00000001
Write: 00000010
``````

So if you want to pass read AND 29 write, you would pass (READ | WRITE) which 28 then combines the two into

``````00000011
``````

Which then can 27 be decrypted on the other end like:

``````if ((flag & Read) != 0) { //...
``````

which 26 checks

``````00000011 &
00000001
``````

which returns

``````00000001
``````

which is not 0, so the 25 flag does specify READ.

You can use XOR to 24 toggle various bits. I've used this when 23 using a flag to specify directional inputs 22 (Up, Down, Left, Right). For example, if 21 a sprite is moving horizontally, and I want 20 it to turn around:

``````     Up: 00000001
Down: 00000010
Left: 00000100
Right: 00001000
Current: 00000100
``````

I simply XOR the current 19 value with (LEFT | RIGHT) which will turn 18 LEFT off and RIGHT on, in this case.

Bit 17 Shifting is useful in several cases.

``````x << y
``````

is the 16 same as

x * 2y

if you need to quickly multiply 15 by a power of two, but watch out for shifting 14 a 1-bit into the top bit - this makes the 13 number negative unless it's unsigned. It's 12 also useful when dealing with different 11 sizes of data. For example, reading an 10 integer from four bytes:

``````int val = (A << 24) | (B << 16) | (C << 8) | D;
``````

Assuming that A 9 is the most-significant byte and D the least. It 8 would end up as:

``````A = 01000000
B = 00000101
C = 00101011
D = 11100011
val = 01000000 00000101 00101011 11100011
``````

Colors are often stored 7 this way (with the most significant byte 6 either ignored or used as Alpha):

``````A = 255 = 11111111
R = 21 = 00010101
G = 255 = 11111111
B = 0 = 00000000
Color = 11111111 00010101 11111111 00000000
``````

To find 5 the values again, just shift the bits to 4 the right until it's at the bottom, then 3 mask off the remaining higher-order bits:

``````Int Alpha = Color >> 24
Int Red = Color >> 16 & 0xFF
Int Green = Color >> 8 & 0xFF
Int Blue = Color & 0xFF
``````

`0xFF` is 2 the same as `11111111`. So essentially, for Red, you 1 would be doing this:

``````Color >> 16 = (filled in 00000000 00000000)11111111 00010101  (removed 11111111 00000000)
00000000 00000000 11111111 00010101 &
00000000 00000000 00000000 11111111 =
00000000 00000000 00000000 00010101 (The original value)
``````
Score: 31

It is worth noting that the single-bit truth 13 tables listed as other answers work on only 12 one or two input bits at a time. What happens 11 when you use integers, such as:

``````int x = 5 & 6;
``````

The answer 10 lies in the binary expansion of each input:

``````  5 = 0 0 0 0 0 1 0 1
& 6 = 0 0 0 0 0 1 1 0
---------------------
0 0 0 0 0 1 0 0
``````

Each 9 pair of bits in each column is run through 8 the "AND" function to give the corresponding 7 output bit on the bottom line. So the answer 6 to the above expression is 4. The CPU has 5 done (in this example) 8 separate "AND" operations 4 in parallel, one for each column.

I mention 3 this because I still remember having this 2 "AHA!" moment when I learned about this 1 many years ago.

Score: 28

Bitwise operators are operators that work 13 on a bit at a time.

AND is 1 only if both 12 of its inputs are 1.

OR is 1 if one or more 11 of its inputs are 1.

XOR is 1 only if exactly 10 one of its inputs are 1.

NOT is 1 only if 9 its input are 0.

These can be best described 8 as truth tables. Inputs possibilities are 7 on the top and left, the resultant bit is 6 one of the four (two in the case of NOT 5 since it only has one input) values shown 4 at the intersection of the two inputs.

``````AND|0 1      OR|0 1
---+----    ---+----
0|0 0       0|0 1
1|0 1       1|1 1

XOR|0 1     NOT|0 1
---+----    ---+---
0|0 1        |1 0
1|1 0
``````

One 3 example is if you only want the lower 4 2 bits of an integer, you AND it with 15 (binary 1 1111) so:

``````    203: 1100 1011
AND  15: 0000 1111
------------------
IS  11: 0000 1011
``````
Score: 18

These are the bitwise operators, all supported 24 in JavaScript:

• `op1 & op2` -- The `AND` operator compares 23 two bits and generates a result of 1 if 22 both bits are 1; otherwise, it returns 0.

• `op1 | op2` -- The 21 `OR` operator compares two bits and generates 20 a result of 1 if the bits are complementary; otherwise, it 19 returns 0.

• `op1 ^ op2` -- The `EXCLUSIVE-OR` operator compares two 18 bits and returns 1 if either of the bits 17 are 1 and it gives 0 if both bits are 0 16 or 1.

• `~op1` -- The `COMPLEMENT` operator is used to invert 15 all of the bits of the operand.

• `op1 << op2` -- The `SHIFT LEFT` operator 14 moves the bits to the left, discards the 13 far left bit, and assigns the rightmost 12 bit a value of 0. Each move to the left 11 effectively multiplies op1 by 2.

• `op1 >> op2` -- The 10 `SHIFT RIGHT` operator moves the bits to the right, discards 9 the far right bit, and assigns the leftmost 8 bit a value of 0. Each move to the right 7 effectively divides op1 in half. The left-most 6 sign bit is preserved.

• `op1 >>> op2` -- The `SHIFT RIGHT` - `ZERO FILL` operator 5 moves the bits to the right, discards the 4 far right bit, and assigns the leftmost 3 bit a value of 0. Each move to the right 2 effectively divides op1 in half. The left-most 1 sign bit is discarded.

Score: 4

To break it down a bit more, it has a lot 2 to do with the binary representation of 1 the value in question.

```For example (in decimal):
x = 8
y = 1

would come out to (in binary):
x = 1000
y = 0001

From there, you can do computational operations such as 'and' or 'or'; in this case:
x | y =
1000
0001 |
------
1001

or...9 in decimal
```

Hope this helps.

Score: 4

When the term "bitwise" is mentioned, it 12 is sometimes clarifying that is is not a 11 "logical" operator.

For example 10 in JavaScript, bitwise operators treat their operands as a sequence of 32 bits (zeros and ones); meanwhile, logical operators are typically used with Boolean (logical) values but can work 9 with non-Boolean types.

Take expr1 && expr2 8 for example.

Returns expr1 if it can be converted to 7 false; otherwise, returns expr2. Thus, when 6 used with Boolean values, && returns 5 true if both operands are true; otherwise, returns 4 false.

``````a = "Cat" && "Dog"     // t && t returns Dog
a = 2 && 4     // t && t returns 4
``````

As others have noted, 2 & 4 is 3 a bitwise AND, so it will return 0.

You can 2 copy the following to test.html or something 1 and test:

``````<html>
<body>
<script>
alert("\"Cat\" && \"Dog\" = " + ("Cat" && "Dog") + "\n"
+ "2 && 4 = " + (2 && 4) + "\n"
+ "2 & 4 = " + (2 & 4));
</script>
``````
Score: 4

In digital computer programming, a bitwise 7 operation operates on one or more bit patterns 6 or binary numerals at the level of their 5 individual bits. It is a fast, primitive 4 action directly supported by the processor, and 3 is used to manipulate values for comparisons 2 and calculations.

operations:

• bitwise AND

• bitwise OR

• bitwise 1 NOT

• bitwise XOR

• etc

List item

``````    AND|0 1        OR|0 1
---+----      ---+----
0|0 0         0|0 1
1|0 1         1|1 1

XOR|0 1        NOT|0 1
---+----       ---+---
0|0 1           |1 0
1|1 0
``````

Eg.

``````    203: 1100 1011
AND  15: 0000 1111
------------------
=  11: 0000 1011
``````

Uses of bitwise operator

• The left-shift and right-shift operators are equivalent to multiplication and division by x * 2y respectively.

Eg.

``````int main()
{
int x = 19;
printf ("x << 1 = %d\n" , x <<1);
printf ("x >> 1 = %d\n", x >>1);
return 0;
}
// Output: 38 9
``````
• The & operator can be used to quickly check if a number is odd or even

Eg.

``````int main()
{
int x = 19;
(x & 1)? printf("Odd"): printf("Even");
return 0;
}
// Output: Odd
``````
• Quick find minimum of x and y without `if else` statement

Eg.

``````int min(int x, int y)
{
return y ^ ((x ^ y) & - (x < y))
}
``````
• Decimal to binary conversion

Eg.

``````#include <stdio.h>
int main ()
{
int n , c , k ;
printf("Enter an integer in decimal number system\n " ) ;
scanf( "%d" , & n );
printf("%d in binary number
system is: \n " , n ) ;
for ( c = 31; c >= 0 ; c -- )
{
k = n >> c ;
if ( k & 1 )
printf("1" ) ;
else
printf("0" ) ;
}
printf(" \n " );
return 0 ;
}
``````
• The XOR gate encryption is popular technique, because of its complixblity and reare use by the programmer.
• bitwise XOR operator is the most useful operator from technical interview perspective.

bitwise shifting works only with +ve number

Also there is a wide range of use of bitwise logic

Score: 1

It might help to think of it this way. This 8 is how AND (&) works:

It basically says 7 are both of these numbers ones, so if you 6 have two numbers 5 and 3 they will be converted 5 into binary and the computer will think

``````         5: 00000101
3: 00000011
``````

are 4 both one: 00000001 0 is false, 1 is true

So 3 the AND of 5 and 3 is one. The OR (|) operator 2 does the same thing except only one of the 1 numbers must be one to output 1, not both.

More Related questions