二进制中1的个数

# -*- coding:utf-8 -*-
class Solution:
    def NumberOf1(self, n):
        # write code here
        if n == 0:
            return 0
        if n < 0:
            # 取绝对值
            n = abs(n)
            # 取反码，用32位的1与原码异或
            n = n ^ 2 ** 32 -1
            # 补码 = 反码 + 1
            n += 1
        
        count = 0
        while n:
            # 与1做与运算，判断最低位是否为1
            if n & 1:
                count += 1
            # 每轮都将二进制数右移一位，直到n为0
            n = n >> 1 
        return count

class Solution:
    def NumberOf1(self, n):
        # write code here
        # 十进制转化为二进制
        # 2整除十进制数字取余，逆序排列
        # 是最简单的机器数表示法。用最高位表示符号位，‘1’表示负号，‘0’表示正号。其他位存放该数的二进制的绝对值。
        # 正数的反码还是等于原码, 负数的反码就是他的原码除符号位外，按位取反。
        # 正数的补码等于他的原码, 负数的补码等于反码+1。
        F_list = []
        L_list = []
        q = n
        count = 0
        if n> 0:
            while q>0 : 
                a = q // 2 
                r = q % 2
                if r == 1:
                    count += 1
                F_list.append(r)
                q = a
            return count
        elif n == 0:
            return 0
        else :
            n = bin(n&0xffffffff) #负数的补码 s
            s = str(n)
            for i in s:
                if i == '1':
                    count +=1
            return count
           

# -*- coding:utf-8 -*-
class Solution:
    def NumberOf1(self, n):
        # write code here
        count = 0
        for i in range(0, 32):
            if (n>>i & 1):
                count += 1
        return count

python简洁版:

class Solution:
    def NumberOf1(self, n):
        res=sum([1 if n&(1<<i)>0 else 0 for i in range(31)])
        return res if n>=0 else res+1

思路来自排名第一的回答的第一个思路，用1左移i次的结果与数字n做&操作看是否大于0，另外，python的int支持大数，没有32位精度限制，所以自己手动为负数加上符号位的1

• 方法一：转换成二进制（字符串），直接数“1”的个数
• 方法二： 位运算：mask=1<<i，其中i表示向左移动几位，右边加0，并与原来结果相与。原数位为1，相与结果为1；原数位为0，相与结果为0（if那句话）。
• 方法三：骚操作：n与n-1相与，每次循环可以将n中的一个1去掉，直到所有1去掉变为0。
  

class Solution:
    def NumberOf1(self, n):
        # write code here
        '''
        # 方法一
        n = n & 0xFFFFFFFF
        bin_num = bin(n)
        count=0
        for i in bin_num:
            if i == '1':
                count+=1
        return count
        
        # 方法二
        n = n & 0xFFFFFFFF
        count = 0
        for i in range(32):
            mask = 1 << i
            if mask & n !=0:
                count+=1
        return count
        '''
        # 方法三
        n = n & 0xFFFFFFFF
        count = 0
        while n:
            n = n&(n-1)
            count += 1
        return count

判断n的二进制表示中1的个数
将n依次与flag = 1,2,3,4,5..进行与运算
必须对flag进行一定的限制，不然会一直循环下去：

• n>=0时，flag <= flag即可
• n<0时，先将n与0xFFFFFFFF作与运算，转正【真的是这样吗？】

# -*- coding:utf-8 -*-
class Solution:
    def NumberOf1(self, n):
        """

        :param n:
        :return:
        """
        flag = 1
        cnt = 0
        if  n < 0:
            n = n&0xFFFFFFFF
        while(flag and flag <= n):
            if n & flag:
                cnt += 1
            flag = flag << 1
        return cnt


s = Solution()
cnt = s.NumberOf1(-1)
print(cnt)

# -*- coding:utf-8 -*-
class Solution:
    def NumberOf1(self, n):
        # write code here
        #按位“与” ：两个位置都为1才为1
        #方法一：转化为字符串
        #正数：源码、反码、补码一致；负数：源码、反码、补码不同
        '''
        n = 0xFFFFFFFF & n #只计算32位，实际上不只是有32位（考虑当n为负数时）
        count = 0
        for i in str(bin(n)):
            if i == "1":
                count += 1
        return count
        '''
        
        #方法二：用mask与每个位置与，求每个位置是否为1
        '''
        count = 0
        n = 0xFFFFFFFF & n
        for i in range(32):
            mask = 1 << i
            if n & mask != 0:
                count += 1
        return count
        '''
        #方法三：n = n&(n-1) 装逼式写法
        #101101 & 101100 = 101100  count = 1
        #101100 & 101011 = 101000  count = 2
        #101000 & 100111 = 100000  count = 3
        #100000 & 011111 = 000000  count = 4
        count = 0
        while n:
            n = 0xffffffff & n
            n = n&(n-1)
            count += 1
        return count

# -*- coding:utf-8 -*-
# 如果一个整数不为0，那么这个整数至少有一位是1。如果我们把这个整数减1，那么原来处在整数最右边的1就会变为0，
# 原来在1后面的所有的0都会变成1(如果最右边的1后面还有0的话)。其余所有位将不会受到影响。
# 举个例子：一个二进制数1100，从右边数起第三位是处于最右边的一个1。减去1后，第三位变成0，它后面的两位0变成了1，而前面的1保持不变，
# 因此得到的结果是1011.我们发现减1的结果是把最右边的一个1开始的所有位都取反了。这个时候如果我们再把原来的整数和减去1之后的结果做与运算，
# 从原来整数最右边一个1那一位开始所有位都会变成0。如1100&1011=1000.也就是说，把一个整数减去1，再和原整数做与运算，
# 会把该整数最右边一个1变成0.那么一个整数的二进制有多少个1，就可以进行多少次这样的操作。


class Solution:
    def NumberOf1(self, n):
        # write code here
        count = 0
        if n < 0:
            n = n & 0xffffffff
        while n != 0:
            n = n & (n - 1)
            count += 1

        return count

Ｐｙｔｈｏｎ　Solution:

# -*- coding:utf-8 -*-
class Solution:
    def NumberOf1(self, n):
        # write code here
        n = 0xFFFFFFFF & n
        stri = str(bin(n).replace('0b', ''))
        count = 0
        for i in stri:
            if i =='1':
                count += 1
        return count
        
        
        
        #return bin(n).replace('0b','').count('1')

注意：这里的整数用32位存储。

python处理时，通过与上0xff...ff可以将有符号数变成无符号数。
负数的补码，是对应正数取反+1得到：例如9的二进制是1001，对应的补码就是10110 + 1 = 10111（最高位是符号位），用32位存储的结果就是 （28个1）0111

# -*- coding:utf-8 -*-
class Solution:
    def NumberOf1(self, n):
        # write code here
        BiStr = bin(n)
        if n<0:
            n = -n
            BiStr = bin((~n&((1<<32)-1))+1)
        return BiStr.replace('0b', '').count('1')

# -*- coding:utf-8 -*-
class Solution:
    def NumberOf1(self, n):
        # write code here
        if n>=0:
            return bin(n).count('1')
        return bin(int(bin(-n)[2:].zfill(32).replace('0','a').replace('1','0').replace('a','1'),2)+1).count('1')

# -*- coding:utf-8 -*-
class Solution:
    def NumberOf1(self, n):
        # write code here
        count = 0
        if n<0 :
            n = n&(0xffffffff)
        while n!=0 :
            n = n&(n-1)
            count = count + 1 
        return count