go -> python

dashidhy · dashidhy · commit 699456fdb2ad · 2020-06-29T14:46:47.000-07:00
diff --git a/data_structure/binary_op.md b/data_structure/binary_op.md
@@ -32,160 +32,163 @@ diff=(n&(n-1))^n
 
 > 给定一个**非空**整数数组，除了某个元素只出现一次以外，其余每个元素均出现两次。找出那个只出现了一次的元素。
 
-```go
-func singleNumber(nums []int) int {
-    // 10 ^10 == 00
-    // 两个数异或就变成0
-    result:=0
-    for i:=0;i<len(nums);i++{
-        result=result^nums[i]
-    }
-    return result
-}
+```Python
+class Solution:
+    def singleNumber(self, nums: List[int]) -> int:
+        
+        out = 0
+        for num in nums:
+            out ^= num
+        
+        return out
 ```
 
 [single-number-ii](https://leetcode-cn.com/problems/single-number-ii/)
 
 > 给定一个**非空**整数数组，除了某个元素只出现一次以外，其余每个元素均出现了三次。找出那个只出现了一次的元素。
 
-```go
-func singleNumber(nums []int) int {
-	// 统计每位1的个数
-	var result int
-	for i := 0; i < 64; i++ {
-		sum := 0
-		for j := 0; j < len(nums); j++ {
-			// 统计1的个数
-			sum += (nums[j] >> i) & 1
-		}
-		// 还原位00^10=10 或者用| 也可以
-		result ^= (sum % 3) << i
-	}
-	return result
-}
+```Python
+class Solution:
+    def singleNumber(self, nums: List[int]) -> int:
+        seen_once = seen_twice = 0
+        
+        for num in nums:
+            seen_once = ~seen_twice & (seen_once ^ num)
+            seen_twice = ~seen_once & (seen_twice ^ num)
+
+        return seen_once
 ```
 
 [single-number-iii](https://leetcode-cn.com/problems/single-number-iii/)
 
 > 给定一个整数数组  `nums`，其中恰好有两个元素只出现一次，其余所有元素均出现两次。 找出只出现一次的那两个元素。
 
-```go
-func singleNumber(nums []int) []int {
-    // a=a^b
-    // b=a^b
-    // a=a^b
-    // 关键点怎么把a^b分成两部分,方案：可以通过diff最后一个1区分
-
-    diff:=0
-    for i:=0;i<len(nums);i++{
-        diff^=nums[i]
-    }
-    result:=[]int{diff,diff}
-    // 去掉末尾的1后异或diff就得到最后一个1的位置
-    diff=(diff&(diff-1))^diff
-    for i:=0;i<len(nums);i++{
-        if diff&nums[i]==0{
-            result[0]^=nums[i]
-        }else{
-            result[1]^=nums[i]
-        }
-    }
-    return result
-}
+```Python
+class Solution:
+    def singleNumber(self, nums: int) -> List[int]:
+        # difference between two numbers (x and y) which were seen only once
+        bitmask = 0
+        for num in nums:
+            bitmask ^= num
+        
+        # rightmost 1-bit diff between x and y
+        diff = bitmask & (-bitmask)
+        
+        x = 0
+        for num in nums:
+            # bitmask which will contain only x
+            if num & diff:
+                x ^= num
+        
+        return [x, bitmask^x]
 ```
 
 [number-of-1-bits](https://leetcode-cn.com/problems/number-of-1-bits/)
 
 > 编写一个函数，输入是一个无符号整数，返回其二进制表达式中数字位数为 ‘1’  的个数（也被称为[汉明重量](https://baike.baidu.com/item/%E6%B1%89%E6%98%8E%E9%87%8D%E9%87%8F)）。
 
-```go
-func hammingWeight(num uint32) int {
-    res:=0
-    for num!=0{
-        num=num&(num-1)
-        res++
-    }
-    return res
-}
+```Python
+class Solution:
+    def hammingWeight(self, n: int) -> int:
+        num_ones = 0
+        while n > 0:
+            num_ones += 1
+            n &= n - 1
+        return num_ones
 ```
 
 [counting-bits](https://leetcode-cn.com/problems/counting-bits/)
 
 > 给定一个非负整数  **num**。对于  0 ≤ i ≤ num  范围中的每个数字  i ，计算其二进制数中的 1 的数目并将它们作为数组返回。
 
-```go
-func countBits(num int) []int {
-    res:=make([]int,num+1)
-
-    for i:=0;i<=num;i++{
-        res[i]=count1(i)
-    }
-    return res
-}
-func count1(n int)(res int){
-    for n!=0{
-        n=n&(n-1)
-        res++
-    }
-    return
-}
+思路：利用上一题的解法容易想到 O(nk) 的解法，k 为位数。但是实际上可以利用动态规划将复杂度降到 O(n)，想法其实也很简单，即当前数的 1 个数等于比它少一个 1 的数的结果加 1。下面给出三种 DP 解法
+
+```Python
+# x <- x // 2
+class Solution:
+    def countBits(self, num: int) -> List[int]:
+        
+        num_ones = [0] * (num + 1)
+        
+        for i in range(1, num + 1):
+            num_ones[i] = num_ones[i >> 1] + (i & 1) # 注意位运算的优先级
+        
+        return num_ones
+```
+
+```Python
+# x <- x minus right most 1
+class Solution:
+    def countBits(self, num: int) -> List[int]:
+        
+        num_ones = [0] * (num + 1)
+        
+        for i in range(1, num + 1):
+            num_ones[i] = num_ones[i & (i - 1)] + 1
+        
+        return num_ones
 ```
 
-另外一种动态规划解法
-
-```go
-func countBits(num int) []int {
-    res:=make([]int,num+1)
-    for i:=1;i<=num;i++{
-        // 上一个缺1的元素+1即可
-        res[i]=res[i&(i-1)]+1
-    }
-    return res
-}
+```Python
+# x <- x minus left most 1
+class Solution:
+    def countBits(self, num: int) -> List[int]:
+        
+        num_ones = [0] * (num + 1)
+        
+        left_most = 1
+        
+        while left_most <= num:
+            for i in range(left_most):
+                if i + left_most > num:
+                    break
+                num_ones[i + left_most] = num_ones[i] + 1
+            left_most <<= 1
+        
+        return num_ones
 ```
 
 [reverse-bits](https://leetcode-cn.com/problems/reverse-bits/)
 
 > 颠倒给定的 32 位无符号整数的二进制位。
 
-思路：依次颠倒即可
-
-```go
-func reverseBits(num uint32) uint32 {
-    var res uint32
-    var pow int=31
-    for num!=0{
-        // 把最后一位取出来，左移之后累加到结果中
-        res+=(num&1)<<pow
-        num>>=1
-        pow--
-    }
-    return res
-}
+思路：简单想法依次颠倒即可。更高级的想法是考虑到处理超长比特串时可能出现重复的pattern，此时如果使用 cache 记录出现过的 pattern 并在重复出现时直接调用结果可以节约时间复杂度，具体可以参考 leetcode 给出的解法。
+
+```Python
+import functools
+
+class Solution:
+    def reverseBits(self, n):
+        ret, power = 0, 24
+        while n:
+            ret += self.reverseByte(n & 0xff) << power
+            n = n >> 8
+            power -= 8
+        return ret
+
+    # memoization with decorator
+    @functools.lru_cache(maxsize=256)
+    def reverseByte(self, byte):
+        return (byte * 0x0202020202 & 0x010884422010) % 1023
 ```
 
 [bitwise-and-of-numbers-range](https://leetcode-cn.com/problems/bitwise-and-of-numbers-range/)
 
 > 给定范围 [m, n]，其中 0 <= m <= n <= 2147483647，返回此范围内所有数字的按位与（包含 m, n 两端点）。
 
-```go
-func rangeBitwiseAnd(m int, n int) int {
-    // m 5 1 0 1
-    //   6 1 1 0
-    // n 7 1 1 1
-    // 把可能包含0的全部右移变成
-    // m 5 1 0 0
-    //   6 1 0 0
-    // n 7 1 0 0
-    // 所以最后结果就是m<<count
-    var count int
-    for m!=n{
-        m>>=1
-        n>>=1
-        count++
-    }
-    return m<<count
-}
+思路：直接从 m 到 n 遍历一遍显然不是最优。一个性质，如果 m 不等于 n，则结果第一位一定是 0 （中间必定包含一个偶数）。利用这个性质，类似的将 m 和 n 右移后我们也可以判断第三位、第四位等等，免去了遍历的时间复杂度。
+
+```Python
+class Solution:
+    def rangeBitwiseAnd(self, m: int, n: int) -> int:
+        
+        shift = 0
+        while m < n:
+            shift += 1
+            m >>= 1
+            n >>= 1
+        
+        return m << shift
 ```
 
 ## 练习
