zoukankan      html  css  js  c++  java
  • leetcode 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.

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

    其他解法:

    Another several method of O(1) time.

    Add 1 by Tree:

    // This is a naive implementation, shown for comparison, and to help in understanding the better functions. 
    // It uses 24 arithmetic operations (shift, add, and).
    int hammingWeight(uint32_t n)
    {
        n = (n & 0x55555555) + (n >>  1 & 0x55555555); // put count of each  2 bits into those  2 bits 
        n = (n & 0x33333333) + (n >>  2 & 0x33333333); // put count of each  4 bits into those  4 bits 
        n = (n & 0x0F0F0F0F) + (n >>  4 & 0x0F0F0F0F); // put count of each  8 bits into those  8 bits 
        n = (n & 0x00FF00FF) + (n >>  8 & 0x00FF00FF); // put count of each 16 bits into those 16 bits 
        n = (n & 0x0000FFFF) + (n >> 16 & 0x0000FFFF); // put count of each 32 bits into those 32 bits 
        return n;
    }
    
    // This uses fewer arithmetic operations than any other known implementation on machines with slow multiplication.
    // It uses 17 arithmetic operations.
    int hammingWeight(uint32_t n)
    {
        n -= (n >> 1) & 0x55555555; //put count of each 2 bits into those 2 bits
        n = (n & 0x33333333) + (n >> 2 & 0x33333333); //put count of each 4 bits into those 4 bits
        n = (n + (n >> 4)) & 0x0F0F0F0F; //put count of each 8 bits into those 8 bits
        n += n >> 8; // put count of each 16 bits into those 8 bits
        n += n >> 16; // put count of each 32 bits into those 8 bits
        return n & 0xFF;
    }
    
    // This uses fewer arithmetic operations than any other known implementation on machines with fast multiplication.
    // It uses 12 arithmetic operations, one of which is a multiply.
    int hammingWeight(uint32_t n)
    {
        n -= (n >> 1) & 0x55555555; // put count of each 2 bits into those 2 bits
        n = (n & 0x33333333) + (n >> 2 & 0x33333333); // put count of each 4 bits into those 4 bits
        n = (n + (n >> 4)) & 0x0F0F0F0F; // put count of each 8 bits into those 8 bits 
        return n * 0x01010101 >> 24; // returns left 8 bits of x + (x<<8) + (x<<16) + (x<<24)
    }
    

    ——From Wikipedia.

  • 相关阅读:
    巴洛克式和哥特式的区别
    推荐阅读书籍,是时候再行动起来了。
    AtCoder ABC 159F Knapsack for All Segments
    AtCoder ABC 159E Dividing Chocolate
    AtCoder ABC 158F Removing Robots
    AtCoder ABC 158E Divisible Substring
    AtCoder ABC 157F Yakiniku Optimization Problem
    AtCoder ABC 157E Simple String Queries
    AtCoder ABC 157D Friend Suggestions
    AtCoder ABC 156F Modularness
  • 原文地址:https://www.cnblogs.com/bonelee/p/8870805.html
Copyright © 2011-2022 走看看