力扣136、137、260以及取模、位运算

1、python取模

所谓取模运算，就是计算两个数相除之后的余数，符号是%。如a % b就是计算a除以b的余数。用数学语言来描述，就是如果存在整数n和m，其中0 <= m < b，使得a = n * b + m，那么a % b = a - n * b = m.

在MATLAB中为mod；
取模运算的两个操作数都必须是整数，可以是负整数，但是b不可以是0.

当a和b中存在负整数时，先放python运行的结果

print(7 % 3,3 % 7)
print(-7 % 3,-3 % 7)
print(7 % -3,3 % -7)
print(-7 % -3,-3 % -7)
# 结果为
1 3
2 4
-2 -4
-1 -3

相信到这里就有所发现，对于符号相同的取模：商尽可能的望0靠近
对于符号不同的取模：商尽可能的向负无穷靠近

float('inf') 表示正无穷

-float('inf') 或 float('-inf') 表示负无穷

其中，inf 均可以写成 Inf

2、原码、反码、补码

二进制有三种不同的表示形式：原码、反码和补码，计算机内部使用补码来表示。
原码：就是其二进制表示（注意，有一位符号位）。

00 00 00 11 -> 3
10 00 00 11 -> -3

反码：正数的反码就是原码，负数的反码是符号位不变，其余位取反（对应正数按位取反）。

00 00 00 11 -> 3
11 11 11 00 -> -3

补码：正数的补码就是原码，负数的补码是反码+1。

00 00 00 11 -> 3
11 11 11 01 -> -3

符号位：最高位为符号位，0表示正数，1表示负数。在位运算中符号位也参与运算。

3、按位非操作 ~

~ 1 = 0
~ 0 = 1

~ 把num的补码中的 0 和 1 全部取反（0 变为 1，1 变为 0）有符号整数的符号位在 ~ 运算中同样会取反。

5 的原码、反码和补码一样
00 00 01 01 -> 5
~
---
全部取反结果为：
11 11 10 10 -> -6
-5的原码为：11 11 11 01
-5的反码为：11 11 10 10
-5的补码为：11 11 10 11
11 11 10 11 -> -5
~
---
-5补码全部取反：00 00 01 00
所以00 00 01 00为4的原码、反码、补码
00 00 01 00 -> 4

4、利用位运算实现快速计算

通过 <<，>> 快速计算2的倍数问题。

n << 1 -> 计算 n*2
n >> 1 -> 计算 n/2，负奇数的运算不可用
n << m -> 计算 n*(2^m)，即乘以 2 的 m 次方
n >> m -> 计算 n/(2^m)，即除以 2 的 m 次方
1 << n -> 2^n

通过 ^ 快速交换两个整数。

a ^= b
b ^= a
a ^= b

通过 a & (-a) 快速获取a的最后为 1 位置的整数。

这里利用了计算机内部是使用的补码表示，所以负数的补码最后加了1，所有正数中后面为0的在负数反码中变为1，后面补码再加1，就等于所有1变为了0，而最后正数数字为1的位置变为了1.

如40和-40
00 10 10 00 -> 40的原码
10 10 10 00->-40的原码
正数的原码、反码、补码一样； 负数的反码为符号位（首位1）不变，其余取反，补码为反码加1
00 10 10 00-> 40的补码
11 01 01 11->-40的反码
11 01 1000->-40的补码（反码加1）
所以40&（-40）就可以计算出最后出现1的位置。

这也是笔试中经常遇到的一道题。

00 00 01 01 -> 5
&
11 11 10 11 -> -5
---
00 00 00 01 -> 1

00 00 11 10 -> 14
&
11 11 00 10 -> -14
---
00 00 00 10 -> 2

5、利用位运算实现整数集合

一个数的二进制表示可以看作是一个集合（0 表示不在集合中，1 表示在集合中）。

比如集合 {1, 3, 4, 8}，可以表示成 01 00 01 10 10 而对应的位运算也就可以看作是对集合进行的操作。

元素与集合的操作：

a | (1<<i)  -> 把 i 插入到集合中
a & ~(1<<i) -> 把 i 从集合中删除
a & (1<<i)  -> 判断 i 是否属于该集合（零不属于，非零属于）

集合之间的操作：

a 补   -> ~a
a 交 b -> a & b
a 并 b -> a | b
a 差 b -> a & (~b)

注意：整数在内存中是以补码的形式存在的，输出自然也是按照补码输出。

例子】 Python 的bin() 输出。

print(bin(3))  # 0b11
print(bin(-3))  # -0b11

print(bin(-3 & 0xffffffff))  
# 0b11111111111111111111111111111101

print(bin(0xfffffffd))       
# 0b11111111111111111111111111111101

print(0xfffffffd)  # 4294967293

是不是很颠覆认知，我们从结果可以看出：

• Python中bin一个负数（十进制表示），输出的是它的原码的二进制表示加上个负号，巨坑。
• Python中的整型是补码形式存储的。
• Python中整型是不限制长度的不会超范围溢出。

所以为了获得负数（十进制表示）的补码，需要手动将其和十六进制数0xffffffff（1个f代表了二进制的4位）进行按位与操作，再交给bin()进行输出，得到的才是负数的补码表示。

异或运算有以下三个性质。

任何数和 0 做异或运算，结果仍然是原来的数，即 a⊕0=a。
任何数和其自身做异或运算，结果是 0，即 a⊕a=0。
异或运算满足交换律和结合律，即 a⊕b⊕a=b⊕a⊕a=b⊕(a⊕a)=b⊕0=b

6、leetcode 习题 136、137、260. 只出现一次的数字

1、给定一个非空整数数组，除了某个元素只出现一次以外，其余每个元素均出现两次。找出那个只出现了一次的元素。

输入: [2,2,1]
输出: 1

class Solution:
    def singleNumber(self, nums: List[int]) -> int:
        # return sum(set(nums))*2 - sum(nums)
        return reduce(lambda x,y:x^y ,nums)

2、给定一个非空整数数组，除了某个元素只出现一次以外，其余每个元素均出现了三次。找出那个只出现了一次的元素。

class Solution:
    def singleNumber(self, nums: List[int]) -> int:
    	# 三种方法哈希表省略Counter（）计数存储即可
        # return (sum(set(nums))*3 - sum(nums))//2
        seen_once=0
        seen_twice=0
        for num in nums:
        	#出现3次的，经过这两次变换为0了，而出现一次的异或其他的，根据交换律，把这个只出现一次的放首位，后面还是0
            seen_once = ~seen_twice&(seen_once^num)
            seen_twice = ~seen_once&(seen_twice^num)
        return seen_once
        # k为5次重复
        # seen_once=0;seen_twice=0;seen_third=0;seen_forth=0;
        # for num in nums:
            # seen_once = ~seen_twice&~seen_third&~seen_forth&(seen_once^num)
            # seen_twice = ~seen_once&~seen_third&~seen_forth&(seen_twice^num)
            # seen_third = ~seen_once&~seen_twice&~seen_forth&(seen_third^num)
            # seen_forth = ~seen_once&~seen_third&~seen_twice&(seen_forth^num)
        # return seen_once

3、给定一个整数数组 nums，其中恰好有两个元素只出现一次，其余所有元素均出现两次。 找出只出现一次的那两个元素。

class Solution:
    def singleNumber(self, nums: List[int]) -> List[int]:
    	# 哈希表
        # hashmap = Counter(nums)
        # return[num for num in hashmap if hashmap[num]==1]
        bitmask = 0
        # 取出那俩数的异或结果
        for num in nums:
            bitmask ^= num
        # 对异或的结果取出最后一个为1的位置，那么必定为其中一个数的1
        diff = bitmask&(-bitmask)
        # 看看哪一个数与这个1有交集，即为其中一个
        x = 0
        for num in nums:
            if num&diff:
                x ^= num
        # 另一个数就是两个数异或结果与这个数异或，符合异或的交换律
        return[x, bitmask^x]