Turn off the rightmost set bit

Given an integer n, turn remove turn off the rightmost set bit in it. 

Input: 12
Output: 8
Explanation: Binary representation of 12 is 00...01100. If we turn of the rightmost set bit, we get 00...01000 which is binary representation of 8

Input: 7
Output: 6
Explanation: Binary representation for 7 is 00...00111 and for 6, it is 00...00110

Input: 0
Output:0
Explanation: There is no rightmost set bit

[Naive Approach] Unset the Rightmost Set Bit Using Bitwise Operations - O(log n)Time O(1) Space

The idea is to unset the rightmost set bit of a given number by first identifying its position using bitwise operations. We traverse the bits from right to left using right shift (>>) until we encounter the first set bit (1), which gives the position of the rightmost set bit. Once this position is found, we create a mask using (1 << pos) that has only that bit set. Then, we apply XOR with the original number, which flips that bit from 1 to 0. This effectively unsets the rightmost set bit of the number.

Algorithm:

• if n == 0, return 0 since there is no set bit to unset.
• Start from position 0 and check each bit using right shift (n >> pos) and & 1.
• Move forward until the first set bit (1) is found — this is the rightmost set bit.
• Create a mask using (1 << pos) to target that bit.
• apply XOR with the original number to flip that bit from 1 to 0 and return the result.

// Cpp program to unset the rightmost
// set bit using Naive approach
#include <bits/stdc++.h>
using namespace std;

// Unsets the rightmost set bit
// of n and returns the result
int unsetLSB(int n) {
    if (n == 0)
        return 0;
  
    // Find the rightmost set bit
    int pos = 0;
    while (((n >> pos) & 1) == 0) {
        pos++;
    }
  
    // Unset the rightmost set bit
    n = n ^ (1 << pos);
  
    return n;
}

int main() {
    int n = 12;
    cout <<" Rightmost unsetBit: "<< unsetLSB(n);
    return 0;
}

#include <stdio.h>

// Unsets the rightmost set bit
// of n and returns the result
int unsetLSB(int n) {
    if (n == 0)
        return 0;
  
    // Find the rightmost set bit
    int pos = 0;
    while (((n >> pos) & 1) == 0) {
        pos++;
    }
  
    // Unset the rightmost set bit
    n = n ^ (1 << pos);
  
    return n;
}

int main() {
    int n = 12;
    printf(" Rightmost unsetBit: %d", unsetLSB(n));
    return 0;
}

public class GfG {
    // Unsets the rightmost set bit
    // of n and returns the result
    public static int unsetLSB(int n) {
        if (n == 0)
            return 0;
      
        // Find the rightmost set bit
        int pos = 0;
        while (((n >> pos) & 1) == 0) {
            pos++;
        }
      
        // Unset the rightmost set bit
        n = n ^ (1 << pos);
      
        return n;
    }
    
    public static void main(String[] args) {
        int n = 12;
        System.out.println(" Rightmost unsetBit: " + unsetLSB(n));
    }
}

# Unsets the rightmost set bit
# of n and returns the result
def unsetLSB(n):
    if n == 0:
        return 0
  
    # Find the rightmost set bit
    pos = 0
    while (n >> pos) & 1 == 0:
        pos += 1
  
    # Unset the rightmost set bit
    n = n ^ (1 << pos)
  
    return n

if __name__ == '__main__':
    n = 12
    print(" Rightmost unsetBit:", unsetLSB(n))

using System;

class GfG {
    // Unsets the rightmost set bit
    // of n and returns the result
    static int unsetLSB(int n) {
        if (n == 0)
            return 0;
      
        // Find the rightmost set bit
        int pos = 0;
        while (((n >> pos) & 1) == 0) {
            pos++;
        }
      
        // Unset the rightmost set bit
        n = n ^ (1 << pos);
      
        return n;
    }
    
    static void Main() {
        int n = 12;
        Console.WriteLine(" Rightmost unsetBit: " + unsetLSB(n));
    }
}

// Unsets the rightmost set bit
// of n and returns the result
function unsetLSB(n) {
    if (n === 0)
        return 0;
  
    // Find the rightmost set bit
    let pos = 0;
    while (((n >> pos) & 1) === 0) {
        pos++;
    }
  
    // Unset the rightmost set bit
    n = n ^ (1 << pos);
  
    return n;
}

let n = 12;
console.log(` Rightmost unsetBit: ${unsetLSB(n)}`);

 Rightmost unsetBit: 8

Time Complexity: O(log n)
Space Complexity: O(1)

[Expected Approach 1] Using n & (n - 1) Trick (Brian Kernighan’s Method) - O(1) Time and O(1) Space

The idea is to unset the rightmost set (1) bit using bit manipulation.When we subtract 1 from a number, all bits from the rightmost set bit (including it) get flipped. By performing a bitwise AND of n and (n - 1), all bits remain unchanged except the rightmost set bit, which becomes 0.

Algorithm:

• Compute n - 1, which flips all bits from the rightmost set bit onward.
• Perform bitwise AND operation: n & (n - 1).
• This keeps all bits before the rightmost set bit unchanged.
• It turns off (unsets) the rightmost set bit.
• Return the resulting value.

// Cpp program to unset the rightmost
// set bit using Subtracting by One
#include <bits/stdc++.h>
using namespace std;

// unsets the rightmost set bit 
// of n and returns the result 
int unsetLSB(int n)  { 
    return (n & (n - 1)); 
} 

int main() { 
    int n = 12; 
    cout<<" Rightmost unsetBit: "<< unsetLSB(n); 
    return 0; 
} 

#include <stdio.h>

// unsets the rightmost set bit 
// of n and returns the result 
int unsetLSB(int n)  { 
    return (n & (n - 1)); 
} 

int main() { 
    int n = 12; 
    printf(" Rightmost unsetBit: %d", unsetLSB(n)); 
    return 0; 
}

public class GfG {
    // unsets the rightmost set bit 
    // of n and returns the result 
    public static int unsetLSB(int n)  { 
        return (n & (n - 1)); 
    } 

    public static void main(String[] args) { 
        int n = 12; 
        System.out.println(" Rightmost unsetBit: " + unsetLSB(n)); 
    }
}

# unsets the rightmost set bit 
# of n and returns the result 
def unsetLSB(n): 
    return (n & (n - 1)) 

if __name__ == '__main__': 
    n = 12
    print(" Rightmost unsetBit:", unsetLSB(n))

using System;

class GfG {
    // unsets the rightmost set bit
    // of n and returns the result
    static int unsetLSB(int n) { return (n & (n - 1)); }

    static void Main(string[] args)
    {
        int n = 12;
        Console.WriteLine(" Rightmost unsetBit: "
                          + unsetLSB(n));
    }
}

// unsets the rightmost set bit 
// of n and returns the result 
function unsetLSB(n)  { 
    return (n & (n - 1)); 
} 

let n = 12; 
console.log(` Rightmost unsetBit: ${unsetLSB(n)}`);

 Rightmost unsetBit: 8

Time Complexity O(1)
Space Complexity: O(1)

[Expected Approach 2] Using 2’s Complement - O(1) Time and O(1) Space

• The idea is to find the rightmost set bit using a property of 2's complement arithmetic. When we perform n & (~n + 1) or equivalently n & (-n), we get a number with only the rightmost set bit of n.
• By subtracting this value from n, we can unset the rightmost set bit.

// C++ program to unset the rightmost
// set bit
#include <bits/stdc++.h> 
using namespace std; 
  
// Unsets the rightmost set bit  
// of n and returns the result  
int unsetBit(int n)  
{  
    return n -= (n & (-n)); 
}  
  
// Driver Code  
int main()  
{  
    int N = 12;  
    cout<<" Rightmost unsetBit: "<<unsetBit(N);  
    return 0;  
}  

#include <stdio.h>

// Unsets the rightmost set bit  
// of n and returns the result  
int unsetBit(int n)  
{  
    return n -= (n & (-n));  
}

// Driver Code  
int main()  
{  
    int N = 12;  
    printf(" Rightmost unsetBit: %d", unsetBit(N));  
    return 0;  
}

// Java program to unset the rightmost
// set bit
public class GfG {
    // Unsets the rightmost set bit  
    // of n and returns the result  
    public static int unsetBit(int n)   
    {  
        return n -= (n & (-n));  
    }

    // Driver Code  
    public static void main(String[] args)   
    {  
        int N = 12;  
        System.out.println(" Rightmost unsetBit: " + unsetBit(N));  
    }
}

# Python3 program to unset the rightmost
# set bit

# Unsets the rightmost set bit  
# of n and returns the result  
def unsetBit(n):  
    return n - (n & -n)  

# Driver Code  
n = 12
print(" Rightmost unsetBit: ", unsetBit(n))

// C# program to unset the rightmost
// set bit
using System;

class GfG {
    // Unsets the rightmost set bit  
    // of n and returns the result  
    static int unsetBit(int n)   
    {  
        return n -= (n & (-n));  
    }

    // Driver Code  
    static void Main()   
    {  
        int N = 12;  
        Console.WriteLine(" Rightmost unsetBit: " + unsetBit(N));  
    }
}

// JavaScript program to unset the rightmost
// set bit

// Unsets the rightmost set bit  
// of n and returns the result  
function unsetBit(n)   
{  
    return n -= (n & (-n));  
}

// Driver Code  
let N = 12;  
console.log(" Rightmost unsetBit: " + unsetBit(N));

 Rightmost unsetBit: 8

Time Complexity:  O(1)
Auxiliary Space: O(1)