0626

Author: princewen

sort_by_leetcode/bit manipulation/__init__.py

@@ -0,0 +1,24 @@
+"""
+
+Given an array of integers, every element appears twice except for one. Find that single one.
+
+Note:
+Your algorithm should have a linear runtime complexity. Could you implement it without using extra memory?
+
+"""
+
+"""
+利用异或，两个相同的数的异或为0
+"""
+
+
+class Solution(object):
+    def singleNumber(self, nums):
+        """
+        :type nums: List[int]
+        :rtype: int
+        """
+        res = 0
+        for i in nums:
+            res = res ^ i
+        return res

sort_by_leetcode/bit manipulation/easy/136. Single Number.py

@@ -0,0 +1,44 @@
+"""
+
+Given an array of size n, find the majority element. The majority element is the element that appears more than ⌊ n/2 ⌋ times.
+
+You may assume that the array is non-empty and the majority element always exist in the array.
+
+Credits:
+Special thanks to @ts for adding this problem and creating all test cases.
+
+Subscribe to see which companies asked this question.
+
+"""
+
+"""思路，因为出现次数最多的元素大于元素个数的一半，所以使用count和cand，设目标值为a
+"""
+
+
+class Solution(object):
+    def majorityElement(self, nums):
+        """
+        :type nums: List[int]
+        :rtype: int
+        """
+        cand = nums[0]
+        count = 1
+        for i in nums[1:]:
+            if count == 0:
+                cand, count = i, 1
+            else:
+                if i == cand:
+                    count = count + 1
+                else:
+                    count = count - 1
+        return cand
+
+"""一行的思路"""
+class Solution(object):
+    def majorityElement(self, nums):
+        """
+        :type nums: List[int]
+        :rtype: int
+        """
+        return sorted(nums)[len(nums)/2]
+

sort_by_leetcode/bit manipulation/easy/169. Majority Element.py

@@ -0,0 +1,44 @@
+"""
+
+Reverse bits of a given 32 bits unsigned integer.
+
+For example, given input 43261596 (represented in binary as 00000010100101000001111010011100), return 964176192 (represented in binary as 00111001011110000010100101000000).
+
+Follow up:
+If this function is called many times, how would you optimize it?
+
+Related problem: Reverse Integer
+
+Credits:
+Special thanks to @ts for adding this problem and creating all test cases.
+
+"""
+
+"""
+
+利用十进制转二进制的方法，考虑十进制13
+13 ／ 2 = 6 ----1
+6 ／2 = 3 ----0
+3 ／2 = 1 ----1
+1 ／2 = 0 ----1
+二进制是1101，前面补全0，而反转的二进制是1011，后面补全0
+所以我们只需要按照除的顺序依次进入数组，后面不组32位用0补齐即可。
+
+"""
+
+
+class Solution:
+    # @param n, an integer
+    # @return an integer
+    def reverseBits(self, n):
+        stack = []
+        while n:
+            stack.append(n % 2)
+            n = n / 2
+        while len(stack) < 32:
+            stack.append(0)
+        ret = 0
+        for num in stack:
+            ret = ret * 2 + num
+        return ret
+

sort_by_leetcode/bit manipulation/easy/190. Reverse Bits.py

@@ -0,0 +1,32 @@
+"""
+
+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.
+
+Credits:
+Special thanks to @ts for adding this problem and creating all test cases.
+
+
+
+"""
+"""
+这里用到的二进制知识是：一个数与比自己小1的数按位与运算，会将自己所对应的二进制数的最后一个1变为0。
+考虑如下的例子： 13的二进制数为1101，12的二进制数为1100
+则 （1101）& （1100） --》（1100）
+1100代表的数是10，9的二进制数为1001，则：
+1100 & 1001 --》1000
+依次类推
+"""
+
+class Solution(object):
+    def hammingWeight(self, n):
+        """
+        :type n: int
+        :rtype: int
+        """
+        count = 0
+        while n:
+            n = n & (n-1)
+            count = count + 1
+        return count

sort_by_leetcode/bit manipulation/easy/191. Number of 1 Bits.py

@@ -0,0 +1,17 @@
+"""
+
+Given an integer, write a function to determine if it is a power of two.
+
+Credits:
+Special thanks to @jianchao.li.fighter for adding this problem and creating all test cases.
+
+"""
+"""跟191题一样的思路，2的倍数的对应二进制数只有1位是1"""
+
+class Solution(object):
+    def isPowerOfTwo(self, n):
+        """
+        :type n: int
+        :rtype: bool
+        """
+        return n>0 and not (n & n-1)

sort_by_leetcode/bit manipulation/easy/231. Power of Two.py

@@ -0,0 +1,36 @@
+"""
+Given an array containing n distinct numbers taken from 0, 1, 2, ..., n, find the one that is missing from the array.
+
+For example,
+Given nums = [0, 1, 3] return 2.
+
+Note:
+Your algorithm should run in linear runtime complexity. Could you implement it using only constant extra space complexity?
+
+"""
+"""利用求和公式求解"""
+class Solution(object):
+    def missingNumber(self, nums):
+        """
+        :type nums: List[int]
+        :rtype: int
+        """
+        n = len(nums)
+        return n * (n+1) / 2 - sum(nums)
+
+
+"""二进制的思路
+仍然利用两个相同的数的异或为0
+"""
+
+class Solution(object):
+    def missingNumber(self, nums):
+        """
+        :type nums: List[int]
+        :rtype: int
+        """
+        result = len(nums)
+        for index,value in enumerate(nums):
+            result ^= index
+            result ^= value
+        return result

sort_by_leetcode/bit manipulation/easy/268. Missing Number.py

@@ -0,0 +1,22 @@
+"""
+
+Given an integer (signed 32 bits), write a function to check whether it is a power of 4.
+
+Example:
+Given num = 16, return true. Given num = 5, return false.
+
+Follow up: Could you solve it without loops/recursion?
+
+Credits:
+Special thanks to @yukuairoy for adding this problem and creating all test cases.
+
+"""
+"""4的倍数首先要满足2的倍数的条件，然后他减1要是3的倍数"""
+
+class Solution(object):
+    def isPowerOfFour(self, num):
+        """
+        :type num: int
+        :rtype: bool
+        """
+        return num>0 and (num & num-1)==0 and (num-1)%3==0

sort_by_leetcode/bit manipulation/easy/342. Power of Four.py

@@ -0,0 +1,70 @@
+"""
+
+Calculate the sum of two integers a and b, but you are not allowed to use the operator + and -.
+
+Example:
+Given a = 1 and b = 2, return 3.
+
+Credits:
+Special thanks to @fujiaozhu for adding this problem and creating all test cases.
+
+"""
+
+"""
+思路：强大的位运算，不能用+ and -，考虑位运算，按位加
+如果两位都是0，则取0，如果两位中有一位是1，则是1，如果两位都是1，则是10，那么我们可以用异或来表示这种关系，但是两个都是1的情况下，还需要在前一位补一个1，所以再用按位与并移1位来表示需要补上的一个1
+例如考虑四位二进制位的3（0011）和 5（0101）相加：
+第一轮
+a = 0011 ^ 0101 = 0110
+b = 0011 & 0101 = 0001 << 1 = 0010
+第二轮:
+a = 0110 ^ 0010 = 0100
+b = 0110 & 0010 = 0010 << 1 = 0100
+第三轮：
+a = 0100 ^ 0100 = 0000
+b = 0100 & 0100 = 0100 << 1 = 1000
+最后一轮：
+a = 0000 ^ 1000 = 1000
+b = 0000 & 1000 = 0000迭代终止，返回a
+
+"""
+"""但是，这个对python不适用！，当输入负数时，会超时"""
+class Solution(object):
+    def getSum(self, a, b):
+        """
+        :type a: int
+        :type b: int
+        :rtype: int
+        """
+        if a==0:
+            return b
+        if b==0:
+            return a
+        while b:
+            carry = a & b
+            a = a ^ b
+            b = carry << 1
+        return a
+
+
+"""python solution"""
+class Solution(object):
+    def getSum(self, a, b):
+        """
+        :type a: int
+        :type b: int
+        :rtype: int
+        """
+        # 32 bits integer max
+        MAX = 0x7FFFFFFF
+        # 32 bits interger min
+        MIN = 0x80000000
+        # mask to get last 32 bits
+        mask = 0xFFFFFFFF
+        while b != 0:
+            # ^ get different bits and & gets double 1s, << moves carry
+            a, b = (a ^ b) & mask, ((a & b) << 1) & mask
+        # if a is negative, get a's 32 bits complement positive first
+        # then get 32-bit positive's Python complement negative
+        """有疑问,python把有符号数当作无符号数处理"""
+        return a if a <= MAX else ~(a ^ mask)

sort_by_leetcode/bit manipulation/easy/371_Sum of Two Integers.py

@@ -0,0 +1,33 @@
+"""
+
+Given two strings s and t which consist of only lowercase letters.
+
+String t is generated by random shuffling string s and then add one more letter at a random position.
+
+Find the letter that was added in t.
+
+Example:
+
+Input:
+s = "abcd"
+t = "abcde"
+
+Output:
+e
+
+Explanation:
+'e' is the letter that was added.
+
+"""
+"""可以用hash table，当然更简单的还是利用两个相同的数异或值为0"""
+class Solution(object):
+    def findTheDifference(self, s, t):
+        """
+        :type s: str
+        :type t: str
+        :rtype: str
+        """
+        res = 0
+        for i in s+t:
+            res ^= ord(i)
+        return chr(res)