notes/OJ notes/pages/Leetcode Number-of-1-Bits.md

# Leetcode Number-of-1-Bits

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

> ##### Algorithms:
> #algorithm #bit_manipulation 
> ##### Data structures:
> #DS #bitset 
> ##### Difficulty:
> #coding_problem #difficulty-easy
> ##### Additional tags:
> #leetcode 
> ##### Revisions:
> N/A

##### Related topics:
```expander
tag:#bit_manipulation
```


##### 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;
  }
};
```