Number of 1 Bits

Number of 1 Bits - Problem

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

A set bit is a bit that has a value of 1 in the binary representation of a number.

Input & Output

Example 1 — Basic Case

$ Input: n = 11

› Output: 3

💡 Note: 11 in binary is 1011, which has three 1-bits at positions 0, 1, and 3

Example 2 — Power of Two

$ Input: n = 8

› Output: 1

💡 Note: 8 in binary is 1000, which has exactly one 1-bit at position 3

Example 3 — All Bits Set

$ Input: n = 7

› Output: 3

💡 Note: 7 in binary is 111, which has three consecutive 1-bits

Constraints

1 ≤ n ≤ 2³¹ - 1

Visualization

Tap to expand

Asked in

🍎 Apple 25 Ⓜ Microsoft 22 G Google 18

The key insight is that we can count set bits using bit manipulation. The optimal approach uses Brian Kernighan's algorithm with n & (n-1) to clear the lowest set bit in each iteration. Time: O(k) where k is number of set bits, Space: O(1)

Common Approaches

✓ Bit Manipulation - Right Shift

⏱️ Time: O(log n) Space: O(1)

Use bitwise operations to check the least significant bit, then right shift to check the next bit. More efficient than division.

Brian Kernighan's Algorithm

⏱️ Time: O(k) Space: O(1)

Use the trick n & (n-1) to clear the lowest set bit. This skips over all zero bits and only iterates for each 1-bit.

Brute Force - Check Each Bit

⏱️ Time: O(log n) Space: O(1)

Convert the number to binary by repeatedly dividing by 2 and checking remainders. Count how many remainders are 1.

Bit Manipulation - Right Shift — Algorithm Steps

Check if the least significant bit is 1 using n & 1
If true, increment count
Right shift n by 1 position
Repeat until n becomes 0

Visualization

Tap to expand

Step-by-Step Walkthrough

Check LSB

Use n & 1 to check least significant bit

Right Shift

Use n >>= 1 to shift bits right

Result

Count all 1-bits efficiently

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

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

int main() {
    int n;
    scanf("%d", &n);
    int result = solution(n);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(log n)

We right shift n until it becomes 0, taking log n iterations

⚡ Linearithmic

Space Complexity

O(1)

Only using a counter variable

✓ Linear Space

125.0K Views

Medium Frequency

~15 min Avg. Time

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

Bit Manipulation - Right Shift — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler