位运算

位运算

按位运算符是把数字看作二进制来进行计算的。Python中的按位运算法则如下：

变量 a 为 60，b 为 13二进制格式如下：
a = 0011 1100
b = 0000 1101

运算符

& 位与运算符：如果两个相应位都为1,则该位为1,否则为0 。(a & b) 输出结果 12 ，二进制： 0000 1100

| 位或运算符：只要对应的两个二进位有一个为1时，结果位就为1。 (a | b) 输出结果 61 ，二进制： 0011 1101

^ 位异或运算符：当两对应的二进位相异时，结果为1 (a ^ b) 输出结果 49 ，二进制： 0011 0001

~ 位取反运算符：对数据的每个二进制位取反,即把1变为0,把0变为1。~x 类似于 -x-1， (~a ) 输出结果 -61 ，二进制： 1100 0011

<< 左移动运算符：指定数的各二进位全部左移指定位，由"<<"右边的数指定移动的位数，高位丢弃，低位补0。 a << 2 输出结果 240 ，二进制： 1111 0000

“>>” 右移动运算符：把”>>“左边的运算数的各二进位全部右移若干位，”>>"右边的数指定移动的位数 a >> 2 输出结果 15 ，二进制： 0000 1111

汉明距离相关

LeetCode/191 位1的个数（汉明重量）

编写一个函数，输入是一个无符号整数，返回其二进制表达式中数字位数为 ‘1’ 的个数（也被称为汉明重量）。

示例 1：
输入：00000000000000000000000000001011
输出：3
解释：输入的二进制串 00000000000000000000000000001011 中，共有三位为 ‘1’。
示例 2：
输入：00000000000000000000000010000000
输出：1
解释：输入的二进制串 00000000000000000000000010000000 中，共有一位为 ‘1’。
示例 3：
输入：11111111111111111111111111111101
输出：31
解释：输入的二进制串 11111111111111111111111111111101 中，共有 31 位为 ‘1’。

提示：
请注意，在某些语言（如 Java）中，没有无符号整数类型。在这种情况下，输入和输出都将被指定为有符号整数类型，并且不应影响您的实现，因为无论整数是有符号的还是无符号的，其内部的二进制表示形式都是相同的。
在 Java 中，编译器使用二进制补码记法来表示有符号整数。因此，在上面的 示例 3 中，输入表示有符号整数 -3。
进阶:
如果多次调用这个函数，你将如何优化你的算法？

思路

时间复杂度为1的个数
0&0=0 0&1=0 1&0=0 1&1=1

class Solution:
    def hammingWeight(self, n: int) -> int:
        count = 0
        while n !=0:
            n = n & (n-1)
            count +=1
        return count

LeetCode/461 汉明距离

两个整数之间的汉明距离指的是这两个数字对应二进制位不同的位置的数目。
给出两个整数 x 和 y，计算它们之间的汉明距离。
注意：
0 ≤ x, y < 231.
示例:
输入: x = 1, y = 4
输出: 2
解释:
1 (0 0 0 1)
4 (0 1 0 0)
…↑… ↑
上面的箭头指出了对应二进制位不同的位置。

思路

两个数一起异或，获得异或值，相异为1，那么这个异或值上二进制位等于1的地方都是原来两个数二进制位上不相等的那些位置，统计1的个数，就能知道有哪些位数不相等了。
0^0=0 0^1=1 1^0=1 1^1=0

class Solution:
    def hammingDistance(self, x: int, y: int) -> int:
        a = x ^ y
        count = 0
        while a != 0:
            a = a & (a - 1)
            count += 1
        return count

LeetCode/136 只出现一次的数字

给定一个非空整数数组，除了某个元素只出现一次以外，其余每个元素均出现两次。找出那个只出现了一次的元素。
说明：
你的算法应该具有线性时间复杂度。 你可以不使用额外空间来实现吗？
示例 1:
输入: [2,2,1]
输出: 1
示例 2:
输入: [4,1,2,1,2]
输出: 4

思路

异或的规律
任何数和本身异或则为0
任何数和 0 异或是本身
异或运算满足交换律和结合律。

class Solution:
    def singleNumber(self, nums: List[int]) -> int:
        res = 0
        for i in nums:
            res = res ^ i
        return res

LeetCode/477 汉明距离总和

两个整数的 汉明距离 指的是这两个数字的二进制数对应位不同的数量。
计算一个数组中，任意两个数之间汉明距离的总和。
示例:
输入: 4, 14, 2
输出: 6
解释: 在二进制表示中，4表示为0100，14表示为1110，2表示为0010。（这样表示是为了体现后四位之间关系）
所以答案为：
HammingDistance(4, 14) + HammingDistance(4, 2) + HammingDistance(14, 2) = 2 + 2 + 2 = 6.

就是求这些数字的32位下的2进制，每位上有多少个1和0，一个整数4个字节，1个字节8位。

思路

看到题目首先想到的是遍历两次，两两计算汉明距离，但是这样有三层循环，耗时太长，不建议使用。代码如下“横向计算”。
转换思路纵向计算。首先横向计算汉明距离的算法是，从头遍历，两两计算做加法运算，然后计算汉明距离，从第一位到最后一位，还是加法运算
纵向算法，遍历列表加法，求这些数字的32位下的2进制，然后计算每一位一和零的数量，做乘法

#横向计算
def totalHammingDistance(nums: List[int]) -> int:
    sum = 0
    for i in range(len(nums)-1):
        for j in nums[i+1:]:
            count = 0
            n = nums[i]^j
            while n != 0:
                n = n & (n - 1)
                count += 1
            sum += count
    return sum

#纵向计算
class Solution:
    def totalHammingDistance(self, nums: List[int]) -> int:
        sum = 0
        for i in range(32):
            count_0 = 0
            count_1 = 0
            for j in range(len(nums)):
                if (nums[j]>>i) & 1 is not 0:
                    count_1 += 1
                else: 
                    count_0 += 1
            sum += count_0 * count_1
        return sum