Reverse bits using lookup table in O(1) time
Given an unsigned integer, reverse all bits of it and return the number with reversed bits.
Examples:
Input : n = 1 Output : 2147483648 On a machine with size of unsigned bit as 32. Reverse of 0....001 is 100....0. Input : n = 2147483648 Output : 1
In the previous post we had seen two method that solved this problem in O(n) & O(logn ) time. Here we solve this problem in O(1) time using lookup table. It’s hard to reverse all 32 bits (assuming this as size of int) in one go using lookup table (” because it’s infeasible to create lookup table of size 232-1 “). So we break 32 bits into 8 bits of chunks( lookup table of size 28-1 “0-255”).
Lookup Table
in lookup tale we will store reverse of every number that are in a range( 0-255)
LookupTable[0] = 0 | binary 00000000 Reverse 00000000
LookupTable[1] = 128 | binary 00000001 reverse 10000000
LookupTable[2] = 64 | binary 00000010 reverse 01000000
LookupTanle[3] = 192 | binary 00000011 reverse 11000000
LookupTable[4] = 32 | binary 00000100 reverse 00100000
and so on… upto lookuptable[255].
Let’s take an Example How lookup table work.
let number = 12456
in Binary = 00000000000000000011000010101000
Split it into 8 bits chunks : 00000000 | 00000000 | 00110000 | 10101000
in decimal : 0 0 48 168
reverse each chunks using lookup table :
Lookuptable[ 0 ] = 0 | in binary 00000000
Lookuptable[48 ] = 12 | in binary 00001100
Lookuptable[168] = 21 | in binary 00010101
Now Binary :
00000000 | 00000000 | 00001100 | 00010101
Binary chunks after rearrangement :
00010101 | 00001100 | 00000000 | 00000000
Reverse of 12456 is 353107968
// CPP program to reverse bits using lookup table. #include<bits/stdc++.h> using namespace std; // Generate a lookup table for 32bit operating system // using macro #define R2(n) n, n + 2*64, n + 1*64, n + 3*64 #define R4(n) R2(n), R2(n + 2*16), R2(n + 1*16), R2(n + 3*16) #define R6(n) R4(n), R4(n + 2*4 ), R4(n + 1*4 ), R4(n + 3*4 ) // Lookup table that store the reverse of each table unsigned int lookuptable[256] = { R6(0), R6(2), R6(1), R6(3) }; /* Function to reverse bits of num */int reverseBits(unsigned int num) { int reverse_num = 0; // Reverse and then rearrange // first chunk of 8 bits from right reverse_num = lookuptable[ num & 0xff ]<<24 | // second chunk of 8 bits from right lookuptable[ (num >> 8) & 0xff ]<<16 | lookuptable[ (num >> 16 )& 0xff ]<< 8 | lookuptable[ (num >>24 ) & 0xff ] ; return reverse_num; } //driver program to test above function int main() { int x = 12456; printf("%u", reverseBits(x)); return 0; } |
chevron_right
filter_none
Output:
353107968
Time complexity :O(1)
Don’t stop now and take your learning to the next level. Learn all the important concepts of Data Structures and Algorithms with the help of the most trusted course: DSA Self Paced. Become industry ready at a student-friendly price.
Recommended Posts:
- Write an Efficient C Program to Reverse Bits of a Number
- Count set bits in an integer
- Count number of bits to be flipped to convert A to B
- Rotate bits of a number
- Next higher number with same number of set bits
- Program to count number of set bits in an (big) array
- Count total set bits in all numbers from 1 to n
- Swap bits in a given number
- Swap all odd and even bits
- Toggle all the bits of a number except k-th bit.
- Copy set bits in a range
- Print first n numbers with exactly two set bits
- Check if bits of a number has count of consecutive set bits in increasing order
- Check if a number has bits in alternate pattern | Set 1
- Count minimum bits to flip such that XOR of A and B equal to C
- Count trailing zero bits using lookup table
- Count all pairs of an array which differ in K bits
- Change bits to make specific OR value
- How to swap two bits in a given integer?
- Reverse an array without using subtract sign ‘-‘ anywhere in the code
If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.
Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.
- Sum of bit differences for numbers from 0 to N
- Partition of a set into K subsets with equal sum using BitMask and DP
- Maximum number of 0s that can be flipped such that Array has no adjacent 1s
- Find position of given term in a series formed with only digits 4 and 7 allowed
- Minimum bit flips such that every K consecutive bits contain at least one set bit
- Minimum flips required to form given binary string where every flip changes all bits to its right as well
- C program to count zeros and ones in binary representation of a number
- Find array sum using Bitwise OR after splitting given array in two halves after K circular shifts
- Count of pairs from Array with sum equal to twice their bitwise AND
- Count of integers up to N which represent a Binary number