Given an positive integer and size of bits, reverse all bits of it and return the number with reversed bits.Examples:
Input : n = 1, bitSize=32 Output : 2147483648 On a machine with size of bit as 32. Reverse of 0....001 is 100....0. Input : n = 2147483648, bitSize=32 Output : 1
We can solve this problem quickly in Python. Approach is very simple,
- Convert integer number into it’s binary representation using bin(num) function.
- bin() function appends 0b as a prefix in binary representation of number, skip first two characters of binary representation and reverse remaining part of string.
- As we know in memory any binary representation of a number is filled with leading zeros after last set bit from left that means we need to append bitSize – len(reversedBits) number of zeros after reversing remaining string.
- Now convert binary representation into integer number using int(string,base) method.
How int() method works ?
int(string,base) method takes a string and base to identify that string is referring to what number system ( binary=2, hexadecimal=16, octal=8 etc. ) and converts string into decimal number system accordingly. For example ; int(‘1010’,2) = 10.
# Function to reverse bits of positive # integer number def reverseBits(num,bitSize):
# Convert number into binary representation
# output will be like bin(10) = '0b10101'
binary = bin (num)
# Skip first two characters of binary
# representation string and reverse
# remaining string and then append zeros
# after it. binary[-1:1:-1] --> start
# from last character and reverse it until
# second last character from left
reverse = binary[ - 1 : 1 : - 1 ]
reverse = reverse + (bitSize - len (reverse)) * '0'
# converts reversed binary string into integer
print ( int (reverse, 2 ))
# Driver program if __name__ = = '__main__' :
num = 1
bitSize = 32
reverseBits(num, bitSize)
|
2147483648
Another way to revert bits without converting to string:
This is based on the concept that if the number (say N) is reversed for X bit then the reversed number will have the value same as:
the maximum possible number of X bits – N
= 2X – 1 – N
Follow the steps to implement this idea:
- Find the highest number that can be formed by the given number.
- Subtract the given number from that.
- Return the numbers.
Below is the implementation of the given approach.
# Python code to implement the approach # Function to find the reverse of the number def reverse_bits(number, bit_size):
# for example, if bitSize is 32
# then after 1 << bitSize we will get
# a 1 in 33-th bit position
# bin(1 << bitSize) looks like
# '0b100000000000000000000000000000000'
# so to get all 1 in each 32 bit positions,
# we need to subtract 1 from (1 << bitSize)
max_value = ( 1 << bit_size) - 1
# it is the maximum value for unsigned int32
# then just subtract your number from the maximum
return max_value - number
if __name__ = = "__main__" :
# for example we can get the number 56
num = 156
# choose a binary size which we want to reverse
size = 32
print (reverse_bits(num, size))
|
4294967139
Approach#3: Using bit manipulation
This approach reverses the bits of a given positive integer number n with the given bit size bitSize. It iterates through all the bits of n using a for loop and checks if the i-th bit is set to 1 by performing a bitwise AND operation between n and a left-shifted 1 by i. If it’s set, it sets the corresponding bit in the result variable using a bitwise OR operation between result and a left-shifted 1 by bitSize – 1 – i. Finally, it returns the result.
Algorithm
1. Initialize result to 0.
2. Iterate through each bit position from 0 to 31:
a. If the bit in the input number is set, set the corresponding bit in the result to 1 shifted by 31 minus the bit position.
3. Return the result.
def reverse_bits(n, bitSize):
result = 0
for i in range (bitSize):
if n & ( 1 << i):
result | = 1 << (bitSize - 1 - i)
return result
n = 2147483648
bitSize = 32
print (reverse_bits(n, bitSize))
|
2147483648
Time Complexity: O(1), since we always iterate through 32 bits.
Space Complexity: O(1), since we only use a constant amount of memory for variables.