no message

Author: Chris Wu

lru-cache.py

@@ -0,0 +1,105 @@
+"""
+I learned this answer from @tusizi; rewrote it.
+
+Let's analyze the problem
+If we need get() to be O(1),
+we must definitely use a hashmap(dictionary) to store the key value.
+
+put() is not a problem, since we are only setting value.
+The problem is when we excceed the capacity.
+How do we find the least-used key and remove it from the hashmap?
+We need something for us to sort from most-frequent-used to least-used.
+
+So what else common data structure do we know?
+Array? no, we will need to iterate to the whole array to find what we need. and it is not easy to add or remove.
+Tree? not likely.
+Min-heap? even though we can get the least-used, but it need O(LogN) to set the most-frequent-used.
+Link list? Bingo!
+
+We also need it to be a double link list, so we can remove the tail.
+We also need the node to store the key when we remove the tail, we can also remove it in the hashmap
+We also need the node to store the val when we get().
+
+It would be like:
+head<->node1<->node2<->node3 ... nodeN<->tail
+(most-frequent-used to least-used)
+
+So the main idea now is to use hashmap to store the key:Node pair [0]
+If we put or get any key-value pair, we move its node to the front of the line (I call this promote()) [1]
+The front of the line means we put it just after head.
+If we excced the capacity, we remove the node at the end of the line [2]
+The end of the line means the node just before tail.
+
+The head and tail is just a dummy, [3]
+for us to keep track of the first and the last of the linklist
+and don't have worry about the edge case.
+"""
+class Node(object):
+    def __init__(self, key, val):
+        self.key = key
+        self.val = val
+        self.next = None
+        self.prev = None 
+
+class LRUCache(object):
+    def __init__(self, capacity):
+        self.capacity = capacity
+        self.dic = {} #[0]
+        self.head = Node(0, 0) #[3]
+        self.tail = Node(0, 0) #[3]
+        self.head.next = self.tail
+        self.tail.prev = self.head
+        
+    def remove(self, node):
+        node.prev.next = node.next
+        node.next.prev = node.prev
+    
+    def promote(self, node): #[1]
+        #set the node next to head
+        temp = self.head.next
+        node.next = temp
+        temp.prev = node
+        self.head.next = node
+        node.prev = self.head
+
+    def get(self, key):
+        if key in self.dic:
+            node = self.dic[key]
+            self.remove(node)
+            self.promote(node)
+            return node.val
+        return -1
+            
+    def put(self, key, value):
+        if key in self.dic:
+            self.remove(self.dic[key])
+        node = Node(key, value)
+        self.promote(node)
+        self.dic[key] = node
+        
+        if len(self.dic)>self.capacity: #[2]
+            del self.dic[self.tail.prev.key]
+            self.remove(self.tail.prev)
+
+#using OrderedDict()
+class LRUCache(object):
+    def __init__(self, capacity):
+        self.dic = collections.OrderedDict()
+        self.remain = capacity
+
+    def get(self, key):
+        if key not in self.dic:
+            return -1
+        v = self.dic.pop(key) 
+        self.dic[key] = v   # set key as the newest one
+        return v
+
+    def set(self, key, value):
+        if key in self.dic:    
+            self.dic.pop(key)
+        else:
+            if self.remain > 0:
+                self.remain -= 1  
+            else:  # self.dic is full
+                self.dic.popitem(last=False) 
+        self.dic[key] = value

maximum-product-of-three-numbers.py

@@ -0,0 +1,38 @@
+"""
+if we sort the array, the max would be the product 3 numbers on the right.
+but if there are negative numbers, it could also be possible that
+two negative numbers lying at the left extreme end could also contribute to lead to a larger product.
+thus, after sorting, either
+
+max1 * max2 * max3
+max1 * min1 * min2
+
+so our gaol will be to find the max 3 numbers and min 2 numbers in the array
+"""
+class Solution(object):
+    def maximumProduct(self, nums):
+        min1 = float('inf') #smallest
+        min2 = float('inf') #second smallest
+
+        max1 = float('-inf') #largest
+        max2 = float('-inf') #second largest
+        max3 = float('-inf') #third largest
+
+        for n in nums:
+            if n<=min1:
+                min2 = min1
+                min1 = n
+            elif n<=min2:
+                min2 = n
+            
+            if n>=max1:
+                max3 = max2
+                max2 = max1
+                max1 = n
+            elif n>=max2:
+                max3 = max2
+                max2 = n
+            elif n>=max3:
+                max3 = n
+
+        return max(min1*min2*max1, max1*max2*max3)

minimum-path-sum.py

@@ -0,0 +1,27 @@
+"""
+let's reset the array by it's min value start out from (0,0)
+in another words, after reset
+grid[i][j]'s value will be the min value start out from (0,0)
+
+if we are at (i,j), we will be either from (i-1,j) or (i,j-1)
+we call them s1 and s2, let's assume they are both in range
+grid[i][j] will be grid[i][j]+min(s1, s2)
+
+we will start out from (0,0) and reset the entire grid.
+"""
+class Solution(object):
+    def minPathSum(self, grid):
+        n = len(grid)
+        m = len(grid[0])
+        for i in xrange(n):
+            for j in xrange(m):
+                s1 = s2 = float('inf')
+                if i-1>=0:
+                    s1 = grid[i-1][j]
+                if j-1>=0:
+                    s2 = grid[i][j-1]
+                    
+                if s1==float('inf') and s2==float('inf'): continue #both source out of range
+                grid[i][j]+=min(s1, s2)
+                
+        return grid[-1][-1]

sliding-window-maximum.py

@@ -0,0 +1,19 @@
+class Solution(object):
+    def maxSlidingWindow(self, nums, k):
+        opt = []
+        q = collections.deque()
+        for i in xrange(len(nums)):
+            n = nums[i]
+            
+            #move the window
+            if q and q[0]<=i-k: q.popleft()
+
+            #pop the right if the element in queue is not greater than the in-coming one
+            #by doing this, we can always keep the max in the current window at left most
+            while q and nums[q[-1]]<=n: q.pop()
+
+            q.append(i)
+
+            #add the max to the output array after the first kth element
+            if 1+i>=k: opt.append(nums[q[0]])
+        return opt

two-sum.py

@@ -1,13 +1,26 @@
 #https://leetcode.com/problems/two-sum/
 """
-I really take time to explain my solution, because I wanted to help people understand.
-If you like my answer, a star on GitHub I will really appreciated.
-https://github.com/wuduhren/leetcode-python
+when we iterate through the nums
+we don't know if the counter part exist
+so we store the counter part we want in the 'wanted' with the index now
+so inside the wanted is {the_counter_part_we_want:index_now} [0]
+
+later on if we found the num is in 'wanted'
+we return the index_now and the index_now we previously stored in the 'wanted' [1]
 """
 class Solution(object):
     def twoSum(self, nums, target):
-        for idx, val in enumerate(nums):
-            for idx2 in range(idx+1, len(nums)):
-                val2 = nums[idx2]
-                if ((val+val2)==target):
-                    return [idx, idx2]
+        wanted = {}
+        for i in xrange(len(nums)):
+            n = nums[i]
+            if n in wanted: #[1]
+                return [wanted[n], i]
+            else:
+                wanted[target-n] = i #[0]
+        return []
+
+"""
+I really take time to explain my solution, because I wanted to help people understand.
+If you like my answer, a star on GitHub I will really appreciated.
+https://github.com/wuduhren/leetcode-python
+"""

unique-email-addres.py

@@ -1,16 +1,74 @@
 #https://leetcode.com/problems/unique-email-addresses/
-import re
+"""
+[0]
+First we use set to store the processed email
+set is implement in hashmap, so it takes O(1) to store unique value.
+
+[1]
+Split the email by '@' to local_name and domain_name
+
+[2]
+we find the first '+' and remove the char after it.
+
+[3]
+we remove the '.' in the string.
+
+we iterate the local_name part 3 times
+first time we are finding the first '@'
+second time we are finding the first '+'
+third time we are finding all the '.'
+
+isn't faster to just iterate once?
+so I come up with the second solution which only iterate once to process the email
+but it is slower, I guess Python really do a good job on the string function
+because they are implemented by C.
+in other language, the second solution might be faster.
+
+both solution are O(N)
+"""
 class Solution(object):
     def numUniqueEmails(self, emails):
-        rs_list = []
+        book = set() #[0]
         for s in emails:
-            local_name = s[:s.index('@')]
-            domain_name = s[s.index('@'):]
+            at = s.find('@') #[1]
+            local_name = s[:at]
+            domain_name = s[at:]
 
-            local_name = local_name[:local_name.index('+')]
-            local_name = local_name.replace('.', '')
-            r = local_name+domain_name
+            plus = local_name.find('+') #[2]
+            if plus!=-1: local_name = local_name[:plus]
+
+            local_name = local_name.replace('.', '') #[3]
+
+            r = local_name+domain_name #[0]
+            book.add(r)
 
-            if r not in rs_list:
-                rs_list.append(r)
-        return len(rs_list)
+        return len(book)
+
+
+class Solution(object):
+    def numUniqueEmails(self, emails):
+        book = set()
+        for email in emails:
+            r = ''
+            ignore = False
+            for i, c in enumerate(email):
+                if c=='@':
+                    r+=email[i:]
+                    break
+                    
+                if ignore: continue
+                    
+                if c=='.':
+                    continue
+                elif c=='+':
+                    ignore = True
+                else:
+                    r+=c                    
+            book.add(r)
+        return len(book)
+
+"""
+I really take time to make the best solution, because I wanted to help people understand.
+If you like my answer, a star on GitHub I will really appreciated.
+https://github.com/wuduhren/leetcode-python
+"""