update

Author: aaron.liu

Array/LC14 Longest Common Prefix.py

@@ -0,0 +1,20 @@
+'''
+https://leetcode.com/problems/longest-common-prefix/description/?envType=company&envId=apple&favoriteSlug=apple-three-months
+
+竖着一个个字符对比即可 
+
+followup: 如果多次query LCP 怎么处理? --> 用trie. 用strs里的字符串建立trie 然后来一个query就用trie做前缀匹配
+'''
+from typing import List
+
+class Solution:
+    # time O(S), where S is the total lenth of all str in strs. space: O(1) 
+    def longestCommonPrefix(self, strs: List[str]) -> str:
+        if not strs:
+            return ""
+        for i in range(len(strs[0])): # 最长前缀不会超过strs[0]的长度
+            char = strs[0][i] # 取出第i个字符
+            for j in range(1, len(strs)): # 遍历剩下字符串j的每一个字符
+                if i == len(strs[j]) or strs[j][i] != char: # 第j个字符走到头 或者 第i个字符与strs[j][i]不匹配
+                    return strs[0][:i] # [:i]左闭右开
+        return strs[0]

Array/LC165 Compare Version Numbers.py

@@ -0,0 +1,41 @@
+'''
+Time complexity : O(max(N,M)), where N and M are the lengths of the input strings respectively. It's a one-pass solution.
+
+Space complexity : O(max(N,M)).
+
+Despite the fact that we did not keep arrays of revision numbers, 
+we still need some additional space to store a substring of the input string for integer conversion.
+
+In the worst case, the substring could be of the original string as well.
+'''
+from typing import List
+
+class Solution:
+    def get_chunk(self, version: str, n: int, p: int) -> List[int]:
+        # 已经走完了当前str
+        if p > n - 1:
+            return 0, p
+
+        # 找一下个"."的位置
+        p_end = p
+        while p_end < n and version[p_end] != ".":
+            p_end += 1 # p_end最后停在.的idx
+
+        # 截取出对应的数字 p_n在str结尾处需要特判
+        num = int(version[p:p_end]) if p_end != n - 1 else int(version[p:n])
+        # p指向下一个chuck的起点 为了下一次截取数字
+        p = p_end + 1
+        return num, p
+
+    def compareVersion(self, version1: str, version2: str) -> int:
+        p1, p2 = 0, 0
+        n1, n2 = len(version1), len(version2)
+
+        while p1 < n1 or p2 < n2: # 注意这里是or 有一个str还有就接着走
+            num1, p1 = self.get_chunk(version1, n1, p1)
+            num2, p2 = self.get_chunk(version2, n2, p2)
+            if num1 != num2:
+                return 1 if num1 > num2 else -1
+
+        # 走过一遍都没return 两个版本最后相等
+        return 0   

Array/LC189 Rotate Array.py

@@ -0,0 +1,17 @@
+from typing import List
+
+class Solution:
+    def reverse(self, nums: list, start: int, end: int) -> None:
+        while start <= end:
+            nums[start], nums[end] = nums[end], nums[start]
+            start += 1
+            end -= 1
+
+    def rotate(self, nums: List[int], k: int) -> None:
+        n = len(nums)
+        k %= n # 对n取module: 有可能k > n
+        
+        # 三步翻转法: 整体翻转 前k个翻转 后n-k个翻转
+        self.reverse(nums, 0, n - 1)
+        self.reverse(nums, 0, k - 1)
+        self.reverse(nums, k, n - 1)

Array/LC238 Product of Array Except Self.py

@@ -0,0 +1,24 @@
+'''
+https://leetcode.com/problems/product-of-array-except-self/description/?envType=company&envId=apple&favoriteSlug=apple-six-months&status=TO_DO
+
+前后缀分解问题
+前缀乘积用数组prefix表示 prefix[i]:前i-1个数的乘积(不包括第i个数) 容易得出:prefix[i] = prefix[i-1]*nums[i-1]
+后缀乘积也可以用数组表示 但是题目要求space O(1)复杂度 所以后缀乘积用一个变量suffix表示 然后on the flight的从后往前计算答案 同时更新suffix
+'''
+from typing import List
+
+class Solution:
+    def productExceptSelf(self, nums: List[int]) -> List[int]:
+        n = len(nums)
+        prefix = [1] * n
+ 
+        for i in range(1, n): # 先计算前缀乘积数组
+            prefix[i] = prefix[i - 1] * nums[i - 1]
+        
+        suffix, idx = 1, n - 1 # 从后往前
+        while idx >= 0:
+            prefix[idx] = prefix[idx] * suffix
+            suffix *= nums[idx] # 每次更新完答案 也要更新suffix 给下一次计算用
+            idx -= 1
+        
+        return prefix

Array/LC3 Longest Substring Without Repeating Characters.py

@@ -0,0 +1,24 @@
+'''
+双指针 
+维护区间[i,j] 使得该区间内部没有重复字符 当出现重复字符时 朝j的方向移动i 当窗口内无重复字符时 再移动j
+'''
+from collections import defaultdict
+
+class Solution:
+    def lengthOfLongestSubstring(self, s: str) -> int:
+        if not s:
+            return 0
+        
+        n, ret = len(s), 0
+        map = defaultdict(int) # str:freq
+
+        # 双指针模板
+        i, j = 0, 0
+        while j < len(s): 
+            map[s[j]] += 1 # j对应的字符freq+1 
+            while map[s[j]] > 1: # 出现重复字符了:刚加入的字符freq大于1
+                map[s[i]] -= 1   # i指向的字符滑出窗口 freq-1
+                i += 1           # 移动i
+            ret = max(ret, j - i + 1) # 每一步更新见过的窗口大小
+            j += 1 # 用while要记得显示写j+=1 
+        return ret

Array/Linkedin Compute Sorted Fx For Sorted Array.py

@@ -0,0 +1,53 @@
+'''
+given sorted array A of doubles. compute a new sorted array B where each element
+is obtained by applying the following fuction F(x) (x is element in A)
+f(x) = ax^2 + bx + c, where a > 0
+output: array B of sorted doubles f(x)
+
+parabola with a > 0, 开口向上的抛物线. 最小值=-b/(2a) 根据图像法: 在最小值左边单调减 在最小值右边单调增
+分成两部分算 得到两个array 然后转化成 merge two sorted array
+time complexity: O(n) -> 沿抛物线算两个f_x数组O(n), merge two sorted list O(n)
+'''
+
+from typing import List
+def compute_sorted_fx(nums: List[float], a:float, b:float, c:float) -> List[float]:
+    if (a <= 0):
+        raise ValueError("input a should be >= 0")
+
+    min_val = -b / (2*a)
+    left_arr, right_arr = [], []
+
+    for i in range(len(nums)):
+        f_x = a * (nums[i] ** 2) + b * nums[i] + c
+        if nums[i] <= min_val:        # parabola左边 left_arr单调减小
+            left_arr.append(f_x)
+        else:
+            right_arr.append(f_x)     # parabola右边 right_arr
+    
+    # 下面是merge two sorted list的模板
+    out_arr = []
+    left_idx, right_idx = len(left_arr) - 1, 0    # 注意left是从后往前数 要注意单调性
+    while left_idx >= 0 and right_idx < len(right_arr): # 写while循环注意在循环逻辑最后把对应的idx++/--
+        if left_arr[left_idx] <= right_arr[right_idx]:
+            out_arr.append(left_arr[left_idx])
+            left_idx -= 1
+        else:
+            out_arr.append(right_arr[right_idx])
+            right_idx += 1
+    
+    while left_idx >= 0:
+        out_arr.append(left_arr[left_idx])
+        left_idx -= 1
+    while right_idx < len(right_arr):
+        out_arr.append(right_arr[right_idx])
+        right_idx += 1
+    
+    return out_arr
+
+# unit test
+a = 2.0
+b = -20.0
+c = 1.0
+nums = [-13, -10, -3, 1, 2, 3, 4, 5, 6, 7, 20, 50]
+
+print(compute_sorted_fx(nums, a, b, c))

Array/Linkedin Meeting Point.py

@@ -0,0 +1,134 @@
+'''
+N robots on a line. Find a point such that the total distance traveled by all robots is minimized.
+
+Input:
+The position pi of each robot i={1, 2, ..., N}, unsorted array
+Output:
+meeting point x* such that the total distance traveled by all individuals is minimized.
+
+x* = min_x: sum(|x - p_i|) -> convex function because sum of convex funtions is also convex.
+形象得想 在数轴上 如果起初把meeting point定在median 然后再把meeting point往左或者右移动delta 可以发现 距离之和
+一定会增加delta. 所以median是最优meeting point
+'''
+
+from typing import List
+
+def find_median(nums: List[float]) -> float:
+    if not nums:
+        return 0.0
+    target_th = len(nums) // 2 if len(nums) % 2 == 0 else len(nums) // 2 + 1
+    idx = partition(nums, target_th, 0, len(nums) - 1)
+    return nums[idx]
+
+def partition(nums:List[float], k:int, start:int, end:int) -> int:
+    if start >= end:                                # corner case: keys is empty. start = 0, end = -1
+        return start
+    
+    left, right = start - 1, end + 1    # 每次用start的后一个 和end的前一个相比 (含义是[start, left], [right, end]已经排好序了)
+    pivot = nums[(left + right) // 2]   # pivot选择中间点的值 比较保险 
+    while left < right:
+        while True:
+            left += 1
+            if nums[left] >= pivot:    # left从左往右找第一个>=pivot的数
+                break
+        while True:
+            right -= 1                 # right从右往左找第一个<=pivot的数
+            if nums[right] <= pivot:
+                break
+        if left < right:               # 交换l,r指向的数 注意这里l,r交换后 不会加一/减一
+            nums[left], nums[right] = nums[right], nums[left]
+    
+    if k <= right - start + 1:        # 左边区间[s, r]有(r-s+1)个数字 k<=它 说明第k小的数 落在[s,r]内 往左递归
+        return partition(nums, k, start, right)
+    else:                             # 在右边区间里 找第 k-(r-s+1)小的数字 左半边区间已经有(r-s+1)个数字了 所以要减掉
+        return partition(nums, k - (right - start + 1), right + 1, end)
+
+# nums = [4.1, 2.2, 2.4, 1.8, 5.4, 6.9]
+nums = [4.1, 2.2, 2.4, 1.8, 5.4]
+print(find_median(nums))
+
+'''
+followup: 如果数组太大 无法放到一台机器上 如何分布式求解?
+利用p-persentile distributed calcuation求解
+
+步骤 1:数据分割
+将大数组分割成若干小块，每块数据可以放入单台机器进行处理。假设有 N 台机器，那么将数组分割成 N 块，每块由一个机器负责处理。
+
+步骤 2: 初始候选选择
+随机选择一些数据点作为候选中位数。这些候选点可以从数据块中随机采样得到。
+
+步骤 3: 分布式统计
+将这些候选中位数广播到所有机器上，并在每个机器上计算其数据中小于等于每个候选的个数。
+
+步骤 4: 汇总统计结果 
+协调节点汇总所有机器上的统计结果，计算全局范围内每个候选的累计个数。
+
+步骤 5: 调整搜索范围
+根据累计个数和目标中位数的位置，调整候选的搜索范围。重复步骤 2 到 4, 直到搜索范围收敛。
+'''
+'''
+import random
+import numpy as np
+
+# 将数据分割成若干块
+def split_data(data, num_chunks):
+    return np.array_split(data, num_chunks)
+
+# 生成初始候选中位数
+def initial_candidates(data_chunks, num_candidates):
+    all_data = np.concatenate(data_chunks)
+    return random.sample(list(all_data), num_candidates)
+
+# 在每个机器上计算小于等于候选的个数
+def count_less_equal(data_chunk, candidates):
+    return [np.sum(data_chunk <= candidate) for candidate in candidates]
+
+# 汇总所有机器的统计结果
+def aggregate_counts(counts_per_machine):
+    return np.sum(counts_per_machine, axis=0)
+
+def find_median_distributed(data, num_machines, num_candidates):
+    # 将数据分成若干块
+    data_chunks = split_data(data, num_machines)
+    
+    # 初始候选中位数
+    candidates = initial_candidates(data_chunks, num_candidates)
+    
+    # 目标中位数的位置
+    median_position = len(data) // 2
+    
+    while True:
+        # 在每个机器上计算小于等于候选的个数
+        counts_per_machine = [count_less_equal(chunk, candidates) for chunk in data_chunks]
+        
+        # 汇总所有机器的统计结果
+        total_counts = aggregate_counts(counts_per_machine)
+        
+        # 找到累计个数刚好超过中位数位置的候选
+        for i, count in enumerate(total_counts):
+            if count >= median_position:
+                current_median = candidates[i]
+                break
+        
+        # 检查是否满足中位数条件
+        if total_counts[i] == median_position:
+            return current_median
+        
+        # 更新候选范围
+        if total_counts[i] < median_position:
+            lower_bound = candidates[i]
+        else:
+            upper_bound = candidates[i]
+        
+        # 生成新的候选
+        candidates = [random.uniform(lower_bound, upper_bound) for _ in range(num_candidates)]
+
+# 示例数据
+data = np.random.randint(0, 100, size=1000)
+num_machines = 10
+num_candidates = 5
+
+# 求解中位数
+median = find_median_distributed(data, num_machines, num_candidates)
+print("Estimated median is:", median)
+'''