 GFG App
Open App Browser
Continue

# Prime Number of Set Bits in Binary Representation | Set 1

Given two integers ‘L’ and ‘R’, write a program to find the total numbers that are having prime number of set bits in their binary representation in the range [L, R].

Examples:

```Input  : l = 6, r = 10
Output : 4
Explanation  :
6  -> 110  (2 set bits, 2 is prime)
7  -> 111  (3 set bits, 3 is prime)
9  -> 1001 (2 set bits, 2 is prime)
10 -> 1010 (2 set bits, 2 is prime)
Hence count is 4

Input  : l = 10, r = 15
Output : 5
10 -> 1010 (2 set bits, 2 is prime)
11 -> 1011 (3 set bits, 3 is prime)
12 -> 1100 (2 set bits, 2 is prime)
13 -> 1101 (3 set bits, 3 is prime)
14 -> 1110 (3 set bits, 3 is prime)
Hence count is 5```

Explanation: In this program we find a total number, that’s having prime number of set bit. so we use a CPP predefined function __builtin_popcount() these functions provide a total set bit in number. as well as be check the total bit’s is prime or not if prime we increase the counter these process repeat till given range.

## C++

 `// C++ program to count total prime ` `// number of set bits in given range` `#include ` `using` `namespace` `std;`   `bool` `isPrime(``int` `n)` `{` `    ``// Corner cases` `    ``if` `(n <= 1)  ``return` `false``;` `    ``if` `(n <= 3)  ``return` `true``;` ` `  `    ``// This is checked so that we can skip ` `    ``// middle five numbers in below loop` `    ``if` `(n%2 == 0 || n%3 == 0) ``return` `false``;` ` `  `    ``for` `(``int` `i=5; i*i<=n; i=i+6)` `        ``if` `(n%i == 0 || n%(i+2) == 0)` `           ``return` `false``;` ` `  `    ``return` `true``;` `}`   `// count number, that contains prime number of set bit` `int` `primeBitsInRange(``int` `l, ``int` `r)` `{` `    ``// tot_bit store number of bit in number` `    ``int` `tot_bit, count = 0;`   `    ``// iterate loop from l to r` `    ``for` `(``int` `i = l; i <= r; i++) {`   `        ``// use predefined function for finding ` `        ``// set bit it is return number of set bit` `        ``tot_bit = __builtin_popcount(i);`   `        ``// check tot_bit prime or, not` `        ``if` `(isPrime(tot_bit))` `            ``count++;` `    ``}` `    ``return` `count;` `}`   `// Driven Program` `int` `main()` `{` `    ``int` `l = 6, r = 10;    ` `    ``cout << primeBitsInRange(l, r);` `    ``return` `0;` `}`

## Java

 `// Java program to count total prime ` `// number of set bits in given range` `import` `java.lang.*;`   `class` `GFG{` `static` `boolean` `isPrime(``int` `n)` `{` `    ``// Corner cases` `    ``if` `(n <= ``1``) ``return` `false``;` `    ``if` `(n <= ``3``) ``return` `true``;`   `    ``// This is checked so that we can skip ` `    ``// middle five numbers in below loop` `    ``if` `(n%``2` `== ``0` `|| n%``3` `== ``0``) ``return` `false``;`   `    ``for` `(``int` `i=``5``; i*i<=n; i=i+``6``)` `        ``if` `(n%i == ``0` `|| n%(i+``2``) == ``0``)` `        ``return` `false``;`   `    ``return` `true``;` `}`   `// count number, that contains prime number of set bit` `static` `int` `primeBitsInRange(``int` `l, ``int` `r)` `{` `    ``// tot_bit store number of bit in number` `    ``int` `tot_bit, count = ``0``;`   `    ``// iterate loop from l to r` `    ``for` `(``int` `i = l; i <= r; i++) {`   `        ``// use predefined function for finding ` `        ``// set bit it is return number of set bit` `        ``tot_bit = Integer.bitCount(i);`   `        ``// check tot_bit prime or, not` `        ``if` `(isPrime(tot_bit))` `            ``count++;` `    ``}` `    ``return` `count;` `}`   `// Driven Program` `public` `static` `void` `main(String[] args)` `{` `    ``int` `l = ``6``, r = ``10``; ` `    ``System.out.println(primeBitsInRange(l, r));` `    `  `}` `}` `// This code is Contributed by mits`

## Python3

 `# Python3 program to count total prime ` `# number of set bits in given range` `def` `isPrime(n):`   `    ``# Corner cases` `    ``if` `(n <``=` `1``): ``return` `False``;` `    ``if` `(n <``=` `3``): ``return` `True``;`   `    ``# This is checked so that we can skip ` `    ``# middle five numbers in below loop` `    ``if` `(n ``%` `2` `=``=` `0` `or` `n ``%` `3` `=``=` `0``):` `        ``return` `False``;` `        `  `    ``i ``=` `5``;` `    ``while` `(i ``*` `i <``=` `n):` `        ``if``(n ``%` `i ``=``=` `0` `or` `n ``%` `(i ``+` `2``) ``=``=` `0``):` `            ``return` `False``;` `        ``i ``=` `i ``+` `6``;`   `    ``return` `True``;`   `# count number, that contains ` `# prime number of set bit` `def` `primeBitsInRange(l, r):`   `    ``# tot_bit store number of` `    ``# bit in number` `    ``count ``=` `0``;`   `    ``# iterate loop from l to r` `    ``for` `i ``in` `range``(l, r ``+` `1``):`   `        ``# use predefined function for finding ` `        ``# set bit it is return number of set bit` `        ``tot_bit ``=` `bin``(i).count(``'1'``);`   `        ``# check tot_bit prime or, not` `        ``if` `(isPrime(tot_bit)):` `            ``count ``+``=` `1``;`   `    ``return` `count;`   `# Driver Code` `l ``=` `6``; ` `r ``=` `10``; ` `print``(primeBitsInRange(l, r));`   `# This code is contributed by mits`

## C#

 `// C# program to count total prime ` `// number of set bits in given range `   `class` `GFG{` `    `  `    ``// To count the bits` `static` `int` `BitCount(``int` `n)` `{` `    ``int` `count = 0;` `    ``while` `(n != 0)` `    ``{` `        ``count++;` `        ``n &= (n - 1);` `    ``}` `    `  `    ``return` `count;` `}` `        `  `static` `bool` `isPrime(``int` `n) ` `{ ` `    ``// Corner cases ` `    ``if` `(n <= 1) ``return` `false``; ` `    ``if` `(n <= 3) ``return` `true``; `   `    ``// This is checked so that we can skip ` `    ``// middle five numbers in below loop ` `    ``if` `(n%2 == 0 || n%3 == 0) ``return` `false``; `   `    ``for` `(``int` `i=5; i*i<=n; i=i+6) ` `        ``if` `(n%i == 0 || n%(i+2) == 0) ` `        ``return` `false``; `   `    ``return` `true``; ` `} `   `// count number, that contains prime number of set bit ` `static` `int` `primeBitsInRange(``int` `l, ``int` `r) ` `{ ` `    ``// tot_bit store number of bit in number ` `    ``int` `tot_bit, count = 0; `   `    ``// iterate loop from l to r ` `    ``for` `(``int` `i = l; i <= r; i++) { `   `        ``// use predefined function for finding ` `        ``// set bit it is return number of set bit ` `        ``tot_bit = BitCount(i); `   `        ``// check tot_bit prime or, not ` `        ``if` `(isPrime(tot_bit)) ` `            ``count++; ` `    ``} ` `    ``return` `count; ` `} `   `// Driven Program ` `public` `static` `void` `Main() ` `{ ` `    ``int` `l = 6, r = 10; ` `    ``System.Console.WriteLine(primeBitsInRange(l, r)); ` `    `  `} ` `} ` `// This code is Contributed by mits `

## PHP

 ``

## Javascript

 ``

Output:

`4`

Time Complexity : Let’s n = (r-l)
so overall time complexity is N*sqrt(N)
We can optimize above solution using Sieve of Eratosthenes.
Prime Number of Set Bits in Binary Representation | Set 2

Approach#2:  Using sieve of eratosthenes

The code uses three functions: sieve_of_eratosthenes(n), count_set_bits(n), and count_prime_set_bits(l, r). The first function, sieve_of_eratosthenes(n), generates a list of Boolean values indicating whether each integer up to n is prime or not. The second function, count_set_bits(n), returns the number of set bits (binary digits equal to 1) in the binary representation of n. The third function, count_prime_set_bits(l, r), counts the number of integers between l and r (inclusive) whose binary representations have a prime number of set bits. It does so by first using the sieve_of_eratosthenes function to generate a list of primes up to the maximum number of bits in any integer between l and r. It then iterates over each integer between l and r, counts the number of set bits in its binary representation using count_set_bits, and increments a counter if that count is a prime number. The final count is returned.

Algorithm

1. Generate all primes from 1 to the maximum number of set bits possible in the binary representation of r (let’s call it max_bits).
2. Loop from l to r (both inclusive).
3. Convert each decimal number to its binary representation.
4. Count the number of set bits in the binary representation.
5. Check if the count is prime or not using the pre-generated primes.
6. If the count is prime, increment the counter.
7. Return the counter as the answer.

## C++

 `#include ` `#include ` `#include ` `using` `namespace` `std;`   `vector<``bool``> sieve_of_eratosthenes(``int` `n) {` `  ``vector<``bool``> primes(n+1, ``true``);` `  ``primes = primes = ``false``;` `  ``for` `(``int` `i = 2; i <= ``sqrt``(n); i++) {` `    ``if` `(primes[i]) {` `      ``for` `(``int` `j = i * i; j <= n; j += i) {` `        ``primes[j] = ``false``;` `      ``}` `    ``}` `  ``}` `  ``return` `primes;` `}`   `int` `count_set_bits(``int` `n) {` `  ``int` `count = 0;` `  ``while` `(n > 0) {` `    ``count += n % 2;` `    ``n /= 2;` `  ``}` `  ``return` `count;` `}`   `int` `count_prime_set_bits(``int` `l, ``int` `r) {` `  ``int` `max_bits = log2(r) + 1;` `  ``vector<``bool``> primes = sieve_of_eratosthenes(max_bits);` `  ``int` `count = 0;` `  ``for` `(``int` `i = l; i <= r; i++) {` `    ``if` `(primes[count_set_bits(i)]) {` `      ``count++;` `    ``}` `  ``}` `  ``return` `count;` `}`   `int` `main() {` `  ``int` `l = 6;` `  ``int` `r = 10;` `  ``cout << count_prime_set_bits(l, r) << endl;` `  ``return` `0;` `}`

## Python3

 `from` `math ``import` `sqrt`   `def` `sieve_of_eratosthenes(n):` `    ``primes ``=` `[``True``] ``*` `(n``+``1``)` `    ``primes[``0``] ``=` `primes[``1``] ``=` `False` `    ``for` `i ``in` `range``(``2``, ``int``(sqrt(n))``+``1``):` `        ``if` `primes[i]:` `            ``for` `j ``in` `range``(i``*``i, n``+``1``, i):` `                ``primes[j] ``=` `False` `    ``return` `primes`   `def` `count_set_bits(n):` `    ``count ``=` `0` `    ``while` `n>``0``:` `        ``count ``+``=` `n``%``2` `        ``n ``/``/``=` `2` `    ``return` `count`   `def` `count_prime_set_bits(l, r):` `    ``max_bits ``=` `len``(``bin``(r))``-``2` `    ``primes ``=` `sieve_of_eratosthenes(max_bits)` `    ``count ``=` `0` `    ``for` `i ``in` `range``(l, r``+``1``):` `        ``if` `primes[count_set_bits(i)]:` `            ``count ``+``=` `1` `    ``return` `count` `l``=``6` `r``=``10` `print``(count_prime_set_bits(l, r))`

Output

`4`

Time Complexity: O((r-l+1) * log log r), where log log r is the time complexity of sieve_of_eratosthenes.

Auxiliary Space: O(log log r)

My Personal Notes arrow_drop_up