Skip to content
Related Articles

Related Articles

Count set bits in an integer using Lookup Table

View Discussion
Improve Article
Save Article
Like Article
  • Difficulty Level : Hard
  • Last Updated : 30 Jun, 2022

Write an efficient program to count number of 1s in binary representation of an integer.
Examples 
 

Input : n = 6
Output : 2
Binary representation of 6 is 110 
and has 2 set bits

Input : n = 13
Output : 3
Binary representation of 11 is 1101 
and has 3 set bits

 

In the previous post we had seen different method that solved this problem in O(log n) time. In this post we solve in O(1) using lookup table. Here we assume that the size of INT is 32-bits. It’s hard to count all 32 bits 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( How lookup table of size (28-1 ) index : 0-255 ).
LookUp Table 
In lookup tale, we store count of set_bit of every 
number that are in a range (0-255) 
LookupTable[0] = 0 | binary 00000000 CountSetBits 0 
LookupTable[1] = 1 | binary 00000001 CountSetBits 1 
LookupTable[2] = 1 | binary 00000010 CountSetBits 1 
LookupTable[3] = 2 | binary 00000011 CountSetBits 2 
LookupTable[4] = 1 | binary 00000100 CountSetBits 1 
and so…on upto LookupTable[255].
Let’s take an Example How lookup table work.
 

Let's number be : 354 
in Binary : 0000000000000000000000101100010

Split it into 8 bits chunks  :
In Binary  :  00000000 | 00000000 | 00000001 | 01100010
In decimal :     0          0          1         98

Now Count Set_bits using LookupTable
LookupTable[0] = 0
LookupTable[1] = 1
LookupTable[98] = 3

so Total bits count : 4 

 

CPP




// c++ count to count number of set bits
// using lookup table in O(1) time
 
#include <iostream>
using namespace std;
 
// Generate a lookup table for 32 bit integers
#define B2(n) n, n + 1, n + 1, n + 2
#define B4(n) B2(n), B2(n + 1), B2(n + 1), B2(n + 2)
#define B6(n) B4(n), B4(n + 1), B4(n + 1), B4(n + 2)
 
// Lookup table that store the reverse of each table
unsigned int lookuptable[256] = { B6(0), B6(1), B6(1), B6(2) };
 
// function countset Bits Using lookup table
// ans return set bits count
unsigned int countSetBits(int N)
{
    // first chunk of 8 bits from right
    unsigned int count = lookuptable[N & 0xff] +
 
                         // second chunk from  right
                         lookuptable[(N >> 8) & 0xff] +
                          
                         // third and fourth chunks
                         lookuptable[(N >> 16) & 0xff] +
                         lookuptable[(N >> 24) & 0xff];
    return count;
}
 
int main()
{
    unsigned int N = 354;
    cout << countSetBits(N) << endl;
 
    return 0;
}

Python3




# Python3 count to count number of set bits
# using lookup table in O(1) time
 
# Generate a lookup table for 32 bit integers
 
lookuptable = []
 
 
def B2(n):
    lookuptable.extend([n, n + 1, n + 1, n + 2])
 
 
def B4(n):
    B2(n), B2(n + 1), B2(n + 1), B2(n + 2)
 
 
def B6(n):
    B4(n), B4(n + 1), B4(n + 1), B4(n + 2)
 
 
# Lookup table that store the reverse of each table
lookuptable.extend([B6(0), B6(1), B6(1), B6(2)])
 
# function countset Bits Using lookup table
# ans return set bits count
 
 
def countSetBits(N):
 
    # adding the bits in chunks of 8 bits
    count = lookuptable[N & 0xff] + lookuptable[(N >> 8) & 0xff] + lookuptable[(
        N >> 16) & 0xff] + lookuptable[(N >> 24) & 0xff]
    return count
 
 
# Driver Code
N = 354
 
# Function Call
print(countSetBits(N))
 
 
# This code is contributed by phasing17

Javascript




// JavaScript count to count number of set bits
// using lookup table in O(1) time
 
// Generate a lookup table for 32 bit integers
 
let lookuptable = [];
 
 
function B2(n)
{
    lookuptable.push(n);
    lookuptable.push(n + 1);
    lookuptable.push(n + 1);
    lookuptable.push(n + 2);
}
 
 
function B4(n)
{
    B2(n), B2(n + 1), B2(n + 1), B2(n + 2)
}
 
 
function B6(n)
{
    B4(n), B4(n + 1), B4(n + 1), B4(n + 2)
}
 
 
// Lookup table that store the reverse of each table
lookuptable.push(B6(0));
lookuptable.push(B6(1));
lookuptable.push(B6(1));
lookuptable.push(B6(2));
 
 
// function countset Bits Using lookup table
// ans return set bits count
function countSetBits(N)
{
    // adding the bits in chunks of 8 bits
    let count = lookuptable[N & 0xff] + lookuptable[(N >> 8) & 0xff] + lookuptable[(N >> 16) & 0xff] + lookuptable[(N >> 24) & 0xff];
    return count;
}
 
 
// Driver Code
let N = 354;
 
// Function Call
console.log(countSetBits(N));
 
 
// This code is contributed by phasing17

Output: 
 

4 

Time Complexity : O(1)
 


My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!