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
    
    

All Problems

All Solutions