Open In App
Related Articles

Toggle bits in the given range

Improve
Improve
Improve
Like Article
Like
Save Article
Save
Report issue
Report

Given a non-negative number n and two values l and r. The problem is to toggle the bits in the range l to r in the binary representation of n, i.e., to toggle bits from the leftmost lth bit to the rightmost rth bit. A toggle operation flips a bit 0 to 1 and a bit 1 to 0.
Constraint: 1 <= l <= r <= number of bits in the binary representation of n.
Examples: 

Input: n = 17, l = 2, r = 3
Output: 23
Explanation: (17)10 = (10001)2
                       (23)10 = (10111)2
The bits in the range 2 to 3 in the binary representation of 17 are toggled.

Input: n = 50, l = 2, r = 5
Output: 44

Recommended Practice


Approach: Following are the steps:

  1. Calculate num as = ((1 << r) – 1) ^ ((1 << (l-1)) – 1) or as ((1 <<r)-l). This will produce a number num having r number of bits and bits in the range l to r are the only set bits.
  2. Now, perform n = n ^ num. This will toggle the bits in the range l to r in n.

C++

// C++ implementation to toggle bits in
// the given range
#include <bits/stdc++.h>
using namespace std;
 
// function to toggle bits in the given range
unsigned int toggleBitsFromLToR(unsigned int n,
                                unsigned int l,
                                unsigned int r)
{
    // calculating a number 'num' having 'r'
    // number of bits and bits in the range l
    // to r are the only set bits
    int num = ((1 << r) - 1) ^ ((1 << (l - 1)) - 1);
 
    // toggle bits in the range l to r in 'n'
    // and return the number
    // Besides this, we can calculate num as: num=(1<<r)-l .
    return (n ^ num);
}
 
// Driver program to test above
int main()
{
    unsigned int n = 50;
    unsigned int l = 2, r = 5;
    cout << toggleBitsFromLToR(n, l, r);
    return 0;
}

                    

Java

// Java implementation to toggle bits in
// the given range
import java.io.*;
 
class GFG {
    // Function to toggle bits in the given range
    static int toggleBitsFromLToR(int n, int l, int r)
    {
        // calculating a number 'num' having 'r'
        // number of bits and bits in the range l
        // to r are the only set bits
        int num = ((1 << r) - 1) ^ ((1 << (l - 1)) - 1);
 
        // toggle bits in the range l to r in 'n'
        // and return the number
        // Besides this, we can calculate num as:
        // num=(1<<r)-l .
        return (n ^ num);
    }
 
    // driver program
    public static void main(String[] args)
    {
        int n = 50;
        int l = 2, r = 5;
        System.out.println(toggleBitsFromLToR(n, l, r));
    }
}
 
// Contributed by Pramod Kumar

                    

Python3

# Python implementation
# to toggle bits in
# the given range
 
# function to toggle bits
# in the given range
 
 
def toggleBitsFromLToR(n, l, r):
 
    # calculating a number
    # 'num' having 'r'
    # number of bits and
    # bits in the range l
    # to r are the only set bits
    num = ((1 << r) - 1) ^ ((1 << (l - 1)) - 1)
 
    # toggle bits in the
    # range l to r in 'n'
    # Besides this, we can calculate num as: num=(1<<r)-l .
 
    # and return the number
    return (n ^ num)
 
# Driver code
 
 
n = 50
l = 2
r = 5
 
print(toggleBitsFromLToR(n, l, r))
 
# This code is contributed
# by Anant Agarwal.

                    

C#

// C# implementation to toggle bits
// in the given range
using System;
 
namespace Toggle {
public class GFG {
 
    // Function to toggle bits in the given range
    static int toggleBitsFromLToR(int n, int l, int r)
    {
        // calculating a number 'num' having 'r'
        // number of bits and bits in the range l
        // to r are the only set bits
        int num = ((1 << r) - 1) ^ ((1 << (l - 1)) - 1);
 
        // toggle bits in the range l to r in 'n'
        // Besides this, we can calculate num as:
        // num=(1<<r)-l .
        // and return the number
        return (n ^ num);
    }
 
    // Driver Code
    public static void Main()
    {
        int n = 50;
        int l = 2, r = 5;
        Console.Write(toggleBitsFromLToR(n, l, r));
    }
}
}
 
// This code is contributed by Sam007.

                    

Javascript

<script>
 
// Javascript implementation to toggle bits in
// the given range
 
// function to toggle bits in the given range
function toggleBitsFromLToR(n, l, r)
{
    // calculating a number 'num' having 'r'
    // number of bits and bits in the range l
    // to r are the only set bits
    var num = ((1 << r) - 1) ^ ((1 << (l - 1)) - 1);
 
    // toggle bits in the range l to r in 'n'
    // and return the number
//Besides this, we can calculate num as: num=(1<<r)-l .
    return (n ^ num);
}
 
// Driver program to test above
var n = 50;
var l = 2, r = 5;
document.write( toggleBitsFromLToR(n, l, r));
 
</script>

                    

PHP

<?php
// PHP implementation
// to toggle bits in
// the given range
 
// function to toggle bits
// in the given range
function toggleBitsFromLToR($n, $l, $r)
{
     
    // calculating a number
    // 'num' having 'r'
    // number of bits and
    // bits in the range l
    // to r are the only
    // set bits
    $num = ((1 << $r) - 1) ^
           ((1 << ($l - 1)) - 1);
 
    // toggle bits in the
    // range l to r in 'n'
    //Besides this, we can calculate num as: $num=(1<<$r)-$l .
    // and return the number
 
    return ($n ^ $num);
}
 
    // Driver Code
    $n = 50;
    $l = 2; $r = 5;
    echo toggleBitsFromLToR($n, $l, $r);
 
// This code is contributed by anuj_67
?>

                    

Output
44

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

Approach 2: 
Iterate over the given range from L to R and check if the ith bit is set or not. if the ith bit is set then make it unset otherwise make it set bit.

C++

// C++ implementation to toggle bits in
// the given range
#include <bits/stdc++.h>
 
using namespace std;
 
// Function to toggle bits in the given range
int toggleBitsFromLToR(int N, int L, int R)
{
    int res = N;
    for (int i = L; i <= R; i++) {
 
        // Set bit
        if ((N & (1 << (i - 1))) != 0) {
 
            // XOR will set 0 to already set
            // bits(a^a=0)
            res = res ^ (1 << (i - 1));
        }
 
        // unset bits
        else {
            // OR will set'0'bits to 1
            res = res | (1 << (i - 1));
        }
    }
    return res;
}
 
// Driver code
int main()
{
    int n = 50;
    int l = 2, r = 5;
    cout << toggleBitsFromLToR(n, l, r);
 
    return 0;
}
 
// This code is contributed by phasing17

                    

Java

// Java implementation to toggle bits in
// the given range
import java.io.*;
 
class GFG {
 
    // Function to toggle bits in the given range
    static int toggleBitsFromLToR(int N, int L, int R)
    {
        int res = N;
        for (int i = L; i <= R; i++) {
 
            // Set bit
            if ((N & (1 << (i - 1))) != 0) {
 
                // XOR will set 0 to already set
                // bits(a^a=0)
                res = res ^ (1 << (i - 1));
            }
 
            // unset bits
            else {
                // OR will set'0'bits to 1
                res = res | (1 << (i - 1));
            }
        }
        return res;
    }
 
    // Driver method
    public static void main(String[] args)
    {
        int n = 50;
        int l = 2, r = 5;
        System.out.println(toggleBitsFromLToR(n, l, r));
    }
}
 
// Contributed by Ocean Bhardwaj

                    

Python3

# Python3 implementation to toggle bits in
# the given range
 
# Function to toggle bits in the given range
def toggleBitsFromLToR(N, L, R):
 
    res = N
    for i in range(L, R + 1):
 
        # Set bit
        if ((N & (1 << (i - 1))) != 0):
 
            # XOR will set 0 to already set
            # bits(a^a=0)
            res = res ^ (1 << (i - 1))
 
        # unset bits
        else:
            # OR will set'0'bits to 1
            res = res | (1 << (i - 1))
 
    return res
 
# Driver code
n = 50
l = 2
r = 5
print(toggleBitsFromLToR(n, l, r))
 
# This code is contributed by phasing17

                    

C#

// C# implementation to toggle bits in
// the given range
using System;
 
class GFG {
 
  // Function to toggle bits in the given range
  static int toggleBitsFromLToR(int N, int L, int R)
  {
    int res = N;
    for (int i = L; i <= R; i++) {
 
      // Set bit
      if ((N & (1 << (i - 1))) != 0) {
 
        // XOR will set 0 to already set
        // bits(a^a=0)
        res = res ^ (1 << (i - 1));
      }
 
      // unset bits
      else {
        // OR will set'0'bits to 1
        res = res | (1 << (i - 1));
      }
    }
    return res;
  }
 
  // Driver Code
  public static void Main(string[] args)
  {
    int n = 50;
    int l = 2, r = 5;
 
    // Function call
    Console.WriteLine(toggleBitsFromLToR(n, l, r));
  }
}
 
// This code is Contributed by phasing17

                    

Javascript

// JavaScript implementation to toggle bits in
// the given range
 
// Function to toggle bits in the given range
function toggleBitsFromLToR(N, L, R)
{
    let res = N;
    for (let i = L; i <= R; i++) {
 
        // Set bit
        if ((N & (1 << (i - 1))) != 0) {
 
            // XOR will set 0 to already set
            // bits(a^a=0)
            res = res ^ (1 << (i - 1));
        }
 
        // unset bits
        else {
            // OR will set'0'bits to 1
            res = res | (1 << (i - 1));
        }
    }
    return res;
}
 
 
// Driver code
let n = 50;
let l = 2, r = 5;
console.log(toggleBitsFromLToR(n, l, r));
 
 
 
// This code is contributed by phasing17

                    

Output
44

Time Complexity: O(R – L + 1) 
Auxiliary Space: O(1)




 



Last Updated : 27 Dec, 2023
Like Article
Save Article
Previous
Next
Share your thoughts in the comments
Similar Reads