Counting Bits - Practice Coding Problems

Counting Bits - Problem

Counting Bits in Binary Representations

Given an integer n, you need to create an array that contains the count of 1-bits in the binary representation of every number from 0 to n inclusive.

Your task: Return an array ans of length n + 1 where ans[i] represents the number of 1's in the binary representation of number i.

Example: For n = 5, the binary representations are:
• 0 → 0 (zero 1's)
• 1 → 1 (one 1)
• 2 → 10 (one 1)
• 3 → 11 (two 1's)
• 4 → 100 (one 1)
• 5 → 101 (two 1's)

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

Input & Output

example_1.py — Basic Case

$ Input: n = 2

› Output: [0, 1, 1]

💡 Note: 0 → 0 (0 ones), 1 → 1 (1 one), 2 → 10 (1 one)

example_2.py — Medium Case

$ Input: n = 5

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

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

example_3.py — Edge Case

$ Input: n = 0

› Output: [0]

💡 Note: Only number 0, which has 0 ones in its binary representation

Constraints

0 ≤ n ≤ 10⁵
Follow up: Can you solve it in O(n) time?
Challenge: Can you do it without using built-in functions?

Visualization

Tap to expand

Understanding the Visualization

Notice the Pattern

Each number's bit count relates to a smaller number

Right Shift Insight

i >> 1 gives us the number with the rightmost bit removed

Add Last Bit

i & 1 tells us if the last bit was 1 or 0

Build Solution

Combine these insights: dp[i] = dp[i >> 1] + (i & 1)

Key Takeaway

🎯 Key Insight: Every number's bit pattern reuses most bits from a smaller number (i >> 1), we just need to account for the rightmost bit!

Asked in

G Google 45 a Amazon 38 f Meta 32 ⊞ Microsoft 25

The optimal solution uses dynamic programming with the key insight that dp[i] = dp[i >> 1] + (i & 1). This means the number of 1-bits in i equals the 1-bits in i/2 plus 1 if i is odd. This achieves O(n) time complexity by reusing previously computed results instead of counting bits from scratch for each number.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming (Optimal)	O(n)	O(1)	Use the relationship: dp[i] = dp[i >> 1] + (i & 1)
Brute Force (Count Each Number Individually)	O(n * log n)	O(1)	Count 1-bits for each number from 0 to n using bit manipulation

Dynamic Programming (Optimal) — Algorithm Steps

Initialize result array with dp[0] = 0
For each number i from 1 to n:
Calculate dp[i] = dp[i >> 1] + (i & 1)
The result uses previously computed values

Visualization

Tap to expand

Step-by-Step Walkthrough

Base Case

dp[0] = 0 (number 0 has zero 1-bits)

Pattern Discovery

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

Build Solution

Use previous results to compute current

Complete Array

Fill entire array in one pass

Code -

solution.c — C

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

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

int main() {
    int n;
    scanf("%d", &n);
    int returnSize;
    int* result = countBits(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 pass through numbers 0 to n, each calculation is O(1)

✓ Linear Growth

Space Complexity

O(1)

Only using the output array, no extra space for memoization

✓ Linear Space

47.0K Views

High Frequency

~15 min Avg. Time

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

Dynamic Programming (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler