# Leetcode Number-of-1-Bits

#### 2022-07-22 14:45

> ##### Algorithms:
>
> #algorithm #bit_manipulation
>
> ##### Data structures:
>
> #DS #bitset
>
> ##### Difficulty:
>
> #coding_problems #difficulty_easy
>
> ##### Additional tags:
>
> #leetcode
>
> ##### Revisions:
>
> N/A

##### Related topics:

##### Links:

- [Link to problem](https://leetcode.com/problems/number-of-1-bits/)

  ***

### Problem

Write a function that takes an unsigned integer and returns the number of '1' bits it has (also known as the [Hamming weight](http://en.wikipedia.org/wiki/Hamming_weight)).

#### Examples

**Example 1:**

**Input:** n = 00000000000000000000000000001011
**Output:** 3
**Explanation:** The input binary string **00000000000000000000000000001011** has a total of three '1' bits.

**Example 2:**

**Input:** n = 00000000000000000000000010000000
**Output:** 1
**Explanation:** The input binary string **00000000000000000000000010000000** has a total of one '1' bit.

**Example 3:**

**Input:** n = 11111111111111111111111111111101
**Output:** 31
**Explanation:** The input binary string **11111111111111111111111111111101** has a total of thirty one '1' bits.

#### Constraints

- The input must be a **binary string** of length `32`.

### Thoughts

> [!summary]
> This is a #bit_manipulation problem.

Two methods for this problem.

#### Method 1: cpp's STL implementation

simply use [bitset::count](https://en.cppreference.com/w/cpp/utility/bitset/count)

#### Method 2: (n & (n - 1)) method

By using n = (n & (n - 1)), we can remove the last `true` in the original bitset:

```
5 : 101
4 : 100
5 & 4 : 100

10 : 1010
9  : 1001
10 & 9 : 1000
```

n - 1 changes the trailing `false`s to `true`, and change the last `true` to false, and by AND operation, we can remove the last `true` bit.

### Solution

#### CPP STL:

```cpp
class Solution {
public:
int hammingWeight(uint32_t n) { return bitset<32>(n).count(); }
};
```

#### Method 2:

```cpp
class Solution {
public:
int hammingWeight(uint32_t n) {
  int count = 0;
  while (n != 0) {
    n = (n & (n - 1));
    count++;
  }
  return count;
}
};
```
