# Count set bits in an integer

Last Updated : 11 Apr, 2023

Write an efficient program to count the number of 1s in the 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 13 is 1101 and has 3 set bits

Recommended Practice

1. Simple Method Loop through all bits in an integer, check if a bit is set and if it is, then increment the set bit count. See the program below.

## C++

 `// C++ program to Count set` `// bits in an integer` `#include ` `using` `namespace` `std;`   `/* Function to get no of set bits in binary` `representation of positive integer n */` `unsigned ``int` `countSetBits(unsigned ``int` `n)` `{` `    ``unsigned ``int` `count = 0;` `    ``while` `(n) {` `        ``count += n & 1;` `        ``n >>= 1;` `    ``}` `    ``return` `count;` `}`   `/* Program to test function countSetBits */` `int` `main()` `{` `    ``int` `i = 9;` `    ``cout << countSetBits(i);` `    ``return` `0;` `}`   `// This code is contributed` `// by Akanksha Rai`

## C

 `// C program to Count set` `// bits in an integer` `#include `   `/* Function to get no of set bits in binary` `   ``representation of positive integer n */` `unsigned ``int` `countSetBits(unsigned ``int` `n)` `{` `    ``unsigned ``int` `count = 0;` `    ``while` `(n) {` `        ``count += n & 1;` `        ``n >>= 1;` `    ``}` `    ``return` `count;` `}`   `/* Program to test function countSetBits */` `int` `main()` `{` `    ``int` `i = 9;` `    ``printf``(``"%d"``, countSetBits(i));` `    ``return` `0;` `}`

## Java

 `// Java program to Count set` `// bits in an integer` `import` `java.io.*;`   `class` `countSetBits {` `    ``/* Function to get no of set ` `    ``bits in binary representation ` `    ``of positive integer n */` `    ``static` `int` `countSetBits(``int` `n)` `    ``{` `        ``int` `count = ``0``;` `        ``while` `(n > ``0``) {` `            ``count += n & ``1``;` `            ``n >>= ``1``;` `        ``}` `        ``return` `count;` `    ``}`   `    ``// driver program` `    ``public` `static` `void` `main(String args[])` `    ``{` `        ``int` `i = ``9``;` `        ``System.out.println(countSetBits(i));` `    ``}` `}`   `// This code is contributed by Anshika Goyal.`

## Python3

 `# Python3 program to Count set` `# bits in an integer `   `# Function to get no of set bits in binary` `# representation of positive integer n */` `def`  `countSetBits(n):` `    ``count ``=` `0` `    ``while` `(n):` `        ``count ``+``=` `n & ``1` `        ``n >>``=` `1` `    ``return` `count`     `# Program to test function countSetBits */` `i ``=` `9` `print``(countSetBits(i))`   `# This code is contributed by` `# Smitha Dinesh Semwal`

## C#

 `// C# program to Count set` `// bits in an integer` `using` `System;`   `class` `GFG {` `    ``// Function to get no of set` `    ``// bits in binary representation` `    ``// of positive integer n` `    ``static` `int` `countSetBits(``int` `n)` `    ``{` `        ``int` `count = 0;` `        ``while` `(n > 0) {` `            ``count += n & 1;` `            ``n >>= 1;` `        ``}` `        ``return` `count;` `    ``}`   `    ``// Driver Code` `    ``public` `static` `void` `Main()` `    ``{` `        ``int` `i = 9;` `        ``Console.Write(countSetBits(i));` `    ``}` `}`   `// This code is contributed by Sam007`

## PHP

 `>= 1;` `    ``}` `    ``return` `\$count``;` `}`   `// Driver Code` `\$i` `= 9;` `echo` `countSetBits(``\$i``);`   `// This code is contributed by ajit` `?>`

## Javascript

 ``

Output

`2`

Time Complexity: O(log n)
Auxiliary Space: O(1)

Recursive Approach:

## C++

 `// cpp implementation of recursive approach to find the` `// number of set bits in binary representation of positive` `// integer n` `#include ` `using` `namespace` `std;`   `// recursive function to count set bits` `int` `countSetBits(``int` `n)` `{` `    ``// base case` `    ``if` `(n == 0)` `        ``return` `0;` `    ``else` `        ``// if last bit set add 1 else add 0` `        ``return` `(n & 1) + countSetBits(n >> 1);` `}`   `// driver code` `int` `main()` `{` `    ``int` `n = 9;` `    ``// function calling` `    ``cout << countSetBits(n);` `    ``return` `0;` `}`   `// This code is contributed by Sania Kumari Gupta (kriSania804)`

## C

 `// cpp implementation of recursive approach to find the` `// number of set bits in binary representation of positive` `// integer n` `#include `   `// recursive function to count set bits` `int` `countSetBits(``int` `n)` `{` `    ``// base case` `    ``if` `(n == 0)` `        ``return` `0;` `    ``else` `        ``// if last bit set add 1 else add 0` `        ``return` `(n & 1) + countSetBits(n >> 1);` `}`   `// driver code` `int` `main()` `{` `    ``int` `n = 9;` `    ``// function calling` `    ``printf``(``"%d"``, countSetBits(n));` `    ``return` `0;` `}`   `// This code is contributed by Sania Kumari Gupta (kriSania804)`

## Java

 `// Java implementation of recursive` `// approach to find the number` `// of set bits in binary representation` `// of positive integer n` `import` `java.io.*;`   `class` `GFG {`   `    ``// recursive function to count set bits` `    ``public` `static` `int` `countSetBits(``int` `n)` `    ``{`   `        ``// base case` `        ``if` `(n == ``0``)` `            ``return` `0``;`   `        ``else`   `            ``// if last bit set add 1 else add 0` `            ``return` `(n & ``1``) + countSetBits(n >> ``1``);` `    ``}`   `    ``// Driver code` `    ``public` `static` `void` `main(String[] args)` `    ``{`   `        ``// get value from user` `        ``int` `n = ``9``;`   `        ``// function calling` `        ``System.out.println(countSetBits(n));` `    ``}` `}`   `// This code is contributes by sunnysingh`

## Python3

 `# Python3 implementation of recursive` `# approach to find the number of set` `# bits in binary representation of ` `# positive integer n`   `def` `countSetBits( n):` `    `  `    ``# base case` `    ``if` `(n ``=``=` `0``):` `        ``return` `0`   `    ``else``:`   `        ``# if last bit set add 1 else` `        ``# add 0` `        ``return` `(n & ``1``) ``+` `countSetBits(n >> ``1``)` `        `  `# Get value from user` `n ``=` `9`   `# Function calling` `print``( countSetBits(n))     ` `        `  `# This code is contributed by sunnysingh`

## C#

 `// C# implementation of recursive` `// approach to find the number of` `// set bits in binary representation` `// of positive integer n` `using` `System;`   `class` `GFG {`   `    ``// recursive function` `    ``// to count set bits` `    ``public` `static` `int` `countSetBits(``int` `n)` `    ``{`   `        ``// base case` `        ``if` `(n == 0)` `            ``return` `0;`   `        ``else`   `            ``// if last bit set` `            ``// add 1 else add 0` `            ``return` `(n & 1) + countSetBits(n >> 1);` `    ``}`   `    ``// Driver code` `    ``static` `public` `void` `Main()` `    ``{`   `        ``// get value` `        ``// from user` `        ``int` `n = 9;`   `        ``// function calling` `        ``Console.WriteLine(countSetBits(n));` `    ``}` `}`   `// This code is contributed by aj_36`

## PHP

 `> 1);` `}`   `// Driver code`   `// get value from user` `\$n` `= 9;`   `// function calling` `echo` `countSetBits(``\$n``);`   `// This code is contributed by m_kit.` `?>`

## Javascript

 ``

Output

`2`

Time Complexity: O(log n)
Auxiliary Space: O(log n) for recursive stack space

2. Brian Kernighan’s Algorithm:
Subtracting 1 from a decimal number flips all the bits after the rightmost set bit(which is 1) including the rightmost set bit.
for example :
10 in binary is 00001010
9 in binary is 00001001
8 in binary is 00001000
7 in binary is 00000111
So if we subtract a number by 1 and do it bitwise & with itself (n & (n-1)), we unset the rightmost set bit. If we do n & (n-1) in a loop and count the number of times the loop executes, we get the set bit count.
The beauty of this solution is the number of times it loops is equal to the number of set bits in a given integer.

```   1  Initialize count: = 0
2  If integer n is not zero
(a) Do bitwise & with (n-1) and assign the value back to n
n: = n&(n-1)
(b) Increment count by 1
(c) go to step 2
3  Else return count```

Example for Brian Kernighan’s Algorithm:

```   n =  9 (1001)
count = 0

Since 9 > 0, subtract by 1 and do bitwise & with (9-1)
n = 9&8  (1001 & 1000)
n = 8
count  = 1

Since 8 > 0, subtract by 1 and do bitwise & with (8-1)
n = 8&7  (1000 & 0111)
n = 0
count = 2

Since n = 0, return count which is 2 now.```

Implementation of Brian Kernighan’s Algorithm:

## C++

 `// C++ program to Count set` `// bits in an integer` `#include ` `using` `namespace` `std;` `class` `gfg {` `    ``/* Function to get no of set bits in binary` `representation of passed binary no. */` `public``:` `    ``unsigned ``int` `countSetBits(``int` `n)` `    ``{` `        ``unsigned ``int` `count = 0;` `        ``while` `(n) {` `            ``n &= (n - 1);` `            ``count++;` `        ``}` `        ``return` `count;` `    ``}` `};` `/* Program to test function countSetBits */` `int` `main()` `{` `    ``gfg g;` `    ``int` `i = 9;` `    ``cout << g.countSetBits(i);` `    ``return` `0;` `}`

## C

 `// C program to Count set` `// bits in an integer` `#include `   `/* Function to get no of set bits in binary` `   ``representation of passed binary no. */` `unsigned ``int` `countSetBits(``int` `n)` `{` `    ``unsigned ``int` `count = 0;` `    ``while` `(n) {` `        ``n &= (n - 1);` `        ``count++;` `    ``}` `    ``return` `count;` `}`   `/* Program to test function countSetBits */` `int` `main()` `{` `    ``int` `i = 9;` `    ``printf``(``"%d"``, countSetBits(i));` `    ``getchar``();` `    ``return` `0;` `}`

## Java

 `// Java program to Count set` `// bits in an integer` `import` `java.io.*;`   `class` `countSetBits {` `    ``/* Function to get no of set ` `    ``bits in binary representation ` `    ``of passed binary no. */` `    ``static` `int` `countSetBits(``int` `n)` `    ``{` `        ``int` `count = ``0``;` `        ``while` `(n > ``0``) {` `            ``n &= (n - ``1``);` `            ``count++;` `        ``}` `        ``return` `count;` `    ``}`   `    ``// driver program` `    ``public` `static` `void` `main(String args[])` `    ``{` `        ``int` `i = ``9``;` `        ``System.out.println(countSetBits(i));` `    ``}` `}`   `// This code is contributed by Anshika Goyal.`

## Python3

 `# Function to get no of set bits in binary` `# representation of passed binary no. */` `def` `countSetBits(n):`   `    ``count ``=` `0` `    ``while` `(n):` `        ``n &``=` `(n``-``1``) ` `        ``count``+``=` `1` `    `  `    ``return` `count`     `# Program to test function countSetBits ` `i ``=` `9` `print``(countSetBits(i))` ` `  `# This code is contributed by` `# Smitha Dinesh Semwal`

## C#

 `// C# program to Count set` `// bits in an integer` `using` `System;`   `class` `GFG {`   `    ``/* Function to get no of set ` `    ``bits in binary representation ` `    ``of passed binary no. */` `    ``static` `int` `countSetBits(``int` `n)` `    ``{` `        ``int` `count = 0;` `        ``while` `(n > 0) {` `            ``n &= (n - 1);` `            ``count++;` `        ``}` `        ``return` `count;` `    ``}`   `    ``// Driver Code` `    ``static` `public` `void` `Main()` `    ``{` `        ``int` `i = 9;` `        ``Console.WriteLine(countSetBits(i));` `    ``}` `}`   `// This code is contributed by ajit`

## PHP

 ``

## Javascript

 ``

Output

`2`

Time Complexity: O(log n)
Auxiliary Space: O(1)

Recursive Approach:

## C++

 `// CPP implementation for recursive` `// approach to find the number of set` `// bits using Brian Kernighanâ€™s Algorithm` `#include ` `using` `namespace` `std;`   `// recursive function to count set bits` `int` `countSetBits(``int` `n)` `{` `    ``// base case` `    ``if` `(n == 0)` `        ``return` `0;` `    ``else` `        ``return` `1 + countSetBits(n & (n - 1));` `}`   `// driver code` `int` `main()` `{` `    ``// get value from user` `    ``int` `n = 9;`   `    ``// function calling` `    ``cout << countSetBits(n);`   `    ``return` `0;` `}`   `// This code is contributed by Raj.`

## Java

 `// Java implementation for recursive` `// approach to find the number of set` `// bits using Brian Kernighan Algorithm` `import` `java.io.*;`   `class` `GFG {`   `    ``// recursive function to count set bits` `    ``public` `static` `int` `countSetBits(``int` `n)` `    ``{`   `        ``// base case` `        ``if` `(n == ``0``)` `            ``return` `0``;` `        ``else` `            ``return` `1` `+ countSetBits(n & (n - ``1``));` `    ``}`   `    ``// Driver function` `    ``public` `static` `void` `main(String[] args)` `    ``{`   `        ``// get value from user` `        ``int` `n = ``9``;`   `        ``// function calling` `        ``System.out.println(countSetBits(n));` `    ``}` `}`   `// This code is contributed by sunnysingh`

## Python3

 `# Python3 implementation for` `# recursive approach to find` `# the number of set bits using` `# Brian Kernighanâ€™s Algorithm`   `# recursive function to count` `# set bits` `def` `countSetBits(n):`   `    ``# base case` `    ``if` `(n ``=``=` `0``):` `        ``return` `0` `    ``else``:` `        ``return` `1` `+` `countSetBits(n & (n ``-` `1``))` `            `  `            `  `# Get value from user` `n ``=` `9` `    `  `# function calling` `print``(countSetBits(n))`   `# This code is contributed by sunnysingh`

## C#

 `// C# implementation for recursive` `// approach to find the number of set` `// bits using Brian Kernighan Algorithm` `using` `System;`   `class` `GFG {`   `    ``// recursive function` `    ``// to count set bits` `    ``public` `static` `int` `countSetBits(``int` `n)` `    ``{`   `        ``// base case` `        ``if` `(n == 0)` `            ``return` `0;` `        ``else` `            ``return` `1 + countSetBits(n & (n - 1));` `    ``}`   `    ``// Driver Code` `    ``static` `public` `void` `Main()` `    ``{`   `        ``// get value from user` `        ``int` `n = 9;`   `        ``// function calling` `        ``Console.WriteLine(countSetBits(n));` `    ``}` `}`   `// This code is contributed by aj_36`

## PHP

 ``

## Javascript

 ``

Output

`2`

Time Complexity: O(log n)
Auxiliary Space: O(log n)

3. Using Lookup table: We can count bits in O(1) time using the lookup table.
Below is the implementation of the above approach:

## C++

 `// C++ implementation of the approach ` `#include ` `using` `namespace` `std;`   `int` `BitsSetTable256[256];`   `// Function to initialise the lookup table ` `void` `initialize() ` `{ `   `    ``// To initially generate the ` `    ``// table algorithmically ` `    ``BitsSetTable256[0] = 0; ` `    ``for` `(``int` `i = 0; i < 256; i++)` `    ``{ ` `        ``BitsSetTable256[i] = (i & 1) + ` `        ``BitsSetTable256[i / 2]; ` `    ``} ` `} `   `// Function to return the count ` `// of set bits in n ` `int` `countSetBits(``int` `n) ` `{ ` `    ``return` `(BitsSetTable256[n & 0xff] + ` `            ``BitsSetTable256[(n >> 8) & 0xff] + ` `            ``BitsSetTable256[(n >> 16) & 0xff] + ` `            ``BitsSetTable256[n >> 24]); ` `} `   `// Driver code ` `int` `main() ` `{ ` `    ``// Initialise the lookup table ` `    ``initialize(); ` `    ``int` `n = 9; ` `    ``cout << countSetBits(n);` `} `   `// This code is contributed by Sanjit_Kumar`

## Java

 `// Java implementation of the approach` `import` `java.util.*;` `class` `GFG {`   `    ``// Lookup table` `    ``static` `int``[] BitsSetTable256 = ``new` `int``[``256``];`   `    ``// Function to initialise the lookup table` `    ``public` `static` `void` `initialize()` `    ``{`   `        ``// To initially generate the` `        ``// table algorithmically` `        ``BitsSetTable256[``0``] = ``0``;` `        ``for` `(``int` `i = ``0``; i < ``256``; i++) {` `            ``BitsSetTable256[i] = (i & ``1``) + BitsSetTable256[i / ``2``];` `        ``}` `    ``}`   `    ``// Function to return the count` `    ``// of set bits in n` `    ``public` `static` `int` `countSetBits(``int` `n)` `    ``{` `        ``return` `(BitsSetTable256[n & ``0xff``]` `                ``+ BitsSetTable256[(n >> ``8``) & ``0xff``]` `                ``+ BitsSetTable256[(n >> ``16``) & ``0xff``]` `                ``+ BitsSetTable256[n >> ``24``]);` `    ``}`   `    ``// Driver code` `    ``public` `static` `void` `main(String[] args)` `    ``{`   `        ``// Initialise the lookup table` `        ``initialize();` `        ``int` `n = ``9``;` `        ``System.out.print(countSetBits(n));` `    ``}` `}`

## Python

 `# Python implementation of the approach ` `BitsSetTable256 ``=` `[``0``] ``*` `256`   `# Function to initialise the lookup table ` `def` `initialize():` `    `  `    ``# To initially generate the ` `    ``# table algorithmically ` `    ``BitsSetTable256[``0``] ``=` `0` `    ``for` `i ``in` `range``(``256``):` `        ``BitsSetTable256[i] ``=` `(i & ``1``) ``+` `BitsSetTable256[i ``/``/` `2``] `   `# Function to return the count ` `# of set bits in n ` `def` `countSetBits(n):` `    ``return` `(BitsSetTable256[n & ``0xff``] ``+` `            ``BitsSetTable256[(n >> ``8``) & ``0xff``] ``+` `            ``BitsSetTable256[(n >> ``16``) & ``0xff``] ``+` `            ``BitsSetTable256[n >> ``24``]) `   `# Driver code `   `# Initialise the lookup table ` `initialize() ` `n ``=` `9` `print``(countSetBits(n))`   `# This code is contributed by SHUBHAMSINGH10`

## C#

 `// C# implementation of the approach` `using` `System;` `using` `System.Collections.Generic;`   `class` `GFG ` `{`   `    ``// Lookup table` `    ``static` `int``[] BitsSetTable256 = ``new` `int``[256];`   `    ``// Function to initialise the lookup table` `    ``public` `static` `void` `initialize()` `    ``{`   `        ``// To initially generate the` `        ``// table algorithmically` `        ``BitsSetTable256[0] = 0;` `        ``for` `(``int` `i = 0; i < 256; i++)` `        ``{` `            ``BitsSetTable256[i] = (i & 1) + BitsSetTable256[i / 2];` `        ``}` `    ``}`   `    ``// Function to return the count` `    ``// of set bits in n` `    ``public` `static` `int` `countSetBits(``int` `n)` `    ``{` `        ``return` `(BitsSetTable256[n & 0xff]` `                ``+ BitsSetTable256[(n >> 8) & 0xff]` `                ``+ BitsSetTable256[(n >> 16) & 0xff]` `                ``+ BitsSetTable256[n >> 24]);` `    ``}`   `    ``// Driver code` `    ``public` `static` `void` `Main(String[] args)` `    ``{`   `        ``// Initialise the lookup table` `        ``initialize();` `        ``int` `n = 9;` `        ``Console.Write(countSetBits(n));` `    ``}` `}`   `// This code is contributed by 29AjayKumar`

## Javascript

 ``

Output

`2`

Time Complexity: O(1)
Auxiliary Space: O(1)

We can find one use of counting set bits at Count number of bits to be flipped to convert A to B
Note: In GCC, we can directly count set bits using __builtin_popcount(). So we can avoid a separate function for counting set bits.

## C++

 `// C++ program to demonstrate __builtin_popcount()` `#include ` `using` `namespace` `std;`   `int` `main()` `{` `    ``cout << __builtin_popcount(4) << endl;` `    ``cout << __builtin_popcount(15);`   `    ``return` `0;` `}`

## Java

 `// java program to demonstrate` `// __builtin_popcount()`   `import` `java.io.*;`   `class` `GFG {`   `    ``// Driver code` `    ``public` `static` `void` `main(String[] args)` `    ``{`   `        ``System.out.println(Integer.bitCount(``4``));` `        ``System.out.println(Integer.bitCount(``15``));` `    ``}` `}`   `// This code is contributed by Raj`

## Python3

 `print``(``bin``(``4``).count(``'1'``));` `print``(``bin``(``15``).count(``'1'``));`   `# This code is Contributed by mits`

## C#

 `using` `System;`   `class` `Program` `{` `    ``static` `void` `Main(``string``[] args)` `    ``{` `        ``Console.WriteLine(Convert.ToString(4, 2).Replace(``"0"``, ``""``).Length);` `        ``Console.WriteLine(Convert.ToString(15, 2).Replace(``"0"``, ``""``).Length);` `    ``}` `}`

## PHP

 ``

## Javascript

 ``

Output

```1
4```

Time complexity: O(1)
Auxiliary space: O(1)

4. Mapping numbers with the bit. It simply maintains a map(or array) of numbers to bits for a nibble. A Nibble contains 4 bits. So we need an array of up to 15.
int num_to_bits[16] = {0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4};
Now we just need to get nibbles of a given long/int/word etc recursively.

## C++

 `// C++ program to count set bits by pre-storing` `// count set bits in nibbles.` `#include ` `using` `namespace` `std;`   `int` `num_to_bits[16] = { 0, 1, 1, 2, 1, 2, 2, 3,` `                        ``1, 2, 2, 3, 2, 3, 3, 4 };`   `/* Recursively get nibble of a given number ` `and map them in the array */` `unsigned ``int` `countSetBitsRec(unsigned ``int` `num)` `{` `    ``int` `nibble = 0;` `    ``if` `(0 == num)` `        ``return` `num_to_bits[0];`   `    ``// Find last nibble` `    ``nibble = num & 0xf;`   `    ``// Use pre-stored values to find count` `    ``// in last nibble plus recursively add` `    ``// remaining nibbles.` `    ``return` `num_to_bits[nibble] + countSetBitsRec(num >> 4);` `}`   `// Driver code` `int` `main()` `{` `    ``int` `num = 31;` `    ``cout << countSetBitsRec(num);` `    ``return` `0;` `}`   `// This code is contributed by rathbhupendra`

## C

 `// C program to count set bits by pre-storing` `// count set bits in nibbles.` `#include `   `int` `num_to_bits[16] = { 0, 1, 1, 2, 1, 2, 2, 3,` `                        ``1, 2, 2, 3, 2, 3, 3, 4 };`   `/* Recursively get nibble of a given number ` `  ``and map them in the array  */` `unsigned ``int` `countSetBitsRec(unsigned ``int` `num)` `{` `    ``int` `nibble = 0;` `    ``if` `(0 == num)` `        ``return` `num_to_bits[0];`   `    ``// Find last nibble` `    ``nibble = num & 0xf;`   `    ``// Use pre-stored values to find count` `    ``// in last nibble plus recursively add` `    ``// remaining nibbles.` `    ``return` `num_to_bits[nibble] + countSetBitsRec(num >> 4);` `}`   `// Driver code` `int` `main()` `{` `    ``int` `num = 31;` `    ``printf``(``"%d\n"``, countSetBitsRec(num));` `}`

## Java

 `// Java program to count set bits by pre-storing` `// count set bits in nibbles.` `import` `java.util.*;` `class` `GFG {` `    ``static` `int``[] num_to_bits = ``new` `int``[] { ``0``, ``1``, ``1``, ``2``, ``1``, ``2``, ``2``,` `                                           ``3``, ``1``, ``2``, ``2``, ``3``, ``2``, ``3``, ``3``, ``4` `};`   `    ``/* Recursively get nibble of a given number ` `and map them in the array */` `    ``static` `int` `countSetBitsRec(``int` `num)` `    ``{` `        ``int` `nibble = ``0``;` `        ``if` `(``0` `== num)` `            ``return` `num_to_bits[``0``];`   `        ``// Find last nibble` `        ``nibble = num & ``0xf``;`   `        ``// Use pre-stored values to find count` `        ``// in last nibble plus recursively add` `        ``// remaining nibbles.` `        ``return` `num_to_bits[nibble] + countSetBitsRec(num >> ``4``);` `    ``}`   `    ``// Driver code` `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``int` `num = ``31``;` `        ``System.out.println(countSetBitsRec(num));` `    ``}` `}` `// this code is contributed by mits`

## Python3

 `# Python3 program to count set bits by pre-storing ` `# count set bits in nibbles. `   `num_to_bits ``=``[``0``, ``1``, ``1``, ``2``, ``1``, ``2``, ``2``, ``3``, ``1``, ``2``, ``2``, ``3``, ``2``, ``3``, ``3``, ``4``]; `   `# Recursively get nibble of a given number ` `# and map them in the array` `def` `countSetBitsRec(num):` `    ``nibble ``=` `0``;` `    ``if``(``0` `=``=` `num):` `        ``return` `num_to_bits[``0``];` `    `  `    ``# Find last nibble` `    ``nibble ``=` `num & ``0xf``;` `    `  `    ``# Use pre-stored values to find count` `    ``# in last nibble plus recursively add` `    ``# remaining nibbles.` `    `  `    ``return` `num_to_bits[nibble] ``+` `countSetBitsRec(num >> ``4``); ` ` `    `# Driver code ` ` `  `num ``=` `31``; ` `print``(countSetBitsRec(num)); `     `# this code is contributed by mits`

## C#

 `// C# program to count set bits by pre-storing` `// count set bits in nibbles.`   `class` `GFG {` `    ``static` `int``[] num_to_bits = ``new` `int``[16] { 0, 1, 1, 2, 1, 2, 2,` `                                             ``3, 1, 2, 2, 3, 2, 3, 3, 4 };`   `    ``/* Recursively get nibble of a given number ` `and map them in the array */` `    ``static` `int` `countSetBitsRec(``int` `num)` `    ``{` `        ``int` `nibble = 0;` `        ``if` `(0 == num)` `            ``return` `num_to_bits[0];`   `        ``// Find last nibble` `        ``nibble = num & 0xf;`   `        ``// Use pre-stored values to find count` `        ``// in last nibble plus recursively add` `        ``// remaining nibbles.` `        ``return` `num_to_bits[nibble] + countSetBitsRec(num >> 4);` `    ``}`   `    ``// Driver code` `    ``static` `void` `Main()` `    ``{` `        ``int` `num = 31;` `        ``System.Console.WriteLine(countSetBitsRec(num));` `    ``}` `}` `// this code is contributed by mits`

## PHP

 `> 4); ` `} `   `// Driver code ` `\$num` `= 31; ` `echo` `(countSetBitsRec(``\$num``)); `   `// This code is contributed by mits` `?>`

## Javascript

 ``

Output

`5`

Time Complexity: O(log n), because we have log(16, n) levels of recursion.
Storage Complexity: O(1) Whether the given number is short, int, long, or long long we require an array of 16 sizes only, which is constant.

5. Checking each bit in a number:

Each bit in the number is checked for whether it is set or not. The number is bitwise AND with powers of 2, so if the result is not equal to zero, we come to know that the particular bit in the position is set.

## C

 `#include `   `// Check each bit in a number is set or not` `// and return the total count of the set bits.` `int` `countSetBits(``int` `N)` `{` `    ``int` `count = 0;` `  `  `    ``// (1 << i) = pow(2, i)` `    ``for` `(``int` `i = 0; i < ``sizeof``(``int``) * 8; i++) {` `        ``if` `(N & (1 << i))` `            ``count++;` `    ``}` `    ``return` `count;` `}`   `// Driver Code` `int` `main()` `{` `    ``int` `N = 15;`   `    ``printf``(``"%d"``, countSetBits(N));` `    ``return` `0;` `}`

## C++

 `#include ` `using` `namespace` `std;`   `// Check each bit in a number is set or not` `// and return the total count of the set bits.` `int` `countSetBits(``int` `N)` `{` `    ``int` `count = 0;` `    ``// (1 << i) = pow(2, i)` `    ``for` `(``int` `i = 0; i < ``sizeof``(``int``) * 8; i++) {` `        ``if` `(N & (1 << i))` `            ``count++;` `    ``}` `    ``return` `count;` `}`   `int` `main()` `{`   `    ``int` `N = 15;`   `    ``cout << countSetBits(N) << endl;` `    ``return` `0;` `}`

## Java

 `import` `java.util.*;` `public` `class` `GFG` `{` `  `  `  ``// Check each bit in a number is set or not` `  ``// and return the total count of the set bits.` `  ``static` `int` `countSetBits(``int` `N)` `  ``{` `    ``int` `count = ``0``;` `    ``// (1 << i) = pow(2, i)` `    ``for` `(``int` `i = ``0``; i < ``4` `* ``8``; i++) ` `    ``{` `      ``if` `((N & (``1` `<< i)) != ``0``)` `        ``count++;` `    ``}` `    ``return` `count;` `  ``}`   `  ``// Driver code` `  ``public` `static` `void` `main(String[] args)` `  ``{` `    ``int` `N = ``15``;` `    ``System.out.println(countSetBits(N));` `  ``}` `}`   `// This code is contributed by divyeshrabadiya07.`

## Python3

 `# Check each bit in a number is set or not` `# and return the total count of the set bits`     `def` `countSetBits(N):` `    ``count ``=` `0`   `    ``# (1 << i) = pow(2, i)` `    ``for` `i ``in` `range``(``4``*``8``):` `        ``if``(N & (``1` `<< i)):` `            ``count ``+``=` `1`   `    ``return` `count`   `    ``# Driver code` `N ``=` `15` `print``(countSetBits(N))`   `# This code is contributed by avanitrachhadiya2155`

## C#

 `using` `System;` `class` `GFG ` `{`   `  ``// Check each bit in a number is set or not` `  ``// and return the total count of the set bits.` `  ``static` `int` `countSetBits(``int` `N)` `  ``{` `    ``int` `count = 0;`   `    ``// (1 << i) = pow(2, i)` `    ``for` `(``int` `i = 0; i < 4 * 8; i++)` `    ``{` `      ``if` `((N & (1 << i)) != 0)` `        ``count++;` `    ``}` `    ``return` `count;` `  ``}`   `  ``// Driver code` `  ``static` `void` `Main() ` `  ``{` `    ``int` `N = 15;` `    ``Console.WriteLine(countSetBits(N));` `  ``}` `}`   `// This code is contributed by divyesh072019.`

## Javascript

 ``

Output

`4`

Time complexity: O(log n)
Auxiliary space: O(1)

6. Using power of 2:(efficient method to find for large value also)

Iterate from k to 0 , where k is the largest power of 2 such that pow(2, k) <= num . And check if the Bitwise AND of num and pow(2, i) is greater than zero or not. If it is greater than zero , Then i-th bit is set ,then increase the count by 1.

## C++

 `// C++ implementation of the above approach`   `#include ` `using` `namespace` `std;`   `// Function to find largest power of 2 such that` `// pow(2,k) <= N ` `int` `findk(``int` `n)` `{ ``int` `k; ``int` `i=0; ``int` `val=``pow``(2,i);` `  `  ` ``while``(val<=n)` ` ``{ ` `     ``k=i; i++;` `    ``val=``pow``(2,i);` ` ``}` `  ``return` `k;` `}`   `// Function to count set bits in a number` `int` `countSetBits(``int` `N)` `{` `    ``int` `count = 0;` `    ``int` `k=findk(N);` `    ``int` `val , x;` `  `  `    ``// Iterating from largest power to 2 such that ` `    ``// pow(2,k) to 0` `    ``for` `(``int` `i = k; i >= 0; i--)` `    ``{` `        ``val=``pow``(2,i);` `        ``x=val & N; ``//x will store Bitwise AND of N & val` `      `  `       ``if``(x > 0)` `       ``{ count++;` `       ``}` `    ``}` `    ``return` `count;``//return count of set bits` `}`   `// Drive Code` `int` `main()` `{` `    ``int` `N = 15;` `    `  `    ``// Function call` `    ``cout << countSetBits(N) << endl;` `    ``return` `0;` `}`   `// This code is contributed by nikhilsainiofficial546`

## Java

 `/*package whatever //do not write package name here */`   `import` `java.io.*;`   `// import java.lang.Math;`   `public` `class` `GFG {` `    ``// Function to find largest power of 2 such that` `    ``// pow(2,k) <= N` `    ``static` `int` `findk(``int` `n)` `    ``{` `        ``int` `k = ``0``;` `        ``int` `i = ``0``;` `        ``int` `val = (``int``)Math.pow(``2``, i);`   `        ``while` `(val <= n) {` `            ``k = i;` `            ``i++;` `            ``val = (``int``)Math.pow(``2``, i);` `        ``}` `        ``return` `k;` `    ``}`   `    ``// Function to count set bits in a number` `    ``static` `int` `countSetBits(``int` `N)` `    ``{` `        ``int` `count = ``0``;` `        ``int` `k = findk(N);` `        ``int` `val, x;`   `        ``// Iterating from largest power to 2 such that` `        ``// pow(2,k) to 0` `        ``for` `(``int` `i = k; i >= ``0``; i--) {` `            ``val = (``int``)Math.pow(``2``, i);` `            ``x = val` `                ``& N; ``// x will store Bitwise AND of N & val`   `            ``if` `(x > ``0``) {` `                ``count++;` `            ``}` `        ``}` `        ``return` `count; ``// return count of set bits` `    ``}`   `    ``// Driver code` `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``int` `N = ``15``;`   `        ``// Function call` `        ``System.out.println(countSetBits(N));` `    ``}` `}`

## Python3

 `# Python implementation of the above approach` `import` `math`   `# Function to find largest power of 2 such that` `# pow(2,k) <= N` `def` `findk(n):` `    ``i ``=` `0` `    ``val ``=` `math.``pow``(``2``, i)` `    ``while` `val <``=` `n:` `        ``k ``=` `i` `        ``i ``+``=` `1` `        ``val ``=` `math.``pow``(``2``, i)` `    ``return` `k`   `# Function to count set bits in a number` `def` `countSetBits(N):` `    ``count ``=` `0` `    ``k ``=` `findk(N)` `    ``for` `i ``in` `range``(k, ``-``1``, ``-``1``):` `        ``val ``=` `int``(math.``pow``(``2``, i))` `        ``x ``=` `val & N ``# x will store Bitwise AND of N & val` `        ``if` `x > ``0``:` `            ``count ``+``=` `1` `    ``return` `count`   `# Drive Code` `if` `__name__ ``=``=` `'__main__'``:` `    ``N ``=` `15`   `    ``# Function call` `    ``print``(countSetBits(N))`

## C#

 `using` `System;`   `class` `Program` `{` `    ``// Function to find largest power of 2 such that` `    ``// pow(2,k) <= N` `    ``static` `int` `FindK(``int` `n)` `    ``{` `        ``int` `k = 0;` `        ``int` `i = 0;` `        ``int` `val = (``int``)Math.Pow(2, i);`   `        ``while` `(val <= n)` `        ``{` `            ``k = i;` `            ``i++;` `            ``val = (``int``)Math.Pow(2, i);` `        ``}` `        ``return` `k;` `    ``}`   `    ``// Function to count set bits in a numnber` `    ``static` `int` `CountSetBits(``int` `N)` `    ``{` `        ``int` `count = 0;` `        ``int` `k = FindK(N);` `        ``int` `val, x;`   `        ``// Iterating from largest power to 2 such that` `        ``// pow(2,k) to 0` `        ``for` `(``int` `i = k; i >= 0; i--)` `        ``{` `            ``val = (``int``)Math.Pow(2, i);` `            ``x = val & N; ``//x will store Bitwise AND of N & val`   `            ``if` `(x > 0)` `            ``{` `                ``count++;` `            ``}` `        ``}` `        ``return` `count; ``//return count of set bits` `    ``}`   `    ``// Drive Code` `    ``static` `void` `Main()` `    ``{` `        ``int` `N = 15;`   `        ``// Function call` `        ``Console.WriteLine(CountSetBits(N));` `    ``}` `}` `//this code is contributed by ajay`

## Javascript

 `// JavaScript implementation of the above approach` `// function to find largest power of 2 such that` `// pow(2,k) <= N` `function` `findk(n){` `    ``let k;` `    ``let i = 0;` `    ``let val = Math.pow(2,i);` `    ``while``(val <= n){` `        ``k=i;` `        ``i++;` `        ``val = Math.pow(2,i);` `    ``}` `    ``return` `k;` `}`   `// function to count set bits in a number` `function` `countSetBits(N){` `    ``let count = 0;` `    ``let k = findk(N);` `    ``let val;` `    ``let x;` `    `  `    ``// iterating from largest power to 2 such that` `    ``// pow(2,k) to 0` `    ``for``(let i = k; i>=0; i--){` `        ``val = Math.pow(2,i);` `        ``x = val & N; ``// x will store bitwise and of N and val` `        `  `        ``if``(x > 0) count++;` `    ``}` `    ``return` `count; ``// return count of set bits` `}`   `// driver program` `let N = 15;`   `// function call` `console.log(countSetBits(N));`   `// THIS CODE IS CONTRIUBTED BY KIRTI AGARWAL(KIRTIAGARWAL23121999)`

Output

`4`

Time Complexity: O(logn)
Auxiliary Space: O(1)

Count set bits in an integer Using Lookup Table

Previous
Next