Reverse bits using lookup table in O(1) time
Last Updated :
17 Mar, 2023
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 LookupTable[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
#include <bits/stdc++.h>
using namespace std;
#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)
unsigned int lookuptable[256]
= { R6(0), R6(2), R6(1), R6(3) };
int reverseBits(unsigned int num)
{
int reverse_num = 0;
reverse_num = lookuptable[num & 0xff] << 24 |
lookuptable[(num >> 8) & 0xff] << 16
| lookuptable[(num >> 16) & 0xff] << 8
| lookuptable[(num >> 24) & 0xff];
return reverse_num;
}
int main()
{
int x = 12456;
printf ( "%u" , reverseBits(x));
return 0;
}
|
Java
import java.util.*;
class GFG {
public static ArrayList<Integer> lookuptable
= new ArrayList<Integer>();
public static void R2( int n)
{
lookuptable.add(n);
lookuptable.add(n + 2 * 64 );
lookuptable.add(n + 1 * 64 );
lookuptable.add(n + 3 * 64 );
}
public static void R4( int n)
{
R2(n);
R2(n + 2 * 16 );
R2(n + 1 * 16 );
R2(n + 3 * 16 );
}
public static void R6( int n)
{
R4(n);
R4(n + 2 * 4 );
R4(n + 1 * 4 );
R4(n + 3 * 4 );
}
public static int reverseBits( int num)
{
int reverse_num = 0 ;
reverse_num
= lookuptable.get(num & 0xff ) << 24 |
lookuptable.get((num >> 8 ) & 0xff ) << 16
| lookuptable.get((num >> 16 ) & 0xff ) << 8
| lookuptable.get((num >> 24 ) & 0xff );
return reverse_num;
}
public static void main(String[] args)
{
R6( 0 );
R6( 2 );
R6( 1 );
R6( 3 );
int x = 12456 ;
System.out.println(reverseBits(x));
}
}
|
Python3
lookuptable = []
def R2(n):
return lookuptable.extend([n, n + 2 * 64 , n + 1 * 64 , n + 3 * 64 ])
def R4(n):
return R2(n), R2(n + 2 * 16 ), R2(n + 1 * 16 ), R2(n + 3 * 16 )
def R6(n):
return R4(n), R4(n + 2 * 4 ), R4(n + 1 * 4 ), R4(n + 3 * 4 )
lookuptable.extend([R6( 0 ), R6( 2 ), R6( 1 ), R6( 3 )])
def reverseBits(num):
reverse_num = 0
reverse_num = lookuptable[num & 0xff ]<< 24 | lookuptable[ (num >> 8 ) & 0xff ]<< 16 |lookuptable[ (num >> 16 )& 0xff ]<< 8 | lookuptable[ (num >> 24 ) & 0xff ]
return reverse_num
x = 12456
print (reverseBits(x))
|
Javascript
let lookuptable = [];
function R2(n) {
return lookuptable.push(n, n + 2 * 64, n + 1 * 64, n + 3 * 64);
}
function R4(n) {
return [R2(n), R2(n + 2 * 16), R2(n + 1 * 16), R2(n + 3 * 16)];
}
function R6(n) {
return [R4(n), R4(n + 2 * 4), R4(n + 1 * 4), R4(n + 3 * 4)];
}
lookuptable.push(R6(0), R6(2), R6(1), R6(3));
function reverseBits(num) {
let reverse_num = 0;
reverse_num =
lookuptable[num & 0xff] << 24 |
lookuptable[(num >> 8) & 0xff] << 16 |
lookuptable[(num >> 16) & 0xff] << 8 |
lookuptable[(num >> 24) & 0xff];
return reverse_num;
}
let x = 12456;
console.log(reverseBits(x));
|
C#
using System;
using System.Collections.Generic;
class GFG {
public static List< int > lookuptable = new List< int >();
public static void R2( int n)
{
lookuptable.Add(n);
lookuptable.Add(n + 2 * 64);
lookuptable.Add(n + 1 * 64);
lookuptable.Add(n + 3 * 64);
}
public static void R4( int n)
{
R2(n);
R2(n + 2 * 16);
R2(n + 1 * 16);
R2(n + 3 * 16);
}
public static void R6( int n)
{
R4(n);
R4(n + 2 * 4);
R4(n + 1 * 4);
R4(n + 3 * 4);
}
public static int reverseBits( int num)
{
int reverse_num = 0;
reverse_num = lookuptable[num & 0xff] << 24 |
lookuptable[(num >> 8) & 0xff] << 16
| lookuptable[(num >> 16) & 0xff] << 8
| lookuptable[(num >> 24) & 0xff];
return reverse_num;
}
public static void Main( string [] args)
{
R6(0);
R6(2);
R6(1);
R6(3);
int x = 12456;
Console.WriteLine(reverseBits(x));
}
}
|
Output:
353107968
Time Complexity: O(1)
Auxiliary Space: O(1)
Like Article
Suggest improvement
Share your thoughts in the comments
Please Login to comment...