new commits

Author: aaron.liu

DataStructure/LC346MovingAverageFromDataStream.py

@@ -0,0 +1,25 @@
+import collections
+
+class MovingAverage:
+
+    def __init__(self, size: int):
+        self.queue = collections.queue()
+        self.size = size
+        self.total = 0
+        
+
+    def next(self, val: int) -> float:
+  
+        if len(self.queue) < self.size:
+            self.queue.append(val)
+            self.total += val
+            return self.total / len(self.queue)
+        else:
+            removal = self.queue.popleft()
+            self.queue.append(val)
+            self.total = self.total - removal + val
+            return self.total / self.size
+
+# Your MovingAverage object will be instantiated and called as such:
+# obj = MovingAverage(size)
+# param_1 = obj.next(val)

DataStructure/LC791_Custom_Sort_String.py

@@ -0,0 +1,19 @@
+import collections
+
+class Solution:
+    # 先计算s的counter, 然后按照order的顺序逐个append to res, 最后加上剩余counter里面的
+    def customSortString(self, order: str, s: str) -> str:
+        if not order or not s: return ""
+        
+
+        res = ""
+        for char in order:
+            if char in counter:    
+                while counter[char] > 0: # 必须要把counter里的所有都取出append. eg. s='eqe' order='eq',output='eeq'
+                    counter[char] -= 1
+                    res += char
+        for c, freq in counter.items():
+            while counter[c] > 0: #此部分相同 也可以放入common method
+                res += c
+                counter[c] -= 1
+        return res

LinkedLists/LC426ConvertBinarySearchTreeToSortedDoublyLinkedList.py

@@ -0,0 +1,34 @@
+from typing import Optional, List
+
+# Definition for a Node.
+class Node:
+    def __init__(self, val, left=None, right=None):
+        self.val = val
+        self.left = left
+        self.right = right
+
+class Solution:
+    # method 1: DFS in-order traverse a tree, get a node list. 
+    # then link each node, and link head and tail. ->need extra space O(n)
+    def treeToDoublyList(self, root: 'Optional[Node]') -> 'Optional[Node]':
+        if not root: return None
+        
+        head, prev = [None], [None]
+        self.dfs(root, head, prev)
+        prev[0].right = head[0]
+        head[0].left = prev[0]
+        return head[0]
+    
+    def dfs(self, node: Node, head: List[Node], prev: List[Node]):
+        if not node: return
+        
+        self.dfs(node.left, head, prev)
+
+        if prev[0]:   # 存在之前的结点(值比当前结点小的结点) 连接node和prev[0]
+            prev[0].right = node
+            node.left = prev[0]
+        else:         # 之前结点不存在: 当前结点为值最小的点 记为head
+            head[0] = node
+        prev[0] = node   # prev[0]往前移动一个 作为下一个节点的左边节点
+
+        self.dfs(node.right, head, prev)

LinkedLists/LC708InsertIntoASortedCircularLinkedList.py

@@ -0,0 +1,38 @@
+from typing import Optional
+
+# Definition for a Node.
+class Node:
+    def __init__(self, val=None, next=None):
+        self.val = val
+        self.next = next
+
+class Solution:
+    # 三种情况: 
+    # 1. no head
+    # 2. insertVal >= max or inserVal <= min: 插入max->insertVal->min
+    # 3. 都不是 就直接插入
+    def insert(self, head: 'Optional[Node]', insertVal: int) -> 'Node':
+        cur_node = Node(insertVal)
+        if not head:
+            cur_node.next = cur_node
+            return  cur_node
+        
+        dummy = Node(-1)
+        dummy.next = head
+
+        # find min and max value nodes
+        while head.next != dummy.next and head.val <= head.next.val:
+            head = head.next
+        min = head.next     # head stops at max
+
+        if head.val <= insertVal or insertVal <= min.val:
+            cur_node.next = min
+            head.next = cur_node
+        else:
+            while head.next.val < insertVal:
+                head = head.next
+            cur_node.next = head.next
+            head.next = cur_node
+        return dummy.next
+
+        

ML/attention/single_head_attention.py

@@ -0,0 +1,50 @@
+'''
+
+single head attention.
+
+input: query and key-value
+
+注意力机制首先计算query与每个key的关联性(compatibility),每个关联性作为每个value的weight,各个weight与value相乘后相加,得到输出.
+
+Attention(Q, K, V) = softmax(QK^T / sqrt(d_k)) * V
+'''
+
+import torch
+from torch import nn
+
+class ScaledDotProductAttention(nn.Module):
+    """ Scaled Dot-Product Attention """
+
+    def __init__(self, scale):
+        super().__init__()
+
+        self.scale = scale
+        self.softmax = nn.Softmax(dim=2)
+
+    def forward(self, q, k, v, mask=None):
+        u = torch.bmm(q, k.transpose(1, 2)) # 1.Matmul
+        u = u / self.scale # 2.Scale
+
+        if mask is not None:
+            u = u.masked_fill(mask, -np.inf) # 3.Mask
+
+        attn = self.softmax(u) # 4.Softmax
+        output = torch.bmm(attn, v) # 5.Output
+
+        return attn, output
+
+
+if __name__ == "__main__":
+    n_q, n_k, n_v = 2, 4, 4
+    d_q, d_k, d_v = 128, 128, 64
+
+    q = torch.randn(batch, n_q, d_q)
+    k = torch.randn(batch, n_k, d_k)
+    v = torch.randn(batch, n_v, d_v)
+    mask = torch.zeros(batch, n_q, n_k).bool()
+
+    attention = ScaledDotProductAttention(scale=np.power(d_k, 0.5))
+    attn, output = attention(q, k, v, mask=mask)
+
+    print(attn)
+    print(output)

Stack/LC71SimplifyPath.py

@@ -0,0 +1,19 @@
+
+class Solution:
+    # 先split成list. 用stack
+    # 如果遇到“..”: 
+    #      如果有stack就pop. 如果“.” or "", continue. else stack.append
+    def simplifyPath(self, path: str) -> str:
+        stack = []
+        pathList = path.split("/")
+        
+        for string in pathList:
+            if string == "." or string == "":
+                continue
+            elif string == "..":
+                if stack:
+                    stack.pop() # ..意思是退到上一层 
+            else:
+                stack.append(string)
+                
+        return "/" + "/".join(stack)

Tree/LC938RangeSumOfBST.py

@@ -0,0 +1,20 @@
+from typing import Optional
+
+# Definition for a binary tree node.
+class TreeNode:
+    def __init__(self, val=0, left=None, right=None):
+        self.val = val
+        self.left = left
+        self.right = right
+
+class Solution:
+    def rangeSumBST(self, root: Optional[TreeNode], low: int, high: int) -> int:
+       
+        if not root: return 0
+
+        if root.val < low:      # 当前root小了 在范围外 应该往右走
+            return self.rangeSumBST(root.right, low, high)
+        if root.val > high:     # 当前root大了 在范围外 应该往左走
+            return self.rangeSumBST(root.left, low, high) 
+        # 当前root值在给定范围内 可以放到和里 然后递归求左边和右边 
+        return root.val + self.rangeSumBST(root.left, low, high) + self.rangeSumBST(root.right, low, high)

Tree/doordash_num_of_menu_updates.py

@@ -0,0 +1,67 @@
+# https://leetcode.com/discuss/interview-question/1528907/doordash-phone-creen
+# reference:
+# https://vivo.pub/calculate-tree-node-changes/
+
+from typing import List
+
+
+class Node:
+    def __init__(self, key:str=None, val:int=None, children:List['Node']=[]):
+        self.key = key
+        self.val = val
+        self.children = children
+
+def compare_old_and_updated_menus(root_o: Node, root_u: Node) -> int:
+    return dfs_compare(root_o, root_u)
+
+def count_nodes(root: Node) -> int:
+    if not root:
+        return 0
+    num = 1
+    for child in root.children:
+        num += count_nodes(child)
+    return num    
+
+def dfs_compare(root_o: Node, root_u: Node) -> int:
+    if not root_o and not root_u:
+        return 0
+    if not root_o:
+        return count_nodes(root_u)
+    if not root_u:
+        return count_nodes(root_o)
+    if root_o.key != root_u.key:
+        return count_nodes(root_u) + count_nodes(root_o)
+
+    diff_cnt = 0
+    if root_o.val != root_u.val:
+        diff_cnt += 1
+    
+    origin_map = {}
+    visited = set()
+    for child in root_o.children:
+        origin_map[child.key] = child
+
+    for child in root_u.children:
+        if child.key in origin_map:
+            visited.add(child.key)
+            diff_cnt += dfs_compare(origin_map[child.key], child)
+        else:
+            diff_cnt += count_nodes(child)
+    
+    for child in root_o.children:
+        if child.key not in visited:
+            diff_cnt += count_nodes(child)
+    return diff_cnt
+
+
+# case 1
+d_o, e_o, f_o = Node("d", 4), Node("e", 5), Node("f", 6)
+b_o, c_o = Node("b", 2, [d_o, e_o]), Node("c", 3, [f_o])
+a_o = Node("a", 1, [b_o, c_o])               # a_o is the root_o
+
+f_u = Node("f", 66)
+c_u = Node("c", 3, [f_u])
+a_u = Node("a", 1, [c_u])                   # a_u is the root_u
+
+
+print(compare_old_and_updated_menus(a_o, a_u))