# Mastering the Hamming Weight Problem on LeetCode: A Comprehensive Guide

## Dive into efficient solutions for calculating the Hamming weight of integers, featuring recursion, bit manipulation, and binary counting techniques.

Hello, fellow code enthusiasts! Today, I'm excited to delve into a fascinating challenge that often pops up in software engineering interviews: determining the Hamming weight of a positive integer's binary representation.

This problem, sometimes referred to as finding the number of set bits, is a great way to test your understanding of binary numbers and bit manipulation techniques. Let's explore this problem together, breaking down its intricacies and uncovering efficient solutions.

## Introduction to the Problem

Consider the task of writing a function that takes the binary representation of a positive integer and returns the number of set bits it contains. The set bits are simply the bits in the binary representation that are '1'. For example, the integer 11, which is '1011' in binary, has three set bits. This concept is integral to various computing tasks and algorithms, making it a staple in technical interviews.

Set Bit - "A set bit refers to a bit in the binary representation of a number that has a value of 1."

Write a function that takes the binary representation of a positive integer and returns the number of set bits it has (also known as the Hamming weight).

Example 1:

Input: n = 11, Output: 3

Example 2:

Input: n = 128, Output: 1

Example 3:

Input: n = 2147483645, Output: 30

## Understanding the Solution

To tackle this problem, we'll explore three different approaches: recursion, bit manipulation, and bin and counting. Each method offers unique insights into handling binary data, with varying complexities and efficiencies.

### Solution 1: Using Recursion

Recursion offers a straightforward way to approach this problem by reducing the input size with each call. Here's how you can implement it:

```
def hammingWeight(self, n: int) -> int:
# Base cases: if n is 0, return 0; if n is 1, return 1
if n == 0:
return 0
if n == 1:
return 1
# Recursive call: n & (n-1) drops the lowest set bit, add 1 for the dropped bit
return self.hammingWeight(n & (n-1)) + 1
```

### Solution 2: Using Bit Manipulation

Bit manipulation is a highly efficient way to solve this problem by directly interacting with the binary representation:

```
def hammingWeight(self, n: int) -> int:
count = 0
while n:
# If the least significant bit is 1, increment count
if n & 1:
count += 1
# Right shift n to check the next bit
n = n >> 1
return count
```

### Solution 3: Using Bin and Counting

For those looking for a simpler approach, converting the number to a binary string and counting the '1's is the most straightforward method:

```
def hammingWeight(self, n: int) -> int:
# Convert n to binary string and count '1's
return bin(n).count('1')
```

## Conclusion

Understanding and implementing these solutions not only prepares you for engineering interviews but also sharpens your problem-solving skills.

Each method, whether it's the recursive, bit manipulation, or the straightforward bin and counting, offers a different perspective on tackling binary data manipulation. Remember, the key to mastering technical interviews is practice and understanding the underlying concepts.

Happy coding!