# Bitwise Hacks for Competitive Programming

• Difficulty Level : Medium
• Last Updated : 30 Jun, 2022

It is recommended to refer Interesting facts about Bitwise Operators as a prerequisite.
1. How to set a bit in the number ‘num’ :
If we want to set a bit at nth position in number ‘num’, it can be done using ‘OR’ operator( | ).

• First, we left shift ‘1’ to n position via (1<<n)
• Then, use ‘OR’ operator to set the bit at that position. ‘OR’ operator is used because it will set the bit even if the bit is unset previously in the binary representation of the number ‘num’.

Note- If the bit would be already set then it would remain unchanged.

## C++

 `#include``using` `namespace` `std;``// num is the number and pos is the position``// at which we want to set the bit.``void` `set(``int` `& num,``int` `pos)``{``     ``// First step is shift '1', second``     ``// step is bitwise OR``     ``num |= (1 << pos);``}``int` `main()``{``     ``int` `num = 4, pos = 1;``     ``set(num, pos);``     ``cout << (``int``)(num) << endl;``     ``return` `0;``}`

## Java

 `/*package whatever //do not write package name here */` `import` `java.io.*;` `class` `GFG {``    ``public` `static` `void` `main (String[] args) {``        ``int` `num = ``4``, pos =``1``;``          ``num = set(num, pos);``          ``System.out.println(num);``    ``}``      ``public` `static` `int` `set(``int` `num, ``int` `pos){``          ``// First step is shift '1', second``         ``// step is bitwise OR``          ``num |= (``1` `<< pos);``          ``return` `num;``    ``}``}` `// This code is contributed by geeky01adash.`

## Python3

 `# num = number, pos = position at which we want to set the bit``def` `set` `(num, pos):``  ``# First step = Shift '1'``  ``# Second step = Bitwise OR``  ``num |``=` `(``1` `<< pos)``  ``print``(num)``  ` `num, pos ``=` `4``, ``1` `set``(num, pos)` `# This code is contributed by sarajadhav12052009`

## C#

 `using` `System;` `public` `class` `GFG{` `    ``static` `public` `void` `Main ()``    ``{``      ``int` `num = 4, pos = 1;``      ``set``(num, pos);``    ``}``  ` `    ``// num = number, pos = position at which we want to set the bit``    ``static` `public` `void` `set``(``int` `num, ``int` `pos)``    ``{``      ``// First Step: Shift '1'``      ``// Second Step: Bitwise OR``      ``num |= (1 << pos);``      ``Console.WriteLine(num);``    ``}``}` `// This code is contributed by sarajadhav12052009`

Output:

`6`

We have passed the parameter by ‘call by reference’ to make permanent changes in the number.
2. How to unset/clear a bit at n’th position in the number ‘num’ :

Suppose we want to unset a bit at nth position in number ‘num’ then we have to do this with the help of ‘AND’ (&) operator.

• First we left shift ‘1’ to n position via (1<<n) than we use bitwise NOT operator ‘~’ to unset this shifted ‘1’.
• Now after clearing this left shifted ‘1’ i.e making it to ‘0’ we will ‘AND'(&) with the number ‘num’ that will unset bit at nth position.

## C++

 `#include ``using` `namespace` `std;``// First step is to get a number that  has all 1's except the given position.``void` `unset(``int` `&num,``int` `pos)``{``    ``//Second step is to bitwise and this  number with given number``    ``num &= (~(1 << pos));``}``int` `main()``{``    ``int` `num = 7;``    ``int`  `pos = 1;``    ``unset(num, pos);``    ``cout << num << endl;``    ``return` `0;``}`

## Java

 `/*package whatever //do not write package name here */` `import` `java.io.*;` `class` `GFG {``    ``public` `static` `void` `main (String[] args) {``        ``int` `num = ``7``, pos =``1``;``          ``num = unset(num, pos);``          ``System.out.println(num);``    ``}``      ``public` `static` `int` `unset(``int` `num, ``int` `pos){``          ``//Second step is to bitwise and this  number with given number``        ``num = num & (~(``1` `<< pos));``          ``return` `num;``    ``}``}` `// This code is contributed by geeky01adash,`

## Python3

 `# First Step: Getting which have all '1's except the``# given position``def` `unset(num, pos):``  ``# Second Step: Bitwise AND this number with the given number``  ``num &``=` `(~(``1` `<< pos))``  ``print``(num)``  ` `num, pos ``=` `7``, ``1` `unset(num, pos)` `# This code is contributed by sarajadhav12052009`

## C#

 `using` `System;` `public` `class` `GFG{` `    ``static` `public` `void` `Main ()``    ``{``      ``// First Step: Getting a number which have all '1's``      ``// except the given position``      ``int` `num = 7, pos = 1;``      ``unset(num, pos);``    ``}``    ``static` `public` `void` `unset(``int` `num, ``int` `pos)``    ``{``      ``// Second Step: Bitwise AND this number with the given number``      ``num &= (~(1 << pos));``      ``Console.WriteLine(num);``    ``}``}` `// This code is contributed by sarajadhav12052009`

Output:

`5`

3.  Toggling a bit at nth position :
Toggling means to turn bit ‘on'(1) if it was ‘off'(0) and to turn ‘off'(0) if it was ‘on'(1) previously. We will be using ‘XOR’ operator here which is this ‘^’. The reason behind ‘XOR’ operator is because of its properties.

• Properties of ‘XOR’ operator.
• 1^1 = 0
• 0^0 = 0
• 1^0 = 1
• 0^1 = 1
• If two bits are different then ‘XOR’ operator returns a set bit(1) else it returns an unset bit(0).

## C++

 `#include ``using` `namespace` `std;``// First step is to shift 1,Second step is to XOR with given number``void` `toggle(``int` `&num,``int` `pos)``{``    ``num ^= (1 << pos);``}``int` `main()``{``    ``int` `num = 4;``    ``int` `pos = 1;``    ``toggle(num, pos);``    ``cout << num << endl;``    ``return` `0;``}`

## Java

 `/*package whatever //do not write package name here */` `import` `java.io.*;` `class` `GFG {``    ``public` `static` `void` `main (String[] args) {``        ``int` `num = ``4``, pos =``1``;``          ``num = toggle(num, pos);``          ``System.out.println(num);``    ``}``      ``public` `static` `int` `toggle(``int` `num, ``int` `pos){``          ``// First step is to shift 1,Second step is to XOR with given number``        ``num ^= (``1` `<< pos);``          ``return` `num;``    ``}``}` `// This code is contributed by geeky01adash.`

## Python3

 `def` `toggle(num, pos):``  ``# First Step: Shifts '1'``  ``# Second Step: XOR num``  ``num ^``=` `(``1` `<< pos)``  ``print``(num)``  ` `  ` `num, pos ``=` `4``, ``1` `toggle(num, pos)` `# This code is contributed by sarajadhav12052009`

## C#

 `using` `System;` `public` `class` `GFG{` `    ``static` `public` `void` `Main ()``    ``{``      ``int` `num = 4, pos = 1;``      ``toggle(num, pos);``    ``}``    ``static` `public` `void` `toggle(``int` `num, ``int` `pos)``    ``{``      ``// First Step: Shift '1'``      ``// Second Step: XOR num``      ``num ^= (1 << pos);``      ``Console.WriteLine(num);``    ``}``}` `// This code is contributed by sarajadhav12052009`

Output:

`6`

4. Checking if bit at nth position is set or unset:

It is quite easily doable using ‘AND’ operator.

• Left shift ‘1’ to given position and then ‘AND'(‘&’).

## C++

 `#include ``using` `namespace` `std;` `bool` `at_position(``int` `num,``int` `pos)``{``    ``bool` `bit = num & (1<

## Java

 `/*package whatever //do not write package name here */` `import` `java.io.*;` `class` `GFG {``    ``public` `static` `void` `main(String[] args)``    ``{``        ``int` `num = ``5``;``        ``int` `pos = ``0``;``        ``int` `bit = at_position(num, pos);``        ``System.out.println(bit);``    ``}``    ``public` `static` `int` `at_position(``int` `num, ``int` `pos)``    ``{``        ``int` `bit = num & (``1` `<< pos);``        ``return` `bit;``    ``}``}` `// This code is contributed by geeky01adash.`

## Python3

 `# code``def` `at_position(num,pos):``    ``bit ``=` `num & (``1``<

Output:

`1`

Observe that we have first left shifted ‘1’ and then used ‘AND’ operator to get bit at that position. So if there is ‘1’ at position ‘pos’ in ‘num’, then after ‘AND’ our variable ‘bit’ will store ‘1’ else if there is ‘0’ at position ‘pos’ in the number ‘num’ than after ‘AND’ our variable bit will store ‘0’.

Some more quick hacks:

• Inverting every bit of a number/1’s complement:

If we want to invert every bit of a number i.e change bit ‘0’ to ‘1’ and bit ‘1’ to ‘0’.We can do this with the help of ‘~’ operator. For example : if number is num=00101100 (binary representation) so ‘~num’ will be ‘11010011’.

•

This is also the ‘1s complement of number’.

## C++

 `#include ``using` `namespace` `std;``int` `main()``{``    ``int` `num = 4;` `    ``// Inverting every bit of number num``    ``cout << (~num);``    ``return` `0;``}`

## Java

 `/*package whatever //do not write package name here */` `import` `java.io.*;` `class` `GFG {``    ``public` `static` `void` `main (String[] args) {``        ``int` `num = ``4``;``      ` `          ``// Inverting every bit of number num``          ``num = (~num);``          ``System.out.println(num);``    ``}``}` `// This code is contributed by geeky01adash.`

## Python3

 `num ``=` `4` `# Inverting every bit of number num``print``(~num)` `# This code is contributed by sarajadhav12052009`

## C#

 `using` `System;` `public` `class` `GFG{` `    ``static` `public` `void` `Main ()``    ``{``      ``int` `num = 4;``      ` `      ``// Inverting every bit of number num``      ``Console.WriteLine(~num);``    ``}``}` `// This code is contributed by sarajadhav12052009`

## Javascript

 ``

```Output:
-5```
• Two’s complement of the number: 2’s complement of a number is 1’s complement + 1.

So formally we can have 2’s complement by finding 1s complement and adding 1 to the result i.e (~num+1) or what else we can do is using ‘-‘ operator.

## C++

 `#include ``using` `namespace` `std;``int` `main()``{``    ``int` `num = 4;``    ``int` `twos_complement = -num;``    ``cout << ``"This is two's complement "` `<< twos_complement << endl;``    ``cout << ``"This is also two's complement "` `<< (~num+1) << endl;``    ``return` `0;``}`

## Java

 `/*package whatever //do not write package name here */` `import` `java.io.*;` `class` `GFG {``    ``public` `static` `void` `main(String[] args)``    ``{``        ``int` `num = ``4``;``        ``int` `twos_complement = -num;``        ``System.out.println(``"This is two's complement "``             ``+ twos_complement);``        ``System.out.println(``"This is also two's complement "``             ``+ (~num + ``1``));``    ``}``}` `// This code is contributed by geeky01adash.`

## Python3

 `num ``=` `4``twos_complement ``=` `-``num` `print``(f``"This is two's complement {twos_complement}"``)``print``(f``"This is also two's complement {~num + 1}"``)` `# This code is contributed by sarajadhav12052009`

## C#

 `using` `System;` `public` `class` `GFG{` `    ``static` `public` `void` `Main ()``    ``{``      ``int` `num = 4;``      ``int` `twos_complement = -num;``      ` `      ``Console.WriteLine(``"This is two's complement "` `+ twos_complement);``      ``Console.WriteLine(``"This is also two's complement "` `+ (~num+1));``    ``}``}` `// This code is contributed by sarajadhav12052009`

## Javascript

 ``

Output:

```This is two's complement -4
This is also two's complement -4```

• Stripping off the lowest set bit :

In many situations we want to strip off the lowest set bit for example in Binary Indexed tree data structure, counting number of set bit in a number.

We do something like this:

`X = X & (X-1)`

But how does it even work ?
Let us see this by taking an example, let X = 1100.
(X-1)  inverts all the bits till it encounters the lowest set ‘1’ and it also inverts that lowest set ‘1’.
X-1 becomes 1011. After ‘ANDing’ X with X-1 we get lowest set bit stripped.

## C++

 `#include ``using` `namespace` `std;``void` `strip_last_set_bit(``int` `&num)``{``    ``num = num & (num-1);``}``int` `main()``{``    ``int` `num = 7;``    ``strip_last_set_bit(num);``    ``cout << num << endl;``    ``return` `0;``}`

## Java

 `/*package whatever //do not write package name here */``import` `java.io.*;` `class` `GFG {``    ``public` `static` `void` `main(String[] args)``    ``{``        ``int` `num = ``7``;``        ``num = strip_last_set_bit(num);``        ``System.out.println(num);``    ``}``    ``public` `static` `int` `strip_last_set_bit(``int` `num)``    ``{``        ``return` `num & (num - ``1``);``    ``}``}` `// This code is contributed by geeky01adash.`

## Python3

 `def` `strip_last_set_bit(num):``  ``num &``=` `(num ``-` `1``)``  ``print``(num)``  ` `num ``=` `7` `strip_last_set_bit(num)` `# This code is contributed by sarajadhav12052009`

## C#

 `using` `System;` `public` `class` `GFG{` `    ``static` `public` `void` `Main ()``    ``{``      ``int` `num = 7;``      ``strip_last_set_bit(num);``    ``}``    ``static` `public` `void` `strip_last_set_bit(``int` `num)``    ``{``      ``num &= (num - 1);``      ``Console.WriteLine(num);``    ``}``}` `// This code is contributed by sarajadhav12052009`

Output:

`6`

• Getting lowest set bit of a number:

This is done by using expression ‘X &(-X)’Let us see this by taking an example: Let X = 00101100. So ~X(1’s complement) will be ‘11010011’ and 2’s complement will be (~X+1 or -X) i.e.  ‘11010100’.So if we ‘AND’ original number ‘X’ with its two’s complement which is ‘-X’, we get lowest set bit.

```00101100
& 11010100
-----------
00000100```

## C++

 `#include ``using` `namespace` `std;``int` `lowest_set_bit(``int` `num)``{``    ``int` `ret = num & (-num);``    ``return` `ret;``}``int` `main()``{``    ``int` `num = 10;``    ``int` `ans = lowest_set_bit(num);``    ``cout << ans << endl;``    ``return` `0;``}`

## Java

 `/*package whatever //do not write package name here */` `import` `java.io.*;` `class` `GFG {``    ``public` `static` `void` `main(String[] args)``    ``{``        ``int` `num = ``10``;``        ``int` `ans = lowest_set_bit(num);``        ``System.out.println(ans);``    ``}``    ``public` `static` `int` `lowest_set_bit(``int` `num)``    ``{``        ``int` `ret = num & (-num);``        ``return` `ret;``    ``}``}` `// This code is contributed by geeky01adash.`

## Python3

 `def` `lowest_set_bit(num):``  ``num &``=` `(``-``num)``  ``print``(num)``  ` `num ``=` `10` `lowest_set_bit(num)` `# This code is contributed by sarajadhav12052009`

## C#

 `using` `System;` `public` `class` `GFG{` `    ``static` `public` `void` `Main ()``    ``{``      ``int` `num = 10;``      ``lowest_set_bit(num);``    ``}``    ``static` `public` `void` `lowest_set_bit(``int` `num)``    ``{``      ``num &= (~num + 1);``      ``Console.WriteLine(num);``    ``}``}` `// This code is contributed by sarajadhav12052009`

Output:

`2`

Division by 2 and Multiplication by 2 are very frequently that too in loops in Competitive Programming so using Bitwise operators can help in speeding up the code.

Divide by 2 using the right shift operator:

```00001100 >> 1 (00001100 is 12)
------------
00000110 (00000110 is 6)```

## C++

 `#include ``using` `namespace` `std;``int` `main()``{``    ``int` `num = 12;``    ``int` `ans = num>>1;``    ``cout << ans << endl;``    ``return` `0;``}`

## Java

 `/*package whatever //do not write package name here */` `import` `java.io.*;` `class` `GFG {``    ``public` `static` `void` `main(String[] args)``    ``{``        ``int` `num = ``12``;``        ``int` `ans = num >> ``1``;``        ``System.out.println(ans);``    ``}``}` `// This code is contributed by geeky01adash.`

## Python3

 `num ``=` `12``print``(num >> ``1``)` `# This code is contributed by sarajadhav12052009`

## C#

 `using` `System;` `public` `class` `GFG{` `    ``static` `public` `void` `Main ()``    ``{``      ``int` `num = 12;``      ``Console.WriteLine(num >> 1);``    ``}``}` `// This code is contributed by sarajadhav12052009`

Output

`6`

Multiply by 2 using the left shift operator:

```00001100 << 1 (00001100 is 12)
------------
00011000 (00000110 is 24)```

## C++

 `#include ``using` `namespace` `std;``int` `main()``{``    ``int` `num = 12;``    ``int` `ans = num<<1;``    ``cout << ans << endl;``    ``return` `0;``}`

## Java

 `/*package whatever //do not write package name here */` `import` `java.io.*;` `class` `GFG {``    ``public` `static` `void` `main (String[] args) {``          ``int` `num = ``12``;``        ``int` `ans = num<<``1``;``        ``System.out.println(ans);``    ``}``}` `// This code is contributed by geeky01adash.`

## C#

 `using` `System;` `public` `class` `GFG{` `    ``static` `public` `void` `Main ()``    ``{``      ``int` `num = 12;``      ``Console.WriteLine(num << 1);``    ``}``}` `// This code is contributed by sarajadhav12052009`

## Python3

 `# Python program for the above approach` `num ``=` `12``ans ``=` `num<<``1``print``(ans)` `# This code is contributed by Shubham Singh`

## Javascript

 ``

Output

`24`

Bit Tricks for Competitive Programming
Refer BitWise Operators Articles for more articles on Bit Hacks.
This article is contributed by Pankaj Mishra. If you like GeeksforGeeks and would like to contribute, you can also write an article and mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.