Number of 1 Bits - Practice Coding Problems

Number of 1 Bits - Problem

Given a positive integer n, write a function that returns the number of set bits in its binary representation. This is also known as the Hamming weight.

A set bit is a bit that has a value of 1. For example, the binary representation of 11 is 1011, which has three set bits.

Goal: Count how many '1' bits appear in the binary representation of the given number.

Example: For n = 11 (binary: 1011), the answer is 3 because there are three '1' bits.

Input & Output

example_1.py — Basic case

$ Input: n = 11

› Output: 3

💡 Note: The binary representation of 11 is 1011, which contains three '1' bits.

example_2.py — Power of 2

$ Input: n = 8

› Output: 1

💡 Note: The binary representation of 8 is 1000, which contains only one '1' bit.

example_3.py — All bits set

$ Input: n = 15

› Output: 4

💡 Note: The binary representation of 15 is 1111, which contains four '1' bits.

Constraints

1 ≤ n ≤ 2³¹ - 1
The input is guaranteed to be a 32-bit unsigned integer
You must handle the number as an unsigned integer in languages that support it

Visualization

Tap to expand

Understanding the Visualization

Identify the pattern

n & (n-1) always clears the rightmost 1-bit

Apply repeatedly

Each operation removes exactly one set bit

Count operations

Number of operations equals number of set bits

Terminate when n=0

All set bits have been cleared

Key Takeaway

🎯 Key Insight: Brian Kernighan's algorithm `n & (n-1)` eliminates exactly one set bit per iteration, making it optimal for sparse bit patterns where most bits are 0.

Asked in

🍎 Apple 45 G Google 38 ⊞ Microsoft 32 a Amazon 28

The optimal approach is Brian Kernighan's algorithm using n & (n-1) to clear the rightmost set bit in each iteration. This runs in O(k) time where k is the number of set bits, making it more efficient than checking all bit positions. For maximum performance, use built-in functions like Integer.bitCount() or __builtin_popcount().

Common Approaches

Approach	Time	Space	Notes
✓ Built-in Population Count	O(1)	O(1)	Use language-specific built-in functions that implement optimized bit counting
Brian Kernighan's Algorithm	O(k)	O(1)	Clear the lowest set bit repeatedly until the number becomes zero
Brute Force (Check Each Bit)	O(log n)	O(1)	Check each bit position one by one using bit shifting

Built-in Population Count — Algorithm Steps

Use the built-in bit counting function
Return the result directly
Examples: Python's bin().count('1'), Java's Integer.bitCount(), C++'s __builtin_popcount()

Visualization

Tap to expand

Step-by-Step Walkthrough

Input: n = 15

Binary representation: 1111

Call built-in function

Use language-specific optimized function

Hardware acceleration

May use CPU POPCNT instruction

Return result: 4

All 4 bits are set

Code -

solution.c — C

#include <stdio.h>
#include <stdint.h>

int hammingWeight(uint32_t n) {
    return __builtin_popcount(n);
}

int main() {
    uint32_t n;
    scanf("%u", &n);
    printf("%d\n", hammingWeight(n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(1)

Built-in functions often use lookup tables or CPU instructions that execute in constant time

✓ Linear Growth

Space Complexity

O(1)

No extra space needed beyond the function call

✓ Linear Space

98.0K Views

High Frequency

~12 min Avg. Time

2.5K 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

Built-in Population Count — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler