Prime Number of Set Bits in Binary Representation

Prime Number of Set Bits in Binary Representation - Problem

Binary Detective Challenge: Given two integers left and right, count how many numbers in the inclusive range [left, right] have a prime number of set bits (1's) in their binary representation.

What are set bits? The number of 1's when a number is written in binary. For example:
• 21 in binary is 10101, which has 3 set bits
• 6 in binary is 110, which has 2 set bits

Goal: Return the count of numbers whose set bit count is a prime number (2, 3, 5, 7, 11, 13, ...).

Example: For range [6, 10], we check each number's binary representation and count set bits, then determine if that count is prime.

Input & Output

example_1.py — Basic Range

$ Input: left = 6, right = 10

› Output: 4

💡 Note: 6→110(2 bits, prime), 7→111(3 bits, prime), 8→1000(1 bit, not prime), 9→1001(2 bits, prime), 10→1010(2 bits, prime). Total: 4 numbers with prime set bits.

example_2.py — Small Range

$ Input: left = 10, right = 15

› Output: 5

💡 Note: 10→1010(2 bits, prime), 11→1011(3 bits, prime), 12→1100(2 bits, prime), 13→1101(3 bits, prime), 14→1110(3 bits, prime), 15→1111(4 bits, not prime). Total: 5 numbers.

example_3.py — Single Number

$ Input: left = 1, right = 1

› Output: 0

💡 Note: 1→1(1 bit). Since 1 is not a prime number, the result is 0.

Constraints

1 ≤ left ≤ right ≤ 10⁶
The maximum number of set bits is at most 32 (since 2³² > 10⁶)
Key insight: We only need to check primality for numbers up to 32

Visualization

Tap to expand

Understanding the Visualization

Convert to Binary

Transform each number to its binary representation

Count Set Bits

Count the number of 1's in the binary string

Check Prime

Determine if the count is a prime number

Accumulate Result

Add to counter if prime, continue to next number

Key Takeaway

🎯 Key Insight: Since we're limited to 32 bits maximum, we can precompute all prime numbers up to 32 and use bit manipulation tricks for O(1) set bit counting, making the solution very efficient!

Asked in

a Amazon 25 G Google 18 ⊞ Microsoft 12 Apple 8

The optimal approach uses precomputed prime checking and efficient bit manipulation. Since numbers are limited to 10⁶, we only need to check primality up to 32 bits. Use built-in bit counting functions and precompute primes for O(1) lookup.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Basic Bit Counting)	O((right - left) * log(right) * sqrt(log(right)))	O(1)	For each number, count set bits using string conversion and check primality with trial division

Brute Force (Basic Bit Counting) — Algorithm Steps

Iterate through each number from left to right
Convert number to binary string and count '1' characters
Check if the count is prime using trial division
Increment result counter if prime
Return total count

Visualization

Tap to expand

Step-by-Step Walkthrough

Check Number 6

6 → 110 → 2 set bits → 2 is prime ✓

Check Number 7

7 → 111 → 3 set bits → 3 is prime ✓

Check Number 8

8 → 1000 → 1 set bit → 1 is not prime ✗

Code -

solution.c — C

#include <stdio.h>
#include <math.h>

int popCount(int n) {
    int count = 0;
    while (n) {
        count += n & 1;
        n >>= 1;
    }
    return count;
}

int isPrime(int n) {
    if (n < 2) return 0;
    if (n == 2) return 1;
    if (n % 2 == 0) return 0;
    for (int i = 3; i <= (int)sqrt(n); i += 2) {
        if (n % i == 0) return 0;
    }
    return 1;
}

int countPrimeSetBits(int left, int right) {
    int count = 0;
    for (int num = left; num <= right; num++) {
        int setBits = popCount(num);
        if (isPrime(setBits)) {
            count++;
        }
    }
    return count;
}

int main() {
    int left, right;
    scanf("%d %d", &left, &right);
    printf("%d\n", countPrimeSetBits(left, right));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O((right - left) * log(right) * sqrt(log(right)))

For each number we do O(log n) bit counting and O(sqrt(bits)) prime checking

⚡ Linearithmic

Space Complexity

O(1)

Only using constant extra variables

✓ Linear Space

28.6K Views

Medium Frequency

~12 min Avg. Time

892 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Basic Bit Counting) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler