add solutions

Author: Chris Wu

problems/find-first-and-last-position-of-element-in-sorted-array.py

@@ -0,0 +1,35 @@
+"""
+First, we search the target by switch pointer `p`.
+    * Starting at middle. `p = (l+r)/2`.
+    * If the `nums[p]>target`, we do the same search on the left-half of nums.
+    * If the `nums[p]<target`, we do the same search on the right-half of nums.
+    * Until we find the target.
+If the target is not in the `nums` the pointer `p` will stop moving. `return [-1, -1]`.
+
+Second, we move pointers, `l`, `r` to find the right-most and left-most targets.
+
+The time complexity is O(LogN), becuase we use the concept of binary search to find the `target`.
+"""
+class Solution(object):
+    def searchRange(self, nums, target):
+        if nums is None or len(nums)==0:
+            return [-1, -1]
+
+        l = 0
+        r = len(nums)
+        p = (l+r)/2
+
+        while nums[p]!=target:
+            if nums[p]>target: r = p
+            else: l = p
+
+            p_next = (l+r)/2
+            if p==p_next: return [-1, -1]
+            p = p_next
+
+        l = r = p
+        while r+1<len(nums) and nums[r+1]==target:
+            r = r+1
+        while 0<=l-1 and nums[l-1]==target:
+            l = l-1
+        return [l, r]

problems/hamming-distance.py

@@ -0,0 +1,32 @@
+"""
+The `^` (XOR) operator returns `1` if the bits are different.
+So the main idea is to count the `1` in the `x^y`.
+The "easy" way is
+```
+class Solution(object):
+    def hammingDistance(self, x, y):
+        return bin(x^y).count('1')
+```
+This solution takes `O(N)`, `N` is the length of the `bin(x^y)`.
+
+Or we can use some tricks, lets say `A` is `x^y` in binary form.
+`A&(A-1)` turns all the bits *right the right-most 1* to 0, including the right-most 1.
+```
+A = 10110
+A = A&(A-1) #10100
+A = A&(A-1) #10000
+A = A&(A-1) #00000
+```
+In other words, `A = A&(A-1)` will eliminate a 1 one at a time, starting from right.
+Until `A` is all 0.
+So we can use this trick to count the `1`.
+The run time will be `O(K)`, `K` is the number of 1 in `A`.
+"""
+class Solution(object):
+    def hammingDistance(self, x, y):
+        xor = x^y
+        count = 0
+        while xor:
+            count += 1
+            xor = xor&(xor-1)
+        return count

problems/number-complement.py

@@ -0,0 +1,25 @@
+"""
+First, we convert the num to its birary.
+```
+>>> bin(5)
+>>> '0b101'
+```
+
+Second, we need to return the base10 of binary's the complement.
+Complement is easy `'101' => '010'`.
+Turn to base10:
+```
+'010' => 0*pow(2, 2) + 1*pow(2, 1) + 0*pow(2, 0)
+'11011' => 1*pow(2, 4) + 1*pow(2, 3) + 0*pow(2, 2) + 1*pow(2, 1) + 1*pow(2, 0)
+```
+
+Basics bit manipulation.
+<https://www.youtube.com/watch?v=NLKQEOgBAnw>
+"""
+class Solution(object):
+    def findComplement(self, num):
+        b = bin(num)[2:]
+        opt = 0
+        for i, c in enumerate(reversed(b)):
+            if c=='0': opt+=pow(2, i)
+        return opt