Add 2453

CharryWu · CharryWu · commit 3b51c516efa5 · 2024-09-28T15:12:21.000-07:00
diff --git a/2024/amazon/minimize-sum-of-distance-to-warehouse.py b/2024/amazon/minimize-sum-of-distance-to-warehouse.py
@@ -0,0 +1,22 @@
+
+def minSumDistancesToWarehouses(nums):
+    nums.sort()
+    best_split = 0
+    max_diff = 0
+    for i in range(1, len(nums)):
+        if nums[i] - nums[i - 1] > max_diff:
+            best_split = i
+            max_diff = nums[i] - nums[i - 1]
+
+    first_half = nums[:best_split]
+    second_half = nums[best_split:]
+
+    first_centroid = round(sum(first_half) / len(first_half))
+    second_centroid = round(sum(second_half) / len(second_half))
+
+    total_dist = 0
+    for num in nums:
+        total_dist += min(abs(num - first_centroid), abs(num - second_centroid))
+    return total_dist
+
+print(minSumDistancesToWarehouses([0, 1, 2,2,2,2,4,4,8,9,9,10,10,11,13,14]))
diff --git a/2024/meta/Sep-screen-1.py b/2024/meta/Sep-screen-1.py
@@ -0,0 +1,147 @@
+#Question 1. Given a binary tree root node, write a function that returns the tree diameter
+#definition: diameter of a tree is the number of nodes on the longest path between any two nodes
+#example
+            1
+          /   \
+         2     3
+        /     / \
+       4     5   6
+                  \
+                   7
+
+
+            1
+             \
+              3
+             / \
+            5   6
+                  \
+                   7
+
+#ans = 6
+
+def solution(root):
+    res = 0
+
+    def dfs(node):
+        nonlocal res
+        if not node:
+            return 0
+        leftres = dfs(node.left)
+        rightres = dfs(node.right)
+        s = leftres + rightres + 1
+        res = max(res, s)
+
+        return 1+max(leftres, rightres)
+
+    dfs(root)
+    return res
+
+
+dfs(1): res = 1 + 2 + 3 = 6, => 1 + 3 = 4
+    - dfs(2): res = 1 + 1 + 0 = 2, => 2
+        - dfs(4) => 1 + 0 = 1, res = 1
+        - dfs(None) => 0
+
+    - dfs(3): res = 1 + 1 + 2 = 4, => 3
+        - dfs(5) => 1
+        - dfs(6) => 2
+            - dfs(7) => 1
+
+
+#Question 2. Given a matrix of integers print out its values along the diagonals that move in the top right to bottom left direction. Each diagonal goes down and to the left as shown in the example. There should be newlines between each diagonal.
+#example
+[[1,  2,  3,  4],
+ [5,  6,  7,  8],
+ [9, 10, 11, 12]]
+
+1  (0, 0) sum = 0
+2 5  (0, 1), (1, 0) sum = 1
+3 6 9 (0, 2), (1,1) (2, 0) = sum = 2
+4 7 10 sum = 4
+8 11  sum = 5
+12  = sum = 6
+
+
+
+3 6 9 (0, 2), (1,1) (2, 0) = sum = 2
+i, j
+0, 2
+1, 1
+2, 0
+
+
+for i in range(m):
+    for j in range(n):
+
+
+# for s in range(m+n):
+#     for i in range(m):
+#         for j in range():
+def solution(matrix):
+    rows, cols = len(matrix), len(matrix[0])
+
+    for col in range(cols):
+        i, j = 0, col
+
+        while i < rows and j >= 0:
+            print(matrix[i][j], end=' ')
+            i += 1
+            j -= 1
+
+
+    for row in range(1, rows):
+        i, j = row, cols-1
+
+        while i < rows and j >= 0:
+            print(matrix[i][j], end=' ')
+            i += 1 # same, move bottom left
+            j -= 1
+
+solution(
+    [[1,  2,  3,  4],
+    [5,  6,  7,  8],
+    [9, 10, 11, 12]]
+)
+
+rows = 3, cols = 4
+
+col = 0
+i, j = 0, 0
+print 1
+
+col = 1
+i, j = 0, 1
+print(2), i+=1 = 1, j -= 1, 0
+i, j = 1, 0
+print(5)
+
+
+col = 2
+i, j = 0, 2
+print(3),
+i, j = 1, 1
+print(6)
+i, j = 2, 0
+print(9)
+
+
+
+col = 3
+i, j = 0, 3
+print(4),
+i, j = 1, 2
+print(7)
+i, j = 3, 0
+print(10)
+
+
+row = 1
+i, j = 1, 3
+print(8),
+i, j = 2, 2
+print(11)
+
+row = 2
+i, j = 2, 3
+print(12),
diff --git a/2024/meta/system-design-prep.md b/2024/meta/system-design-prep.md
@@ -0,0 +1,31 @@
+How to answer in a system design interview?
+1. For a Read-Heavy System - Consider using a Cache.
+2. For a Write-Heavy System - Use Message Queues for async processing
+3. For a Low Latency Requirement - Consider using a Cache and CDN.
+4. Need Atomicity, Consistency, Isolation, Durability Compliant DB - Go for RDBMS/SQL Database.
+5. Have unstructured data - Go for NoSQL Database.
+6. Have Complex Data (Videos, Images, Files) - Go for Blob/Object storage.
+7. Complex Pre-computation - Use Message Queue & Cache.
+8. High-Volume Data Search - Consider search index, tries or search engine.
+9. Scaling SQL Database - Implement Database Sharding..google  и
+10. High AvaPilability, Performance, & Throughput - Use a Load Balancer.
+11. Global Data Delivery - Consider using a CDN.
+12. Graph Data (data with nodes, edges, and relationships) - Utilize Graph Database.
+13. Scaling Various Components - Implement Horizontal Scaling.
+14. High-Performing Database Queries - Use Database Indexes.. 1point 3acres
+15. Bulk Job Processing - Consider Batch Processing & Message Queues.
+16. Server Load Management & Preventing DOS Attacks- Use a Rate Limiter.
+17. Microservices Architecture - Use an API Gateway.
+18. For Single Point of Failure - Implement Redundancy.
+19. For Fault-Tolerance and Durability - Implement Data Replication.
+20. For User-to-User fast communication - Use Websockets..--
+21. Failure Detection in Distributed Systems - Implement a Heartbeat.
+22. Data Integrity - Use Checksum Algorithm.
+23. Efficient Server Scaling - Implement Consistent Hashing.. ----
+24. Decentralized Data Transfer - Consider Gossip Protocol.
+25. Location-Based Functionality - Use Quadtree, Geohash, etc.
+26. Avoid Specific Technology Names - Use generic terms.
+27. High Availability and Consistency Trade-Off - Eventual Consistency.
+28. For IP resolution & Domain Name Query - Mention DNS (Domain Name System).. From 1point 3acres bbs
+29. Handling Large Data in Network Requests - Implement Pagination..1point3acres
+30. Cache Eviction Policy - Preferred is LRU (Least Recently Used) Cache.
diff --git a/array-hashmap-counting/2453. Destroy Sequential Targets.py b/array-hashmap-counting/2453. Destroy Sequential Targets.py
@@ -0,0 +1,18 @@
+class Solution:
+    def destroyTargets(self, nums: List[int], space: int) -> int:
+        remainder_class = {} # remainder => (freq_counter, min_value)
+        maxval = 0
+        for num in nums:
+            div, mod = divmod(num, space)
+            if mod not in remainder_class:
+                remainder_class[mod] = (1, num)
+            else:
+                remainder_class[mod] = (remainder_class[mod][0]+1, min(remainder_class[mod][1], num))
+
+            maxval = max(maxval, remainder_class[mod][0])
+
+        res = float('inf')
+        for freq, minval in remainder_class.values():
+            if freq == maxval:
+                res = min(res, minval)
+        return res
