Description
Given a positive integer n, write a function that returns the number of set bits in its binary representation (also known as the Hamming weight).
Example 1:
Input: n = 11
Output: 3
Explanation:
The input binary string 1011 has a total of three set bits.
Example 2:
Input: n = 128
Output: 1
Explanation:
The input binary string 10000000 has a total of one set bit.
Example 3:
Input: n = 2147483645
Output: 30
Explanation:
The input binary string 1111111111111111111111111111101 has a total of thirty set bits.
Constraints:
Follow up: If this function is called many times, how would you optimize it?
Solutions
Solution 1
PythonJavaC++GoTypeScriptRustJavaScriptCKotlin
class Solution:
def hammingWeight(self, n: int) -> int:
ans = 0
while n:
n &= n - 1
ans += 1
return ans(code-box)
public class Solution {
// you need to treat n as an unsigned value
public int hammingWeight(int n) {
int ans = 0;
while (n != 0) {
n &= n - 1;
++ans;
}
return ans;
}
}(code-box)
class Solution {
public:
int hammingWeight(uint32_t n) {
int ans = 0;
while (n) {
n &= n - 1;
++ans;
}
return ans;
}
};(code-box)
func hammingWeight(num uint32) int {
ans := 0
for num != 0 {
num &= num - 1
ans++
}
return ans
}(code-box)
function hammingWeight(n: number): number {
let ans: number = 0;
while (n !== 0) {
ans++;
n &= n - 1;
}
return ans;
}(code-box)
impl Solution {
pub fn hammingWeight(n: u32) -> i32 {
n.count_ones() as i32
}
}(code-box)
/**
* @param {number} n - a positive integer
* @return {number}
*/
var hammingWeight = function (n) {
let ans = 0;
while (n) {
n &= n - 1;
++ans;
}
return ans;
};(code-box)
int hammingWeight(uint32_t n) {
int ans = 0;
while (n) {
n &= n - 1;
ans++;
}
return ans;
}(code-box)
class Solution {
fun hammingWeight(n: Int): Int {
var count = 0
var num = n
while (num != 0) {
num = num and (num - 1)
count++
}
return count
}
}(code-box)
Solution 2
PythonJavaC++GoTypeScriptRustJavaScriptKotlin
class Solution:
def hammingWeight(self, n: int) -> int:
ans = 0
while n:
n -= n & -n
ans += 1
return ans(code-box)
public class Solution {
// you need to treat n as an unsigned value
public int hammingWeight(int n) {
int ans = 0;
while (n != 0) {
n -= (n & -n);
++ans;
}
return ans;
}
}(code-box)
class Solution {
public:
int hammingWeight(uint32_t n) {
int ans = 0;
while (n) {
n -= (n & -n);
++ans;
}
return ans;
}
};(code-box)
func hammingWeight(num uint32) int {
ans := 0
for num != 0 {
num -= (num & -num)
ans++
}
return ans
}(code-box)
function hammingWeight(n: number): number {
let count = 0;
while (n) {
n -= n & -n;
count++;
}
return count;
}(code-box)
impl Solution {
pub fn hammingWeight(mut n: u32) -> i32 {
let mut res = 0;
while n != 0 {
n &= n - 1;
res += 1;
}
res
}
}(code-box)
/**
* @param {number} n
* @return {number}
*/
var hammingWeight = function (n) {
let count = 0;
while (n) {
n -= n & -n;
count++;
}
return count;
};(code-box)
class Solution {
fun hammingWeight(n: Int): Int {
var count = 0
var num = n
while (num != 0) {
num -= num and (-num)
count++
}
return count
}
}(code-box)
