# Question

Formatted question description: https://leetcode.ca/all/191.html

 191	Number of 1 Bits

Write a function that takes an unsigned integer and returns the number of ’1' bits it has
(also known as the Hamming weight).

For example, the 32-bit integer ’11' has binary representation 00000000000000000000000000001011,
so the function should return 3.

Credits:
Special thanks to @ts for adding this problem and creating all test cases.

@tag-bit


# Algorithm

Sum up &1 result.

# Code

Java

• 
public class Number_of_1_Bits {

public static void main(String[] args) {
Number_of_1_Bits out = new Number_of_1_Bits();

Solution s = out.new Solution();

System.out.println(s.hammingWeight(11));
}

public class Solution {
// you need to treat n as an unsigned value
public int hammingWeight(int n) {

int count = 0;

while (n > 0) {
count += n & 1;

n >>= 1;
}
return count;
}
}

public class Solution_cheat {
// you need to treat n as an unsigned value
public int hammingWeight(int n) {
return Integer.bitCount(n); // Returns the number of one-bits in the two's complement binary representation
}
}

public class Solution_toBinaryString {
// you need to treat n as an unsigned value
public int hammingWeight(int n) {

String binaryString = Integer.toBinaryString(n);

int count = 0;
for (int i = 0; i < binaryString.length(); i++) {
if (binaryString.charAt(i) == '1') {
count++;
}
}

return count;
}
}
}

• // OJ: https://leetcode.com/problems/number-of-1-bits/
// Time: O(1)
// Space: O(1)
class Solution {
public:
int hammingWeight(uint32_t n) {
int ans = 0;
for (; n; n -= (n & -n)) ++ans;
return ans;
}
};

• class Solution(object):
def hammingWeight(self, n):
"""
:type n: int
:rtype: int
"""
ans = 0
while n > 0:
n -= (n & -n)
ans += 1
return ans