Given a non-negative integer N. The task is to invert the bits of the number N and print the decimal equivalent of the number obtained after inverting the bits.
Note: Leading 0’s are not being considered.
Examples:
Input : 11
Output : 4
(11)10 = (1011)2
After inverting the bits, we get:
(0100)2 = (4)10.
Input : 20
Output : 11
(20)10 = (10100)2.
After inverting the bits, we get:
(01011)2 = (11)10.
A similar problem is already discussed in Invert actual bits of a number.
In this article, an efficient approach using bitwise operators is discussed. Below is the step by step algorithm to solve the problem:
- Calculate the total number of bits in the given number. This can be done by calculating:
X = log2N
Where N is the given number and X is the total number of bits of N.
-
The next step is to generate a number with X bits and all bits set. That is, 11111….X-times. This can be done by calculating:
Step-1: M = 1 << X
Step-2: M = M | (M-1)
- Where M is the required X-bit number with all bits set.
- The final step is to calculate the bit-wise XOR of M with N, which will be our answer.
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
int invertBits( int n)
{
int x = log2(n) ;
int m = 1 << x;
m = m | m - 1;
n = n ^ m;
return n;
}
int main()
{
int n = 20;
cout << invertBits(n);
return 0;
}
|
Java
import java.util.*;
class GFG
{
static int invertBits( int n)
{
int x = ( int )(Math.log(n) /
Math.log( 2 )) ;
int m = 1 << x;
m = m | m - 1 ;
n = n ^ m;
return n;
}
public static void main(String[] args)
{
int n = 20 ;
System.out.print(invertBits(n));
}
}
|
C#
using System;
public class GFG
{
static int invertBits( int n)
{
int x = ( int )(Math.Log(n) /
Math.Log(2)) ;
int m = 1 << x;
m = m | m - 1;
n = n ^ m;
return n;
}
public static void Main()
{
int n = 20;
Console.Write(invertBits(n));
}
}
|
Javascript
<script>
function invertBits(n)
{
let x = parseInt(Math.log(n) / Math.log(2)) ;
let m = 1 << x;
m = m | m - 1;
n = n ^ m;
return n;
}
let n = 20;
document.write(invertBits(n));
</script>
|
PHP
<?php
function invertBits( $n )
{
$x = log( $n , 2);
$m = 1 << $x ;
$m = $m | $m - 1;
$n = $n ^ $m ;
return $n ;
}
$n = 20;
echo (invertBits( $n ));
?>
|
Python3
import math
def invertBits(n):
x = int (math.log(n, 2 ))
m = 1 << x
m = m | m - 1
n = n ^ m
return n
n = 20
print (invertBits(n))
|
Time Complexity: O(log2n)
Auxiliary Space: O(1)
Method#2: Using Bitwise NOT operator and Bitwise AND operator
Approach
1. Find the number of bits required to represent the given number.
2. Initialize a variable ‘mask’ to 2^bits-1.
3. XOR the given number with ‘mask’ and store the result in ‘result’.
4. Return ‘result’.
Algorithm
1. Initialize a variable ‘num’ with the given number.
2. Initialize a variable ‘result’ to 0.
3. Initialize a variable ‘bits’ to 0.
4. Calculate the number of bits required to represent ‘num’ and store it in ‘bits’.
5. Initialize a variable ‘mask’ to 2^bits-1.
6. XOR ‘num’ with ‘mask’ and store the result in ‘result’.
7. Return ‘result’.
C++
#include <iostream>
int invertBits( int num) {
int count = 0;
int temp = num;
while (temp > 0) {
count++;
temp >>= 1;
}
return (~num) & ((1 << count) - 1);
}
int main() {
int num = 11;
std::cout << invertBits(num) << std::endl;
return 0;
}
|
Java
public class InvertBits {
static int invertBits( int num)
{
int count = 0 ;
int temp = num;
while (temp > 0 ) {
count++;
temp >>= 1 ;
}
return (~num) & (( 1 << count) - 1 );
}
public static void main(String[] args)
{
int num = 11 ;
int invertedNum = invertBits(num);
System.out.println(invertedNum);
}
}
|
C#
using System;
class Program {
static int InvertBits( int num)
{
int count = 0;
int temp = num;
while (temp > 0) {
count++;
temp >>= 1;
}
return (~num) & ((1 << count) - 1);
}
static void Main()
{
int num = 11;
Console.WriteLine(InvertBits(num));
}
}
|
Javascript
function invertBits(num) {
let count = 0;
let temp = num;
while (temp > 0) {
count++;
temp >>= 1;
}
return (~num) & ((1 << count) - 1);
}
function main() {
let num = 11;
console.log(invertBits(num));
}
main();
|
Python3
def invert_bits(num):
count = 0
temp = num
while temp > 0 :
count + = 1
temp >> = 1
return (~num) & (( 1 << count) - 1 )
num = 11
print (invert_bits(num))
|
Time complexity: O(log n) where n is the given number.
Auxiliary Space: O(1)
METHOD 3:Using defaultdict method
APPROACH:
This program uses a defaultdict object to invert the bits of a given input number. The input number is first converted to a binary string, and then each bit of the string is toggled using a defaultdict object. Finally, the inverted bits are converted back to an integer.
ALGORITHM:
1.Convert the input number to a binary string.
2.Create a defaultdict object with int type as the default value.
3.Iterate through the binary string and toggle each bit by setting its value in the defaultdict to the opposite of its original value.
4.Convert the inverted bits back to a binary string and then to an integer using the built-in int() function.
5.Return the inverted integer.
C++
#include <bitset>
#include <iostream>
#include <string>
#include <unordered_map>
using namespace std;
int invert_bits( int num)
{
string binary_str = bitset<32>(num).to_string().substr(
bitset<32>(num).to_string().find( '1' ));
unordered_map< int , int > inverted_bits;
for ( size_t i = 0; i < binary_str.size(); ++i) {
inverted_bits[i] = 1 - (binary_str[i] - '0' );
}
int inverted_num = 0;
for ( size_t i = 0; i < binary_str.size(); ++i) {
inverted_num |= (inverted_bits[i]
<< (binary_str.size() - 1 - i));
}
return inverted_num;
}
int main()
{
int num = 20;
int inverted_num = invert_bits(num);
cout << inverted_num << endl;
return 0;
}
|
Java
import java.util.HashMap;
public class GFG {
public static int invertBits( int num)
{
String binaryStr
= Integer.toBinaryString(num).replaceFirst(
"^0+(?!$)" , "" );
HashMap<Integer, Integer> invertedBits
= new HashMap<>();
for ( int i = 0 ; i < binaryStr.length(); i++) {
int bit = binaryStr.charAt(i) == '1' ? 0 : 1 ;
invertedBits.put(i, bit);
}
int invertedNum = 0 ;
for ( int i = 0 ; i < binaryStr.length(); i++) {
int bit = invertedBits.get(i);
invertedNum
|= (bit << (binaryStr.length() - 1 - i));
}
return invertedNum;
}
public static void main(String[] args)
{
int num = 20 ;
int invertedNum = invertBits(num);
System.out.println(invertedNum);
}
}
|
C#
using System;
using System.Collections.Generic;
class MainClass {
public static void Main ( string [] args) {
int num = 20;
int invertedNum = InvertBits(num);
Console.WriteLine(invertedNum);
}
public static int InvertBits( int num) {
string binaryStr = Convert.ToString(num, 2);
int firstOneIndex = binaryStr.IndexOf( '1' );
if (firstOneIndex == -1)
return 0;
string binaryStrTrimmed = binaryStr.Substring(firstOneIndex);
Dictionary< int , int > invertedBits = new Dictionary< int , int >();
for ( int i = 0; i < binaryStrTrimmed.Length; ++i) {
invertedBits[i] = 1 - (binaryStrTrimmed[i] - '0' );
}
int invertedNum = 0;
for ( int i = 0; i < binaryStrTrimmed.Length; ++i) {
invertedNum |= (invertedBits[i] << (binaryStrTrimmed.Length - 1 - i));
}
return invertedNum;
}
}
|
Javascript
function invertBits(num) {
let binaryStr = num.toString(2).replace(/^0+(?!$)/, '' );
let invertedBits = new Map();
for (let i = 0; i < binaryStr.length; i++) {
let bit = binaryStr.charAt(i) === '1' ? 0 : 1;
invertedBits.set(i, bit);
}
let invertedNum = 0;
for (let i = 0; i < binaryStr.length; i++) {
let bit = invertedBits.get(i);
invertedNum |= bit << (binaryStr.length - 1 - i);
}
return invertedNum;
}
let num = 20;
let invertedNum = invertBits(num);
console.log(invertedNum);
|
Python3
from collections import defaultdict
def invert_bits(num):
binary_str = bin (num)[ 2 :]
inverted_bits = defaultdict( int )
for i, bit in enumerate (binary_str):
inverted_bits[i] = int ( not int (bit))
inverted_num = int (''.join( str (inverted_bits[i]) for i in range ( len (binary_str))), 2 )
return inverted_num
num = 20
inverted_num = invert_bits(num)
print (inverted_num)
|
Time Complexity:
The time complexity of this program depends on the length of the binary string representation of the input number. The program iterates through the binary string once, which takes O(n) time, where n is the length of the binary string. Converting the inverted bits back to an integer using the int() function takes O(n) time as well. Therefore, the overall time complexity of the program is O(n).
Space Complexity:
The space complexity of this program is also O(n), as the defaultdict object is used to store the inverted bits, and the size of the defaultdict object is proportional to the length of the binary string.