Counting Bits

Counting Bits - Problem

Given an integer n, return an array ans of length n + 1 such that for each i (where 0 <= i <= n), ans[i] is the number of 1's in the binary representation of i.

For example, if n = 2, the array should contain the count of 1-bits for numbers 0, 1, and 2:

0 in binary is 0 → 0 ones
1 in binary is 1 → 1 one
2 in binary is 10 → 1 one

So the result would be [0, 1, 1].

Input & Output

Example 1 — Basic Case

$ Input: n = 2

› Output: [0,1,1]

💡 Note: 0 in binary: 0 → 0 ones, 1 in binary: 1 → 1 one, 2 in binary: 10 → 1 one. Result: [0,1,1]

Example 2 — Larger Range

$ Input: n = 5

› Output: [0,1,1,2,1,2]

💡 Note: Count 1-bits: 0→0, 1→1, 2(10)→1, 3(11)→2, 4(100)→1, 5(101)→2

Example 3 — Single Number

$ Input: n = 0

› Output: [0]

💡 Note: Only need to count bits for 0, which has zero 1-bits

Constraints

0 ≤ n ≤ 10⁵

Visualization

Tap to expand

Asked in

Apple 25 M Microsoft 20 G Google 15

The key insight is recognizing that each number's 1-bit count can be derived from a previously computed smaller number. The optimal Dynamic Programming approach uses either dp[i] = dp[i >> 1] + (i & 1) or dp[i] = dp[i & (i-1)] + 1. Time: O(n), Space: O(1)

Common Approaches

✓ Bit Manipulation - Remove Rightmost 1-bit

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

Another elegant DP approach using the bit manipulation trick: i & (i-1) removes the rightmost 1-bit from i. So the number of 1-bits in i equals the number of 1-bits in i & (i-1) plus 1 (for the removed bit).

Brute Force - Count Bits for Each Number

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

The straightforward approach: for every number i from 0 to n, convert it to binary and count how many 1-bits it contains. We can do this by repeatedly checking if the least significant bit is 1, then right-shifting.

Dynamic Programming - Build from Previous Results

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

The key insight is that the number of 1-bits in i equals the number of 1-bits in i/2 plus 1 if i is odd. This is because right-shifting removes the least significant bit, and we add 1 if that bit was a 1.

Bit Manipulation - Remove Rightmost 1-bit — Algorithm Steps

Initialize dp array with dp[0] = 0
For each i from 1 to n, use dp[i] = dp[i & (i-1)] + 1
i & (i-1) removes the rightmost 1-bit, giving us a smaller number
Add 1 for the removed bit to get the total count

Visualization

Tap to expand

Step-by-Step Walkthrough

Identify Pattern

i & (i-1) removes the rightmost 1-bit

Use Previous Result

dp[i] = dp[i & (i-1)] + 1

Build Solution

Each number uses a previously computed smaller value

Code -

solution.c — C

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

int* solution(int n, int* returnSize) {
    *returnSize = n + 1;
    int* dp = (int*)calloc(*returnSize, sizeof(int));
    for (int i = 1; i <= n; i++) {
        dp[i] = dp[i & (i - 1)] + 1;
    }
    return dp;
}

int main() {
    int n;
    scanf("%d", &n);
    int returnSize;
    int* result = solution(n, &returnSize);
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("%d", result[i]);
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single loop through numbers 1 to n, each operation is constant time

✓ Linear Growth

Space Complexity

O(1)

Only using the output array for storage

✓ Linear Space

523.0K Views

High Frequency

~15 min Avg. Time

8.4K 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 - Remove Rightmost 1-bit — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler