Precondition:It is recommended to referInteresting Facts about Bitwise Operators

**To set a bit in the number "num":**

If we want to start a little**N**position in the number "num" this can be done with the "OR" operator ( | ).

- First we shift the '1' to the left via (1<<n) to position n.
- Then use the "OR" operator to set the bit at that position. The OR operator is used because it sets the bit even if the bit was not previously set in the binary representation of the number num.

Observation:If the bit was already set, it would remain unchanged.

## C++

`#include<iostream>`

`to use`

`namespace`

`Standard;`

`// num is the number and pos is the position`

`// where we want to set the bit.`

`Empty`

`Phrase(`

`int`

`& num,`

`int`

`pos)`

`{`

`// First step is shift '1', second`

`// step is bitwise OR`

`ob |= (1 << pos);`

`}`

`int`

`mainly()`

`{`

`int`

`num = 4, pos = 1;`

`set(num, pos);`

`cause << (`

`int`

`)(num) << endl;`

`to return`

`0;`

`}`

## Java

`/*any package //don't write package names here */`

`matter`

`java.io.*;`

`Classroom`

`GFG {`

`public`

`static`

`Empty`

`principal (String[] argumentos) {`

`int`

`number =`

`4`

`, Pos =`

`1`

`;`

`num = set(num, pos);`

`System.out.println(num);`

`}`

`public`

`static`

`int`

`Phrase(`

`int`

`Number,`

`int`

`pos){`

`// First step is shift '1', second`

`// step is bitwise OR`

`number |= (`

`1`

`<< Pos);`

`to return`

`Number;`

`}`

`}`

`// This code is contributed by geeky01adash.`

## Python3

`# num = number, pos = position where we want to set the bit`

`def`

`Phrase`

`(obs, pos):`

`# First step = Shift '1'`

`# Second pass = bitwise OR`

`number |`

`=`

`(`

`1`

`<<pos)`

`press`

`(Number)`

`ob, pos`

`=`

`4`

`,`

`1`

`Phrase`

`(I can)`

`# This code is contributed by sarajadhav12052009`

## C #

`to use`

`System;`

`public`

`Classroom`

`GFG{`

`static`

`public`

`Empty`

`Mainly ()`

`{`

`int`

`num = 4, pos = 1;`

`Phrase`

`(ob, pos);`

`}`

`// num = number, pos = position where we want to set the bit`

`static`

`public`

`Empty`

`Phrase`

`(`

`int`

`Number,`

`int`

`pos)`

`{`

`// First step: Shift '1'`

`// Second step: bitwise OR`

`ob |= (1 << pos);`

`Console.WriteLine(num);`

`}`

`}`

`// This code is contributed by sarajadhav12052009`

## Javascript

`<script>`

`// num is the number and pos is the position`

`// where we want to set the bit.`

`function`

`set(num,pos)`

`{`

`// First step is shift '1', second`

`// step is bitwise OR`

`ob |= (1 << pos);`

`console.log(parseInt(num));`

`}`

`sei num = 4;`

`last pos = 1;`

`set(num, pos);`

`// This code is contributed by akashish__`

`</script>`

**Exit**

6

**Time complexity:**O(1)**auxiliary room:**O(1)

We pass the parameter via 'call by reference' to make permanent changes to the number.

**2. To set/clear a bit at the nth position in number num:**

Suppose we want to redefine something at the nth position at number "num", then we need to do it using "AND" (&) operator.

- First, we move the offset of "1" to position n via (1<<n) and then use the bitwise NOT operator "~" to reset this offset "1".
- After we delete that "1" shifted to the left, that is, H. set them to "0", we do "AND" (&) with the number "num" that resets the bit in the nth position.

## C++

`#include <iostream>`

`to use`

`namespace`

`Standard;`

`// The first step is to get a number that contains only 1 except for the specified position.`

`Empty`

`not configured (`

`int`

`&num,`

`int`

`pos)`

`{`

`//Second step is bitwise and this number with the given number`

`ob &= (~(1 <<pos));`

`}`

`int`

`mainly()`

`{`

`int`

`number = 7;`

`int`

`Pos = 1;`

`unset(ob, pos);`

`cout << num << endl;`

`to return`

`0;`

`}`

## Java

`/*any package //don't write package names here */`

`matter`

`java.io.*;`

`Classroom`

`GFG {`

`public`

`static`

`Empty`

`main(String[] argumentos)`

`{`

`int`

`number =`

`7`

`, Pos =`

`1`

`;`

`num = unset(num, pos);`

`System.out.println(num);`

`}`

`public`

`static`

`int`

`not configured (`

`int`

`Number,`

`int`

`pos)`

`{`

`// The second step is bitwise and this number with`

`// given number`

`number = number & (~(`

`1`

`<< Pos));`

`to return`

`Number;`

`}`

`}`

## Python3

`# First step: get all '1's except have`

`# position given`

`def`

`undefined(num, pos):`

`# Second step: bitwise And this number with the given number`

`num &`

`=`

`(~(`

`1`

`<<pos))`

`press`

`(Number)`

`ob, pos`

`=`

`7`

`,`

`1`

`disarm`

## C #

`to use`

`System;`

`public`

`Classroom`

`GFG {`

`static`

`public`

`Empty`

`Mainly()`

`{`

`// First step: Get a number consisting only of 1`

`// except for the given position`

`int`

`num = 7, pos = 1;`

`unset(ob, pos);`

`}`

`static`

`public`

`Empty`

`not configured (`

`int`

`Number,`

`int`

`pos)`

`{`

`// Second step: And bitwise this number with the`

`// given number`

`ob &= (~(1 <<pos));`

`Console.WriteLine(num);`

`}`

`}`

## Javascript

`// The first step is to get a number that contains only 1 except for the specified position.`

`function`

`undefined(num,pos)`

`{`

`//Second step is bitwise and this number with the given number`

`ob &= ( ~ (1 << pos));`

`to return`

`Number;`

`}`

`sei num = 7;`

`last pos = 1;`

`console.log (unset (num, pos));`

`// This code is contributed by akashish__`

**Exit**

5

**Time complexity:**O(1)**auxiliary room:**O(1)

**3. Toggle something in the nth position:**

Toggle means turning bit on (1) if it was "off" (0) and "off" (0) if previously it was "on" (1). Let's use the 'XOR' operator here, which is this '^'. The reason for the "XOR" operator is in its properties.

- 'XOR' operator properties.
- 1^1 = 0
- 0^0 = 0
- 1^0 = 1
- 0^1 = 1

- If two bits are different, the "XOR" operator returns a set bit (1), otherwise it returns an unset bit (0).

## C++

`#include <iostream>`

`to use`

`namespace`

`Standard;`

`// First step is to change 1, second step is XOR with data`

`// number`

`Empty`

`Trocar(`

`int`

`& num,`

`int`

`pos) { num ^= (1 << pos); }`

`int`

`mainly()`

`{`

`int`

`number = 4;`

`int`

`Pos = 1;`

`toggle(num, pos);`

`cout << num << endl;`

`to return`

`0;`

`}`

## Java

`/*any package //don't write package names here */`

`matter`

`java.io.*;`

`Classroom`

`GFG {`

`public`

`static`

`Empty`

`principal (String[] argumentos) {`

`int`

`number =`

`4`

`, Pos =`

`1`

`;`

`num = toggle(num, pos);`

`System.out.println(num);`

`}`

`public`

`static`

`int`

`Trocar(`

`int`

`Number,`

`int`

`pos){`

`// First step is offset 1, second step is XOR with given number`

`number ^= (`

`1`

`<< Pos);`

`to return`

`Number;`

`}`

`}`

`// This code is contributed by geeky01adash.`

## Python3

`def`

`toggle(num, pos):`

`# First step: move '1'`

`# Second step: XOR num`

`number ^`

`=`

`(`

`1`

`<<pos)`

`press`

`(Number)`

`ob, pos`

`=`

`4`

`,`

`1`

`toggle(num, pos)`

`# This code is contributed by sarajadhav12052009`

## C #

`to use`

`System;`

`public`

`Classroom`

`GFG{`

`static`

`public`

`Empty`

`Mainly ()`

`{`

`int`

`num = 4, pos = 1;`

`toggle(num, pos);`

`}`

`static`

`public`

`Empty`

`Trocar(`

`int`

`Number,`

`int`

`pos)`

`{`

`// First step: Shift '1'`

`// Second step: XOR num`

`ob ^= (1 << pos);`

`Console.WriteLine(num);`

`}`

`}`

`// This code is contributed by sarajadhav12052009`

## Javascript

`function`

`toggle(num, pos) {`

`// First step is offset 1, second step is XOR with given number`

`ob ^= (1 << pos);`

`to return`

`Number;`

`}`

`know num = 4,`

`Pos = 1;`

`num = toggle(num, pos);`

`console.log(num);`

`// This code is contributed by Prajwal Kandekar`

**Exit**

6

**Time complexity:**O(1)**auxiliary room:**O(1)

**4. Check whether the bit in the nth position is set or not:**

This is easy to do with the "AND" operator.

- Left shift "1" to the specified position, then "AND" ("&").

## C++

`#include <iostream>`

`to use`

`namespace`

`Standard;`

`bool`

`a position(`

`int`

`Number,`

`int`

`pos)`

`{`

`bool`

`bit = num & (1 << pos);`

`to return`

`Chunk;`

`}`

`int`

`mainly()`

`{`

`int`

`number = 5;`

`int`

`Pos = 0;`

`bool`

`bit = at_position (num, pos);`

`cout << bit << endl;`

`to return`

`0;`

`}`

## Java

`/*any package //don't write package names here */`

`matter`

`java.io.*;`

`Classroom`

`GFG {`

`public`

`static`

`Empty`

`main(String[] argumentos)`

`{`

`int`

`number =`

`5`

`;`

`int`

`Pos =`

`0`

`;`

`int`

`bit = at_position (num, pos);`

`System.out.println (Bit);`

`}`

`public`

`static`

`int`

`a position(`

`int`

`Number,`

`int`

`pos)`

`{`

`int`

`bit = ob & (`

`1`

`<< Pos);`

`to return`

`Chunk;`

`}`

`}`

## Python3

`#-Code`

`def`

`at_position(num,pos):`

`Chunk`

`=`

`num & (`

`1`

`<<pos)`

`to return`

`Chunk`

`Number`

`=`

`5`

`pos`

`=`

`0`

`Chunk`

`=`

`at_position(num, pos)`

`press`

`(Chunk)`

## C #

`to use`

`System;`

`Classroom`

`GFG {`

`static`

`Empty`

`Mainly(`

`line`

`[ ] Arguments)`

`{`

`int`

`number = 5;`

`int`

`Pos = 0;`

`int`

`bit = at_position (num, pos);`

`Console.WriteLine (Bit);`

`}`

`static`

`int`

`a position(`

`int`

`Number,`

`int`

`pos)`

`{`

`int`

`bit = num & (1 << pos);`

`to return`

`Chunk;`

`}`

`}`

## Javascript

`<script>`

`function`

`at_position(num,pos)`

`{`

`to return`

`ob & (1<<pos);`

`}`

`sei num = 5;`

`let pos = 0;`

`console.log (at_position (num, pos));`

`// contribution from akashish__`

`</script>`

**Exit**

1

**Time complexity:**O(1)**auxiliary room:**O(1)

Note that we first shift "1" to the left and then use the "AND" operator to get a bit at that position. So if there is '1' in position 'pos' in 'num' then our variable 'bit' stores '1' after 'AND' otherwise if there is '0' in position 'pos' in number then 'num' will provide. than after 'AND' stores our variable '0' bit.

**A few more quick hacks:**

**Inverting each bit of a number/1's complement:**If we want to invert each bit of a number, that is, change bit '0' to '1' and bit '1' to '0', we can do it with the help of the '~' operator. For example: if the number is num =00101100 (binary representation), then '~num' will be '11010011'.

*This is also the "1's complement of the number".*

## C++

`#include <iostream>`

`to use`

`namespace`

`Standard;`

`int`

`mainly()`

`{`

`int`

`number = 4;`

`// reverse each bit of number num`

`cout << (~num);`

`to return`

`0;`

`}`

## Java

`/*any package //don't write package names here */`

`matter`

`java.io.*;`

`Classroom`

`GFG {`

`public`

`static`

`Empty`

`principal (String[] argumentos) {`

`int`

`number =`

`4`

`;`

`// reverse each bit of number num`

`number = (~number);`

`System.out.println(num);`

`}`

`}`

## Python3

`Number`

`=`

`4`

`# Invert each bit of number num`

`press`

`(~number)`

## C #

`to use`

`System;`

`public`

`Classroom`

`GFG{`

`static`

`public`

`Empty`

`Mainly ()`

`{`

`int`

`number = 4;`

`// reverse each bit of number num`

`Console.WriteLine(~num);`

`}`

`}`

## Javascript

`<script>`

`sei num = 4;`

`// reverse each bit of number num`

`console.log(~num);`

`</script>`

**Exit**

-5

**Time complexity:**O(1)**auxiliary room:**O(1)

**Two's complement of the number:**The two's complement of a number is one's complement + 1.

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

## C++

`#include <iostream>`

`to use`

`namespace`

`Standard;`

`int`

`mainly()`

`{`

`int`

`number = 4;`

`int`

`twos_complement = -num;`

`cause <<`

`"This is two's complement"`

`<< two's complement << endl;`

`cause <<`

`"This is also two's complement"`

`<< (~num+1) << endl;`

`to return`

`0;`

`}`

## Java

`/*any package //don't write package names here */`

`matter`

`java.io.*;`

`Classroom`

`GFG {`

`public`

`static`

`Empty`

`main(String[] argumentos)`

`{`

`int`

`number =`

`4`

`;`

`int`

`twos_complement = -num;`

`System.out.println(`

`"This is two's complement"`

`+ two's complement);`

`System.out.println(`

`"This is also two's complement"`

`+ (~number +`

`1`

`));`

`}`

`}`

`// This code is contributed by geeky01adash.`

## Python3

`Number`

`=`

`4`

`two's complement`

`=`

`-`

`Number`

`press`

`(F`

`"This is two's complement {twos_complement}"`

`)`

`press`

`(F`

`"This is also two's complement {~num + 1}"`

`)`

`# This code is contributed by sarajadhav12052009`

## C #

`to use`

`System;`

`public`

`Classroom`

`GFG{`

`static`

`public`

`Empty`

`Mainly ()`

`{`

`int`

`number = 4;`

`int`

`twos_complement = -num;`

`Console.WriteLine(`

`"This is two's complement"`

`+ two's complement);`

`Console.WriteLine(`

`"This is also two's complement"`

`+ (~num+1));`

`}`

`}`

`// This code is contributed by sarajadhav12052009`

## Javascript

`<script>`

`sei num = 4;`

`let twos_complement = -num;`

`Console.log (`

`"This is two's complement"`

`+ two's complement);`

`Console.log (`

`"This is also two's complement"`

`+ (~num+1));`

`// This code is contributed by akashish__`

`</script>`

**Exit**

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

**Time complexity:**O(1)**auxiliary room:**O(1)

**Removing the lowest bitset:**

In many situations we want to remove the lowest bit set, for example in a binary indexed tree data structure counting the number of bits set in a number. We do something like this:

X = X & (X-1)

But how does it work? Let's see this with an example, let X = 1100.

- (X-1) inverts all bits until it finds the smallest quantity "1", and also inverts this smallest quantity "1".
- X-1 becomes 1011. After "WALKING" X with X-1, we remove the lowest set bit.

## C++

`#include <iostream>`

`to use`

`namespace`

`Standard;`

`Empty`

`strip_last_set_bit(`

`int`

`&num)`

`{`

`num = num & (num-1);`

`}`

`int`

`mainly()`

`{`

`int`

`number = 7;`

`strip_last_set_bit(num);`

`cout << num << endl;`

`to return`

`0;`

`}`

## Java

`matter`

`java.io.*;`

`Classroom`

`GFG {`

`public`

`static`

`Empty`

`main(String[] argumentos)`

`{`

`int`

`number =`

`7`

`;`

`num = strip_last_set_bit(num);`

`System.out.println(num);`

`}`

`public`

`static`

`int`

`strip_last_set_bit(`

`int`

`Number)`

`{`

`to return`

`I know -`

`1`

`);`

`}`

`}`

## Python3

`def`

`strip_last_set_bit(num):`

`num &`

`=`

`(Anz`

`-`

`1`

`)`

`press`

`(Number)`

`Number`

`=`

`7`

`strip_last_set_bit(num)`

## C #

`to use`

`System;`

`public`

`Classroom`

`GFG{`

`static`

`public`

`Empty`

`Mainly ()`

`{`

`int`

`number = 7;`

`strip_last_set_bit(num);`

`}`

`static`

`public`

`Empty`

`strip_last_set_bit(`

`int`

`Number)`

`{`

`number &= (number - 1);`

`Console.WriteLine(num);`

`}`

`}`

## Javascript

`<script>`

`function`

`strip_last_set_bit(num)`

`{`

`to return`

`number & (number-1);`

`}`

`sei num = 7;`

`console.log(strip_last_set_bit(num));`

`</script>`

**Exit**

6

**Time complexity:**O(1)**auxiliary room:**O(1)

**Get the lowest register bit of a number:**

This is achieved using the expression 'X &(-X)'. Let's see this with an example: Let X = 00101100. Then ~X(1's complement) will be '11010011' and 2's complement will be (~X+ 1 or -X), ie '11010100'. So if 'E' the original number 'X' with its two's complement, which is '-X', we get the lowest bit set.

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

## C++

`#include <iostream>`

`to use`

`namespace`

`Standard;`

`int`

`menor_bit_set(`

`int`

`Number)`

`{`

`int`

`ret = num & (-num);`

`to return`

`turn back;`

`}`

`int`

`mainly()`

`{`

`int`

`number = 10;`

`int`

`ans = less_set_bit(num);`

`cout << ans << endl;`

`to return`

`0;`

`}`

## Java

`matter`

`java.io.*;`

`Classroom`

`GFG {`

`public`

`static`

`Empty`

`main(String[] argumentos)`

`{`

`int`

`number =`

`10`

`;`

`int`

`ans = less_set_bit(num);`

`System.out.println(ans);`

`}`

`public`

`static`

`int`

`menor_bit_set(`

`int`

`Number)`

`{`

`int`

`ret = num & (-num);`

`to return`

`turn back;`

`}`

`}`

## Python3

`def`

`minor_set_bit(num):`

`num &`

`=`

`(`

`-`

`Number)`

`press`

`(Number)`

`Number`

`=`

`10`

`minor_bit_set(num)`

## Javascript

`// Function to set the lowest bit`

`function`

`minor_bit_set(num)`

`{`

`// Take e from num and -ve from num`

`let ret = num & (-num);`

`to return`

`turn back;`

`}`

`// driver code`

`I know num = 10`

`let ans = smallest_set_bit(num)`

`console.log(ans)`

## C #

`to use`

`System;`

`public`

`Classroom`

`GFG {`

`static`

`public`

`Empty`

`Mainly()`

`{`

`int`

`number = 10;`

`bit_set_minor(num);`

`}`

`static`

`public`

`Empty`

`menor_bit_set(`

`int`

`Number)`

`{`

`number &= (~number + 1);`

`Console.WriteLine(num);`

`}`

`}`

**Exit**

2

Divide by 2 and multiply by 2 are also very common in loops in competitive programming, so using bitwise operators can help speed up code.

Divide by 2 using the right shift operator:

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

## C++

`#include <iostream>`

`to use`

`namespace`

`Standard;`

`int`

`mainly()`

`{`

`int`

`number = 12;`

`int`

`ans = num>>1;`

`cout << ans << endl;`

`to return`

`0;`

`}`

## Java

`matter`

`java.io.*;`

`Classroom`

`GFG {`

`public`

`static`

`Empty`

`main(String[] argumentos)`

`{`

`int`

`number =`

`12`

`;`

`int`

`years = ob >>`

`1`

`;`

`System.out.println(ans);`

`}`

`}`

## Python3

`Number`

`=`

`12`

`press`

`(Number >>`

`1`

`)`

## C #

`to use`

`System;`

`public`

`Classroom`

`GFG{`

`static`

`public`

`Empty`

`Mainly ()`

`{`

`int`

`number = 12;`

`Console.WriteLine(num >> 1);`

`}`

`}`

## Javascript

`<script>`

`Guerra`

`number = 12;`

`Guerra`

`ans = num>>1;`

`console.log(ans);`

`</script>`

**Exit**

6

**Time complexity:**O(1)**auxiliary room:**O(1)

**Multiply by 2 using the left shift operator:**

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

## C++

`#include <iostream>`

`to use`

`namespace`

`Standard;`

`int`

`mainly()`

`{`

`int`

`number = 12;`

`int`

`ans = num<<1;`

`cout << ans << endl;`

`to return`

`0;`

`}`

## Java

`/*any package //don't write package names here */`

`matter`

`java.io.*;`

`Classroom`

`GFG {`

`public`

`static`

`Empty`

`principal (String[] argumentos) {`

`int`

`number =`

`12`

`;`

`int`

`ans = num<<`

`1`

`;`

`System.out.println(ans);`

`}`

`}`

`// This code is contributed by geeky01adash.`

## C #

`to use`

`System;`

`public`

`Classroom`

`GFG{`

`static`

`public`

`Empty`

`Mainly ()`

`{`

`int`

`number = 12;`

`Console.WriteLine(num << 1);`

`}`

`}`

`// This code is contributed by sarajadhav12052009`

## Python3

`# Python program for the above approach`

`Number`

`=`

`12`

`response`

`=`

`number <<`

`1`

`press`

`(response)`

`# This code is contributed by Shubham Singh`

## Javascript

`<script>`

`// Javascript program for the above approach`

`Guerra`

`number = 12;`

`Guerra`

`ans = num<<1;`

`document.write(ans);`

`//This code is contributed by Shubham Singh`

`</script>`

**Exit**

24

**Time complexity:**O(1)**auxiliary room:**O(1)

Bit tricks for competitive programming

ReferBitWise Operator Articlesfor more articles on bit hacks.

This article was contributed by**Pankaj Mishra**. If you like GeeksforGeeks and want to contribute, you can also write an article and send your article to review-team@geeksforgeeks.org. See your article appear on the main page of GeeksforGeeks and help other geeks.

Please write comments if you find something wrong or if you want to share more information about the topic discussed above.

my personal notes*arrow_drop_up*