updates

Author: wuduhren

problems/python3/add-two-numbers.py

@@ -0,0 +1,19 @@
+class Solution:
+    def addTwoNumbers(self, l1: Optional[ListNode], l2: Optional[ListNode]) -> Optional[ListNode]:
+        carry = 0
+        dummy = ListNode()
+        curr = dummy
+        
+        while l1 or l2 or carry:
+            n = (l1.val if l1 else 0) + (l2.val if l2 else 0) + carry
+            if n>=10:
+                curr.next = ListNode(n-10)
+                carry = 1
+            else:
+                curr.next = ListNode(n)
+                carry = 0
+            curr = curr.next
+            if l1: l1 = l1.next
+            if l2: l2 = l2.next
+            
+        return dummy.next

problems/python3/find-the-duplicate-number.py

@@ -0,0 +1,16 @@
+class Solution:
+    def findDuplicate(self, nums: List[int]) -> int:
+        head = nums[0]
+        slow = head
+        fast = head
+        
+        while True:
+            slow = nums[slow]
+            fast = nums[nums[fast]]
+            if slow==fast: break
+        
+        slow = head
+        while slow!=fast:
+            slow = nums[slow]
+            fast = nums[fast]
+        return slow

problems/python3/kth-largest-element-in-a-stream.py

@@ -0,0 +1,14 @@
+class KthLargest:
+
+    def __init__(self, k: int, nums: List[int]):
+        self.k = k
+        self.nums = nums
+        
+        heapq.heapify(self.nums)
+        while len(self.nums)>self.k: heapq.heappop(self.nums)
+        
+
+    def add(self, val: int) -> int:
+        heapq.heappush(self.nums, val)
+        if len(self.nums)>self.k: heapq.heappop(self.nums)
+        return self.nums[0]

problems/python3/last-stone-weight.py

@@ -0,0 +1,12 @@
+class Solution:
+    def lastStoneWeight(self, stones: List[int]) -> int:
+        stones = [-stone for stone in stones]
+        heapq.heapify(stones)
+        
+        while len(stones)>=2:
+            w1 = -heapq.heappop(stones)
+            w2 = -heapq.heappop(stones)
+            
+            if w1-w2>0: heapq.heappush(stones, -(w1-w2))
+        
+        return -stones[0] if stones else 0

problems/python3/linked-list-cycle.py

@@ -0,0 +1,16 @@
+class Solution:
+    def hasCycle(self, head: Optional[ListNode]) -> bool:
+        if not head: return False
+        
+        slow = head
+        fast = head
+        
+        while fast:
+            slow = slow.next
+            
+            if not fast.next: return False
+            fast = fast.next.next
+            
+            if slow==fast: return True
+        
+        return False

problems/python3/lru-cache.py

@@ -0,0 +1,47 @@
+class Node:
+    def __init__(self, key: int, val: int):
+        self.key = key
+        self.val = val
+        self.next = None
+        self.prev = None
+
+class LRUCache:
+    
+    def __init__(self, capacity: int):
+        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: int) -> int:
+        if key in self.dic:
+            node = self.dic[key]
+            self.remove(node)
+            self.promote(node)
+            return node.val
+        return -1
+            
+    def put(self, key: int, value: int) -> None:
+        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)