Bitwise operators are used to manipulate data at its lowest level (bit level). Data in memory (RAM) is organized as a sequence of bytes. Each byte is a group of eight consecutive bits. We use bitwise operators whenever we need to manipulate bits directly. In this post I will show you some cool bitwise operator hacks and tricks. These hacks will boost your programming skill.

## Quick overview of Bitwise operators

**Bitwise AND (**operator compare two bits and return 1 if both bits are set (1), otherwise return 0.`&`

)**Bitwise OR (**operator compare two bits and return 1 if any of them or both bits are set (1), otherwise return 0.`|`

)**Bitwise XOR (**operator compare two bits and return 1 if either of the bits are set (1), otherwise return 0.`^`

)**Bitwise complement (**operator takes single operand and invert all the bits of the operand.`~`

)**Bitwise right shift (**operator insert 0 bit at most significant bit and shift subsequent bits to right.`>>`

)**Bitwise Left shift (**operator insert 0 bit at least significant bit and shift subsequent bits to left.`<<`

)

Let us get started and learn some cool bitwise operator hacks and tricks.

## Bitwise operator hacks and tricks

### Right shift (>>) operator is equivalent to division by 2

Want to divide a number by 2 quicky. Here you go, use bitwise right shift operator to divide an integer by 2. Each right shift operation reduces the number (operand) to its half.

**Example:**`#include <stdio.h> int main() { int a = 24; // Use bitwise right shift to divide // number by power of 2 printf("24 / (2^1) => %d\n", (a >> 1)); printf("24 / (2^2) => %d\n", (a >> 2)); printf("24 / (2^3) => %d\n", (a >> 3)); return 0; }`

**Output:**`24 / (2^1) => 12 24 / (2^2) => 6 24 / (2^3) => 3`

### Left shift (<<) operator is equivalent to multiplication by 2

Similar to division, you can use bitwise left shift operator to quickly multiply a number by the power of 2. Each left shift makes doubles the number (operand).

**Example:**`#include <stdio.h> int main() { int a = 12; // Use bitwise left shift to multiply // number by power of 2 printf("12 * (2^1) => %d\n", (a << 1)); printf("12 * (2^2) => %d\n", (a << 2)); printf("12 * (2^3) => %d\n", (a << 3)); return 0; }`

**Output:**`12 * (2^1) => 24 12 * (2^2) => 48 12 * (2^3) => 96`

### Use bitwise AND (&) operator to check even or odd number

To check even or odd number we generally use modulo division operator. You can use bitwise AND

`&`

operator to check whether a number is even or odd.You can also use this trick to check if a number is divisible by two or not.

Read more how to use bitwise AND operator to check even or odd.

**Example:**`#include <stdio.h> int main() { int num1 = 10, num2 = 21; // Check even odd if (num1 & 1) printf("%d is an ODD number.\n", num1); else printf("%d is an EVEN number.\n", num1); if(num2 & 1) printf("%d is an ODD number.\n", num2); else printf("%d is an EVEN number.\n", num2); return 0; }`

**Output:**`10 is an EVEN number. 21 is an ODD number.`

### Store multiple flags in single variable

We often use variable to store boolean flag values e.g.

`isEven`

,`isMarried`

,`isPrime`

etc. Instead of wasting 4 byte to store single flag. You can use bit masking to store multiple flag values in single variable. A 4 byte unsigned integer can store 32 flags.We use bitwise OR

`|`

operator to set flag. To unset or check flag status we use bitwise AND`&`

operator. At a high level it is known as bit masking, but you can think it as set, unset and check a bit status.**Example:**

In below example I will set, check and reset three flag values. Flag for marital status at 0th bit, voting status at 1st bit, VISA status at 2nd bit.`#include <stdio.h> int main() { // Make all bits off. unsigned char flag = 0; // Set marital status YES, i.e. 0th bit 1 // (flag => 0000 0001 = 1) flag = flag | 1; // Set voting status YES, i.e. 1st bit 1 // (flag => 0000 0011 = 3) flag = flag | 2; // Set VISA eligibility status YES, i.e. 2nd bit 1 // (flag => 0000 0111 = 7) flag = flag | 4; // Print flag value printf("flag, DECIMAL = %d, HEX = %x\n\n", flag, flag); // Check if married if(flag & 1) printf("You are married.\n"); else printf("You are not married.\n"); // Check voting eligibility if(flag & 2) printf("You are eligible for voting.\n"); else printf("You are not eligible for voting.\n"); // Check VISA status if(flag & 4) printf("You are eligible to get VISA.\n"); else printf("You are not eligible to get VISA.\n"); // Unset or set all flags to false. flag = flag & (~(1 << 0)); flag = flag & (~(1 << 1)); flag = flag & (~(1 << 2)); // Print flag value printf("\nflag, DECIMAL = %d, HEX = %x\n", flag, flag); return 0; }`

**Output:**`flag, DECIMAL = 7, HEX = 7 You are married. You are eligible for voting. You are eligible to get VISA. flag, DECIMAL = 0, HEX = 0`

### Quickly find 1s and 2s complement of a number

One's complement of a binary number is defined as value obtained after inverting all bits of the number. We use bitwise complement operator

`~`

operator, to find 1s complement of a number.You can get two's complement of a binary number by adding 1 to its one's complement.

**Example:**`#include <stdio.h> int main() { int num = 8; // ~num yields 1s complement of num printf("1s complement of %d = %d\n", num, (~num)); // (~num + 1) yields 2s complement of num printf("2s complement of %d = %d\n", num, (~num + 1)); return 0; }`

**Output:**`1s complement of 8 = -9 2s complement of 8 = -8`

### Quickly convert character to lowercase and uppercase

This is my favourite hack. You can use bitwise OR and AND operator to convert a character to lowercase and uppercase respectively.

To convert a character

`ch`to lowercase use`ch = ch | ' '`

. Whether`ch`

is uppercase or lowercase. Result of this is always a lowercase character.To convert a character

`ch`to uppercase use`ch = ch & '_'`

. It always return uppercase character, doesn't matter whether`ch`

is uppercase or lowercase.**Example:**`#include <stdio.h> int main() { // Convert to lowercase printf("'a' => '%c'\n", ('a' | ' ')); printf("'A' => '%c'\n", ('A' | ' ')); // Convert to uppercase printf("'a' => '%c'\n", ('a' & '_')); printf("'A' => '%c'\n", ('a' & '_')); return 0; }`

**Output:**`'a' => 'a' 'A' => 'a' 'a' => 'A' 'A' => 'A'`

### Quick conditional assignment hack

This is one of my favourite bitwise XOR

`^`

hack. In programming you may require some conditional assignment such as,`if (x == a) x = b; if (x == b) x = a;`

You can use bitwise XOR operator for these type of assignment.

**Example:**`#include <stdio.h> int main() { int a = 10, b = 20, x; // Original value x = a; printf("x = %d\n", x); // if (x == a) x = b; x = a ^ b ^ x; printf("x = %d\n", x); // if (x == b) x = a; x = a ^ b ^ x; printf("x = %d\n", x); // x = 0 x = x ^ x; printf("x = %d\n", x); return 0; }`

**Output:**`x = 10 x = 20 x = 10 x = 0`

### Find maximum or minimum without if...else

Another hack frequently asked in interviews. We all know to find maximum or minimum using if else. Let's do it bitwise way.

**Example:**`#include <stdio.h> int main() { int x = 10, y = 20; int min = (y ^ (x ^ y) & -(x < y)); int max = (x ^ (x ^ y) & -(x < y)); printf("Minimum(10, 20) => %d\n", min); printf("Maximum(10, 20) => %d\n", max); return 0; }`

**Output:**`Maximum(10, 20) => 20 Minimum(10, 20) => 10`

### Use bitwise XOR (^) operator to quickly swap two number without third variable

Frequently asked in interviews, how to swap two numbers without using third variable. You can use bitwise XOR

`^`

operator to swap two variables without using third variable.**Example:**`#include <stdio.h> int main() { int a, b; // Input two numbers printf("Enter two numbers to swap: "); scanf("%d%d", &a, &b); // Print original values. printf("Original value: a=%d, b=%d\n", a, b); // Swap a with b a ^= b; b ^= a; a ^= b; // Swapped values. printf("Swapped value: a=%d, b=%d\n", a, b); return 0; }`

**Output:**`Enter two numbers to swap: 10 20 Original value: a=10, b=20 Swapped value: a=20, b=10`

### Use bitwise XOR (^) operator for basic encryption and decryption

Bitwise XOR operator is one of the magical operators in C. It has a special property, suppose

`a`and`b`two integers and`c = a ^ b`

. Then, the result of`a ^ b`

i.e.`c`

, when XORed with`a`return`b`

and vice versa.For example:

`int a, b, c; a = 10, b=20; c = a ^ b; // c = 30 printf("%d", (c ^ a)); // 20 printf("%d", (c ^ b)); // 10`

We can use this feature of XOR operator for basic encryption/decryption.

**Example:**`#include <stdio.h> #define KEY 22 int main() { char text[100]; int i; // Input text printf("Enter text to encrypt: "); fgets(text, 100, stdin); // Encrypt text for (i=0; text[i] != '\0'; i++) { text[i] = text[i] ^ KEY; } printf("Encrypted text: %s\n", text); // Decrypt text for (i = 0; text[i] != '\0'; i++) { text[i] = text[i] ^ KEY; } printf("Original text: %s\n", text); return 0; }`

**Output:**`Enter text to encrypt: I love C programming. Encrypted text: _6zy`s6U6fdyqdw{{xq8 Original text: I love C programming.`

Tell us your favorite bitwise operator hacks and tricks in the comments section. Or you got some more hacks please share with us.

Happy coding 😉

**References:**

<pre><code> ----Your Source Code---- </code></pre>