# Turn off the rightmost set bit

Write a program that unsets the rightmost set bit of an integer. **Examples :**

Input: 12 (00...01100) Output: 8 (00...01000) Input: 7 (00...00111) Output: 6 (00...00110)

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the **DSA Self Paced Course** at a student-friendly price and become industry ready. To complete your preparation from learning a language to DS Algo and many more, please refer **Complete Interview Preparation Course****.**

In case you wish to attend **live classes **with experts, please refer **DSA Live Classes for Working Professionals **and **Competitive Programming Live for Students**.

Let the input number be n. n-1 would have all the bits flipped after the rightmost set bit (including the set bit). So, doing n&(n-1) would give us the required result.

So, now let us see how **n – 1** is **flipping all the bits** to the **right** (**including** the **rightmost set bit** also) of the **n**.

Taking n = 12, so (n – 1) = 11,

**n** can be written like ** (n = (n – 1) + 1)**, so now we can think of this problem as

__Adding 1 to Any Number__**(refer this article for better understanding)**

**of (n-1) = 11 = 1011, so now lets make n from (n-1), which can be done by adding a 1 to (n-1)**

__Binary representation__*On adding 1 to any number X, all bits to the right of*

**rightmost 0**(**including**the**rightmost zero**) gets**flipped***(n-1) = 1011*

(n-1) + 1 = 1100 **(all the bits to the right of rightmost zero (including rightmost zero) got flipped)**

Since we have flipped the **rightmost zero**, so now, *rightmost zero is now flipped to rightmost 1 (aka the rightmost set bit of n)* and

**all bits before rightmost 0 are the same as before**

X = 010 . . . . . 0 (rightmost zero) 111

X + 1 = 010 . . . . . 1 (rightmost one) 0 0 0

Example :

**X = 71 = Think of it as n – 1 **

Binary Representation of X = 1000111

**X + 1 = 72 = Think of it as n **

Binary Representation of (X+1) = 1001000__Observation : __

**1. All the bits to the left of rightmost 0 (excluding rightmost 0) in X (thinking it as n – 1) are same as in to the left of the rightmost 1(excluding rightmost 1) in X + 1 (thinking ****of ****it as n)**

**2. All the bits to the right of rightmost 0 (including rightmost 0) in X (thinking it as n – 1) are different as in to the right of the rightmost 1 (including rightmost 1) in X + 1 (thinking ****of ****it as n)**

So **bitwise AND of left part of X **(till rightmost 0, excluding rightmost 0) and **left part of X + 1** (till rightmost 1, excluding rightmost 1) **will give the required answer**, **bitwise AND right part of X** (from rightmost 0) and **right part of X + 1** **(from rightmost 1 (rightmost set bit))** will result in **0 **

## C++

`#include <bits/stdc++.h>` `using` `namespace` `std;` `// unsets the rightmost set bit` `// of n and returns the result` `int` `fun(unsigned ` `int` `n)` `{` ` ` `return` `n & (n - 1);` `}` `// Driver Code` `int` `main()` `{` ` ` `int` `n = 7;` ` ` `cout<<` `"The number after unsetting the"` `;` ` ` `cout<<` `" rightmost set bit "` `<<fun(n);` ` ` `return` `0;` `}` `//This code is contributed by rathbhupendra` |

## C

`#include <stdio.h>` `// unsets the rightmost set bit` `// of n and returns the result` `int` `fun(unsigned ` `int` `n)` `{` ` ` `return` `n & (n - 1);` `}` `// Driver Code` `int` `main()` `{` ` ` `int` `n = 7;` ` ` `printf` `(` `"The number after unsetting the"` `);` ` ` `printf` `(` `" rightmost set bit %d"` `, fun(n));` ` ` `return` `0;` `}` |

## Java

`// Java program to unset the` `// rightmost set bit of an integer.` `class` `GFG {` ` ` `/* unsets the rightmost set bit` ` ` `of n and returns the result */` ` ` `static` `int` `fun(` `int` `n)` ` ` `{` ` ` `return` `n & (n - ` `1` `);` ` ` `}` ` ` `// Driver code` ` ` `public` `static` `void` `main(String arg[])` ` ` `{` ` ` `int` `n = ` `7` `;` ` ` `System.out.print(` `"The number after unsetting "` ` ` `+ ` `"the rightmost set bit "` `+ fun(n));` ` ` `}` `}` `// This code is contributed by Anant Agarwal.` |

## Python3

`# unsets the rightmost set bit` `# of n and returns the result` `def` `fun(n):` ` ` `return` `n & (n` `-` `1` `)` `# Driver code` `n ` `=` `7` `print` `(` `"The number after unsetting the rightmost set bit"` `, fun(n))` `# This code is contributed` `# by Anant Agarwal.` |

## C#

`// C# program to unset the` `// rightmost set bit of an integer.` `using` `System;` `class` `GFG {` ` ` `/* unsets the rightmost set bit` ` ` `of n and returns the result */` ` ` `static` `int` `fun(` `int` `n)` ` ` `{` ` ` `return` `n & (n - 1);` ` ` `}` ` ` `// Driver code` ` ` `public` `static` `void` `Main()` ` ` `{` ` ` `int` `n = 7;` ` ` `Console.Write(` `"The number after unsetting "` ` ` `+ ` `"the rightmost set bit "` `+ fun(n));` ` ` `}` `}` `// This code is contributed by Sam007` |

## Javascript

`<script>` `// JavaScript program for the above approach` ` ` `/* unsets the rightmost set bit` ` ` `of n and returns the result */` ` ` `function` `fun(n)` ` ` `{` ` ` `return` `n & (n - 1);` ` ` `}` `// Driver Code` ` ` `let n = 7;` ` ` `document.write(` `"The number after unsetting "` ` ` `+ ` `"the rightmost set bit "` `+ fun(n));` `// This code is contributed by susmitakundugoaldanga.` `</script>` |

## PHP

`<?php` `// unsets the rightmost set bit` `// of n and returns the result` `function` `fun(` `$n` `)` `{` `return` `$n` `& (` `$n` `- 1);` `}` `// Driver Code` `$n` `= 7;` `echo` `"The number after unsetting the"` `.` ` ` `" rightmost set bit "` `, fun(` `$n` `);` `// This code is contributed by vt_m.` `?>` |

**Output :**

The number after unsetting the rightmost set bit 6

Please write comments if you find the above code/algorithm incorrect, or find better ways to solve the same problem