update

Author: aaron.liu

Diff for: Array/LC247StrobogrammaticNumberII.py

@@ -0,0 +1,29 @@
+class Solution:
+    def findStrobogrammatic(self, n: int) -> List[str]:
+        map = {
+            "0": "0",
+            "1": "1",
+            "6": "9",
+            "8": "8",
+            "9": "6",
+        }
+        
+        ret = []
+        
+        if n % 2 == 1:
+            ret = ["0", "1", "8"]
+            n -= 1
+        else:
+            ret = [""]
+        
+        while n:
+            size = len(ret)
+            while size:
+                size -= 1
+                cur = ret.pop(0)
+                for key in map:
+                    if n == 2 and key == "0":
+                        continue
+                    ret.append(key + cur + map[key])
+            n -= 2
+        return ret

Diff for: Array/LC468 Validate IP Address.py

@@ -0,0 +1,27 @@
+# Aaron solution
+# Time O(N) 
+# Space O(N)
+def validIPAddress(self, queryIP: str) -> str:
+
+    def is_ip_v4(s):   
+        address = s.split(".")
+        if len(address) != 4: return False 
+        for item in address: 
+            if not item.isdigit() or str(int(item)) != item or int(item) > 255: # str(int(item)) != item -> 判断是否有leading zeros. 如果有 int()会把前导0消除 在str()回去 就跟原始的item不同
+                return False 
+        return True 
+
+    def is_ip_v6(s): 
+        address = s.split(":")
+        if len(address) != 8: return False 
+        for item in address: 
+            if len(item) < 1 or len(item) > 4: return False 
+            for ch in item.lower(): # 先转换成小写
+                if 'a' <= ch <= 'f' or '0' <= ch <= '9': 
+                    continue 
+                else: 
+                    return False
+        return True 
+
+    if is_ip_v4(queryIP): return "IPv4" 
+    return "IPv6" if is_ip_v6(queryIP) else "Neither"

Diff for: Array/LC825FriendsOfAppropriateAges.py

@@ -0,0 +1,18 @@
+from typing import List
+
+class Solution:
+    def numFriendRequests(self, ages: List[int]) -> int:
+        size = len(ages) # 有多少人
+        
+        age_num = [0] * 121 # age_num[i]: 第i岁有多少人
+        for age in ages:
+            age_num[age] += 1
+        
+        ret = size * size  # 可能的所有请求个数 后面会剔除非法的请求
+        for i in range(1, 121):         # 枚举所有可能的年龄(代表某个人)
+            for j in range(1, 121):     # 枚举所有可能的年龄(代表某个人)
+                if (j <= 0.5 * i + 7) or (j > i):
+                    ret -= age_num[i] * age_num[j]
+                elif j == i:  # 剔除自己向自己发请求(自环)
+                    ret -= age_num[j]
+        return ret

Diff for: Array/Meta reorder string.py

@@ -0,0 +1,30 @@
+'''
+输入一个字符串s 要求根据s里的字符出现的frequency从高到低重新排序。e.g. "mammamia" -> "mmmmaaai". 
+如果字符出现次数相同，按字母表顺序排列相同频率的字符
+'''
+
+from collections import Counter
+
+def frequency_sort(s: str) -> str:
+    # Step 1: 统计每个字符的频率
+    freq = Counter(s)
+    
+    # Step 2: 按照频率和字母顺序排序
+    # 使用 (-freq[char], char) 作为排序键，先按频率降序，再按字母升序
+    sorted_chars = sorted(freq.keys(), key=lambda ch: (-freq[ch], ch))
+    
+    # Step 3: 根据排序结果重构字符串
+    result = ''.join(char * freq[char] for char in sorted_chars)
+
+    # step 3 也能这么写
+    #result = ''
+    #for char in sorted_chars:
+    #    result += char * freq[char]
+    
+    return result
+
+# 测试
+print(frequency_sort("mammamia"))  # 输出: "mmmmaaai"
+print(frequency_sort("tree"))      # 输出: "eert"
+print(frequency_sort("cccaaa"))    # 输出: "aaaccc"
+print(frequency_sort("Aabb"))      # 输出: "bbAa"

Diff for: Array/Meta second largest num.py

@@ -0,0 +1,42 @@
+# Given a list of numbers (0-9) arrange the numbers in the second greatest number
+
+from typing import List
+from collections import Counter
+
+def find_sencond_largest(nums: List[int]) -> int:
+    # 将数字转换为字符串并计数
+    counter = Counter(num for num in nums)
+    max_digit, min_digit = -1, 10
+    
+    for key in counter.keys():
+        max_digit = max(max_digit, key)
+        min_digit = min(min_digit, key)
+    
+    if max_digit == 0:
+        return 0
+    
+    # 构建最大数
+    max_num  = []
+    for num in range(max_digit, min_digit - 1, -1):
+        if num in counter:
+            cur = [num] * counter[num]
+            max_num.extend(cur)
+
+    # 从右向左查找第一个可以减小的数字
+    # 877777
+    # 11000
+    pivot = -1
+    for i in range(len(max_num) - 1, 0, -1):
+        if max_num[i - 1] > max_num[i]:
+            pivot = i - 1
+
+        if pivot != -1 and not (max_num[i] == 0 and i - 1 == 0):
+            max_num[i - 1], max_num[i] = max_num[i], max_num[i - 1]
+            print("final list", [str(s) for s in max_num])
+            return int(''.join([str(s) for s in max_num]))
+    return int(''.join(max_num))
+
+print(find_sencond_largest([5,3,2,5,5,7,9,8])) 
+print(find_sencond_largest([9,8,7,6,5,4,3,2,1,0])) 
+print(find_sencond_largest([1,2,3,4,5]))
+print(find_sencond_largest([1,1,0,0,0])) 

Diff for: BinarySearch/LC26RemoveDuplicatesFromSortedArray.py

@@ -0,0 +1,31 @@
+'''
+variation of LC 489
+find cheese and instead of manual rotation, the robot can move in any direction
+assume cheese 
+'''
+from typing import List
+
+class Robot:
+    def check_cheese(self) -> bool:
+        pass 
+    
+    def move(self) -> bool:
+        pass
+
+
+def find_cheese(robot: Robot):
+    directions = [(-1, 0), (1, 0), (0, 1), (0, -1)]
+    visited = set()
+    visited.add((0, 0))
+    dfs(robot, directions, 0, 0, visited)
+
+def dfs(robot: Robot, directions: List[tuple[int, int]], x: int, y: int, visited: set) -> List[int]:
+    if robot.check_cheese():
+        return [x, y]
+    
+    for i in range(4):
+        nx = x + directions[i][0]
+        ny = y + directions[i][1]
+        if (nx, ny) not in visited and robot.move():
+            visited.add(nx, ny)
+            dfs(robot, directions, nx, ny, visited)

Diff for: DFS/Meta_cleaning_robot.py

@@ -0,0 +1,73 @@
+'''
+Given an linked list nums and an integer k, return the k most frequent elements. You may return the answer in any order.
+
+Example 1:
+
+Input: nums = [1,1,1,2,2,3], k = 2
+Output: [1,2]
+Example 2:
+
+Input: nums = [1], k = 1
+Output: [1]
+ 
+
+Constraints:
+
+1 <= nums.length <= 105
+-104 <= nums[i] <= 104
+k is in the range [1, the number of unique elements in the array].
+It is guaranteed that the answer is unique.
+'''
+from collections import defaultdict
+import heapq
+
+class ListNode:
+    def __init__(self, x):
+        self.val = x
+        self.next = None
+
+
+def topKFrequent(head: ListNode, k: int) -> list:
+    # Step 1: Count the frequency of each element in the linked list
+    frequency = defaultdict(int)
+    current = head
+    
+    while current:
+        frequency[current.val] += 1
+        current = current.next
+    
+    # Step 2: Use a min-heap to keep track of the top k elements
+    min_heap = []
+    
+    for num, freq in frequency.items():
+        heapq.heappush(min_heap, (freq, num))
+        if len(min_heap) > k:
+            heapq.heappop(min_heap)
+    
+    # Step 3: Extract the elements from the heap
+    result = []
+    while min_heap:
+        result.append(heapq.heappop(min_heap)[1])
+    
+    return result
+
+# Helper function to create linked list from list of values
+def create_linked_list(values):
+    if not values:
+        return None
+    head = ListNode(values[0])
+    current = head
+    for value in values[1:]:
+        current.next = ListNode(value)
+        current = current.next
+    return head
+
+# Test case 1
+nums = create_linked_list([1, 1, 1, 2, 2, 3])
+k = 2
+print(topKFrequent(nums, k))  # Output: [1, 2]
+
+# Test case 2
+nums = create_linked_list([1])
+k = 1
+print(topKFrequent(nums, k))  # Output: [1]

Diff for: LinkedLists/Meta Top K Frequent Elements in linked list.py

@@ -0,0 +1,28 @@
+from typing import Optional
+import collections
+
+# 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 isCompleteTree(self, root: Optional[TreeNode]) -> bool:
+        seen_null = False
+        queue = collections.deque([root])
+        while queue:
+            if seen_null:
+                return not any(queue)
+            
+            for _ in range(len(queue)):
+                node = queue.popleft()
+                if not node:
+                    seen_null = True
+                else:
+                    if seen_null:
+                        return False
+                    queue.append(node.left)
+                    queue.append(node.right)
+        return True

Diff for: Memo/LC2060CheckIfAnOriginalStringExistsGivenTwoEncodedStrings.py

@@ -4,36 +4,39 @@
 
 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)
+    diff = []
+    ret = dfs_compare(root_o, root_u, diff)
+    print([item.key for item in diff])
+    return ret
 
-def count_nodes(root: Node) -> int:
+def count_nodes(root: Node, diff: List=[]) -> int:
     if not root:
         return 0
+    diff.append(root)
     num = 1
     for child in root.children:
         num += count_nodes(child)
     return num    
 
-def dfs_compare(root_o: Node, root_u: Node) -> int:
+def dfs_compare(root_o: Node, root_u: Node, diff: List) -> int:
     if not root_o and not root_u:
         return 0
     if not root_o:
-        return count_nodes(root_u)
+        return count_nodes(root_u, diff)
     if not root_u:
-        return count_nodes(root_o)
+        return count_nodes(root_o, diff)
     if root_o.key != root_u.key:
-        return count_nodes(root_u) + count_nodes(root_o)
-
+        return count_nodes(root_u, diff) + count_nodes(root_o, diff)
     diff_cnt = 0
     if root_o.val != root_u.val:
+        diff.append(root_o)
         diff_cnt += 1
 
     origin_map = {}
@@ -44,24 +47,35 @@ def dfs_compare(root_o: Node, root_u: Node) -> int:
     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)
+            diff_cnt += dfs_compare(origin_map[child.key], child, diff)
         else:
-            diff_cnt += count_nodes(child)
+            diff_cnt += count_nodes(child, diff)
 
     for child in root_o.children:
         if child.key not in visited:
-            diff_cnt += count_nodes(child)
+            diff_cnt += count_nodes(child, diff)
     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
+'''
+# case 2
+old_tree = Node("root", 1, [])
+child1_old = Node("child1", 2, [])
+child2_old = Node("child2", 3, [])
+old_tree.children = [child1_old, child2_old]
+
 
+new_tree = Node("root", 1, [])
+child1_new = Node("child1", 5, [])  # Value changed
+child3_new = Node("child3", 4, [])  # New node
+new_tree.children = [child1_new, child3_new]
 
-print(compare_old_and_updated_menus(a_o, a_u))
+print(compare_old_and_updated_menus(old_tree, new_tree))