Number of 1 Bits

Problem Statement

Write a function that takes an unsigned integer and returns the number of 1 bits (Hamming weight).

You need to solve this problem efficiently.

What to notice first

• Key insight 1 for Number of 1 Bits
• Key insight 2 for solving this problem
• Key insight 3 specific to the approach

Examples

Input	Output	Explanation
Example 1	Result 1	Explanation for example 1
Example 2	Result 2	Explanation for example 2

Constraints

• Constraint 1 for Number of 1 Bits
• Constraint 2
• Constraint 3

Real-World Applications

Where this pattern appears

• Network packet header parsing
• Permission and flag management in operating systems
• Compression algorithms and encoding
• Hardware register manipulation and embedded systems

Complexity Comparison

Approach	Time	Space	Best When
Loop	O(n)	O(1)	When applicable
Kernighan	O(n)	O(1)	When applicable
Builtin	O(n)	O(1)	When applicable

Approach 1: Loop

★ Recommended

This approach provides an efficient solution for number of 1 bits.

⏱ Time O(n) Single pass 💾 Space O(1) Minimal storage

Solution Code

Python

number_of_1_bits_loop.py

def number_of_1_bits_loop(n: int) -> int:
    """Count 1 bits by checking each bit."""
    count = 0
    while n:
        count += n & 1
        n >>= 1
    return count

# Test cases
print(number_of_1_bits_loop(11))  # 3
print(number_of_1_bits_loop(128))  # 1

C++

number_of_1_bits_loop.cpp

#include <cstdint>
using namespace std;

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

int main() {
    cout << numberOf1BitsLoop(11) << endl;  // 3
    return 0;
}

Java

number_of_1_bits_loop.java

public class NumberOf1BitsLoop {
    public static int numberOf1BitsLoop(int n) {
        int count = 0;
        while (n != 0) {
            count += n & 1;
            n >>>= 1;
        }
        return count;
    }

    public static void main(String[] args) {
        System.out.println(numberOf1BitsLoop(11));  // 3
    }
}

JavaScript

number_of_1_bits_loop.js

function numberOf1BitsLoop(n) {
    let count = 0;
    while (n) {
        count += n & 1;
        n >>>= 1;
    }
    return count;
}

console.log(numberOf1BitsLoop(11));  // 3
console.log(numberOf1BitsLoop(128));  // 1

Rust

number_of_1_bits_loop.rs

fn number_of_1_bits_loop(mut n: u32) -> i32 {
    let mut count = 0;
    while n > 0 {
        count += (n & 1) as i32;
        n >>= 1;
    }
    count
}

fn main() {
    println!("{}", number_of_1_bits_loop(11));  // 3
    println!("{}", number_of_1_bits_loop(128));  // 1
}

Go

number_of_1_bits_loop.go

package main

import "fmt"

func numberOf1BitsLoop(num uint32) int {
  count := 0
  for num > 0 {
    count += int(num & 1)
    num >>= 1
  }
  return count
}

func main() {
  fmt.Println(numberOf1BitsLoop(11))  // 3
  fmt.Println(numberOf1BitsLoop(128))  // 1
}

Approach 2: Kernighan

🎯 Interview Favourite

This approach provides an efficient solution for number of 1 bits.

⏱ Time O(n) Single pass 💾 Space O(1) Minimal storage

Solution Code

Python

number_of_1_bits_kernighan.py

# Python Solution
# Problem: number-of-1-bits
# Approach: kernighan

# Implementation placeholder for number_of_1_bits_kernighan
# This file is auto-generated and should contain the solution code.

def number_of_1_bits_kernighan():
    pass

if __name__ == "__main__":
    pass

C++

number_of_1_bits_kernighan.cpp

# C++ Solution
# Problem: number-of-1-bits
# Approach: kernighan

# Implementation placeholder for number_of_1_bits_kernighan
# This file is auto-generated and should contain the solution code.

def number_of_1_bits_kernighan():
    pass

if __name__ == "__main__":
    pass

Java

number_of_1_bits_kernighan.java

# Java Solution
# Problem: number-of-1-bits
# Approach: kernighan

# Implementation placeholder for number_of_1_bits_kernighan
# This file is auto-generated and should contain the solution code.

def number_of_1_bits_kernighan():
    pass

if __name__ == "__main__":
    pass

JavaScript

number_of_1_bits_kernighan.js

# JavaScript Solution
# Problem: number-of-1-bits
# Approach: kernighan

# Implementation placeholder for number_of_1_bits_kernighan
# This file is auto-generated and should contain the solution code.

def number_of_1_bits_kernighan():
    pass

if __name__ == "__main__":
    pass

Rust

number_of_1_bits_kernighan.rs

# Rust Solution
# Problem: number-of-1-bits
# Approach: kernighan

# Implementation placeholder for number_of_1_bits_kernighan
# This file is auto-generated and should contain the solution code.

def number_of_1_bits_kernighan():
    pass

if __name__ == "__main__":
    pass

Go

number_of_1_bits_kernighan.go

# Golang Solution
# Problem: number-of-1-bits
# Approach: kernighan

# Implementation placeholder for number_of_1_bits_kernighan
# This file is auto-generated and should contain the solution code.

def number_of_1_bits_kernighan():
    pass

if __name__ == "__main__":
    pass

Approach 3: Builtin

✓ Simple

This approach provides an efficient solution for number of 1 bits.

⏱ Time O(n) Single pass 💾 Space O(1) Minimal storage

Solution Code

Python

number_of_1_bits_builtin.py

# Python Solution
# Problem: number-of-1-bits
# Approach: builtin

# Implementation placeholder for number_of_1_bits_builtin
# This file is auto-generated and should contain the solution code.

def number_of_1_bits_builtin():
    pass

if __name__ == "__main__":
    pass

C++

number_of_1_bits_builtin.cpp

# C++ Solution
# Problem: number-of-1-bits
# Approach: builtin

# Implementation placeholder for number_of_1_bits_builtin
# This file is auto-generated and should contain the solution code.

def number_of_1_bits_builtin():
    pass

if __name__ == "__main__":
    pass

Java

number_of_1_bits_builtin.java

# Java Solution
# Problem: number-of-1-bits
# Approach: builtin

# Implementation placeholder for number_of_1_bits_builtin
# This file is auto-generated and should contain the solution code.

def number_of_1_bits_builtin():
    pass

if __name__ == "__main__":
    pass

JavaScript

number_of_1_bits_builtin.js

# JavaScript Solution
# Problem: number-of-1-bits
# Approach: builtin

# Implementation placeholder for number_of_1_bits_builtin
# This file is auto-generated and should contain the solution code.

def number_of_1_bits_builtin():
    pass

if __name__ == "__main__":
    pass

Rust

number_of_1_bits_builtin.rs

# Rust Solution
# Problem: number-of-1-bits
# Approach: builtin

# Implementation placeholder for number_of_1_bits_builtin
# This file is auto-generated and should contain the solution code.

def number_of_1_bits_builtin():
    pass

if __name__ == "__main__":
    pass

Go

number_of_1_bits_builtin.go

# Golang Solution
# Problem: number-of-1-bits
# Approach: builtin

# Implementation placeholder for number_of_1_bits_builtin
# This file is auto-generated and should contain the solution code.

def number_of_1_bits_builtin():
    pass

if __name__ == "__main__":
    pass

Related Problems

• Two Sum ↗ Easy #1
• Palindrome Number ↗ Easy #9

Interview Tips

Key trade-offs to discuss

• Time vs. space trade-offs between approaches
• Handling edge cases (empty inputs, single elements, duplicates)
• Optimization opportunities and when they matter
• Follow-up variations and constraint changes

← Previous
#190 Reverse Bits