feat(work): add Set Matrix Zeroes solution

apps/docs/content/(array)/48-rotate-image.mdx

@@ -0,0 +1,37 @@
+---
+title: '48. Rotate Image'
+description: You are given an n x n 2D matrix representing an image, rotate the image by 90 degrees (clockwise)
+sidebar:
+  label: 'Rotate Image'
+  badge: 'Medium'
+---
+
+<Badge variant="accent">Matrix Index Math</Badge>
+
+### Example 1:
+- Input: `matrix = [[1,2,3],[4,5,6],[7,8,9]]`
+- Output: `[[7,4,1],[8,5,2],[9,6,3]]`
+
+### Example 2:
+- Input: `matrix = [[5,1,9,11],[2,4,8,10],[13,3,6,7],[15,14,12,16]]`
+- Output: `[[15,13,2,5],[14,3,4,1],[12,6,8,9],[16,7,10,11]]`
+
+### Constraints:
+
+- `n == matrix.length == matrix[i].length`
+- `1 <= n <= 20`
+- `-1000 <= matrix[i][j] <= 1000`
+
+## Solution
+
+```py
+class Solution:
+    def rotate(self, matrix: List[List[int]]) -> None:
+        n = len(matrix)
+        for r in range(n):
+            for c in range(r + 1, n):
+                matrix[r][c], matrix[c][r] = matrix[c][r], matrix[r][c]
+
+        for r in range(n):
+            matrix[r].reverse()
+```

apps/docs/content/(array)/54-spiral-matrix.mdx

@@ -0,0 +1,59 @@
+---
+title: '54. Spiral Matrix'
+description: Given an m x n matrix, return all elements of the matrix in spiral order
+sidebar:
+  label: 'Spiral Matrix'
+  badge: 'Medium'
+---
+
+<Badge variant="accent">Matrix Index Math</Badge>
+
+### Example 1:
+- Input: `matrix = [[1,2,3],[4,5,6],[7,8,9]]`
+- Output: `[1,2,3,6,9,8,7,4,5]`
+
+### Example 2:
+- Input: `matrix = [[1,2,3,4],[5,6,7,8],[9,10,11,12]]`
+- Output: `[1,2,3,4,8,12,11,10,9,5,6,7]`
+
+### Constraints:
+
+- `m == matrix.length`
+- `n == matrix[i].length`
+- `1 <= m, n <= 10`
+- `-100 <= matrix[i][j] <= 100`
+
+## Solution
+
+```py
+class Solution:
+    def spiralOrder(self, matrix: List[List[int]]) -> List[int]:
+        res = []
+        top, bottom = 0, len(matrix) - 1
+        left, right = 0, len(matrix[0]) - 1
+
+        while top <= bottom and left <= right:
+            # 1. Top Row
+            for c in range(left, right + 1):
+                res.append(matrix[top][c])
+            top += 1
+
+            # 2. Right Column
+            for r in range(top, bottom + 1):
+                res.append(matrix[r][right])
+            right -= 1
+
+            # 3. Bottom Row
+            if top <= bottom:
+                for c in range(right, left - 1, -1):
+                    res.append(matrix[bottom][c])
+                bottom -= 1
+
+            # 4. Left Column
+            if left <= right:
+                for r in range(bottom, top - 1, -1):
+                    res.append(matrix[r][left])
+                left += 1
+
+        return res
+```

apps/docs/content/(array)/73-set-matrix-zeroes.mdx

@@ -0,0 +1,67 @@
+---
+title: '73. Set Matrix Zeroes'
+description: Given an m x n integer matrix matrix, if an element is 0, set its entire row and column to 0's
+sidebar:
+  label: 'Set Matrix Zeroes'
+  badge: 'Medium'
+---
+
+<Badge variant="accent">Matrix Index Math</Badge>
+
+::::warning
+You must do it in place.
+::::
+
+### Example 1:
+- Input: `matrix = [[1,1,1],[1,0,1],[1,1,1]]`
+- Output: `[[1,0,1],[0,0,0],[1,0,1]]`
+
+### Example 2:
+- Input: `matrix = [[0,1,2,0],[3,4,5,2],[1,3,1,5]]`
+- Output: `[[0,0,0,0],[0,4,5,0],[0,3,1,0]]`
+
+### Constraints:
+
+- `m == matrix.length`
+- `n == matrix[0].length`
+- `1 <= m, n <= 200`
+- `-2^31 <= matrix[i][j] <= 2^31 - 1`
+- A straightforward solution using O(mn) space is probably a bad idea.
+- A simple improvement uses O(m + n) space, but still not the best solution.
+- Could you devise a constant space solution?
+
+## Solution
+
+```py
+class Solution:
+    def setZeroes(self, matrix: List[List[int]]) -> None:
+        """
+        Do not return anything, modify matrix in-place instead.
+        """
+        m, n = len(matrix), len(matrix[0])
+
+        # 1. remember if row 0 or column 0 have their own zeros
+        row0_zero = any(matrix[0][c] == 0 for c in range(n))
+        col0_zero = any(matrix[r][0] == 0 for r in range(m))
+
+        # 2. use row 0 and column 0 as marker lists
+        for r in range(1, m):
+            for c in range(1, n):
+                if matrix[r][c] == 0:
+                    matrix[r][0] = 0
+                    matrix[0][c] = 0
+
+        # 3. zero the inner cells from the markers
+        for r in range(1, m):
+            for c in range(1, n):
+                if matrix[r][0] == 0 or matrix[0][c] == 0:
+                    matrix[r][c] = 0
+
+        # 4. handle row 0 and column 0 last
+        if row0_zero:
+            for c in range(n):
+                matrix[0][c] = 0
+        if col0_zero:
+            for r in range(m):
+                matrix[r][0] = 0
+```

apps/docs/content/(linked-list)/2-add-two-numbers.mdx

@@ -0,0 +1,57 @@
+---
+title: '2. Add Two Numbers'
+description: You are given two non-empty linked lists representing two non-negative integers. The digits are stored in reverse order, and each of their nodes contains a single digit. Add the two numbers and return the sum as a linked list
+sidebar:
+  label: 'Add Two Numbers'
+  badge: 'Medium'
+---
+
+<Badge variant="accent">Hybrid Structures</Badge>
+
+### Example 1:
+- Input: `l1 = [2,4,3], l2 = [5,6,4]`
+- Output: `[7,0,8]`
+- Explanation: `342 + 465 = 807`.
+
+### Example 2:
+- Input: `l1 = [0], l2 = [0]`
+- Output: `[0]`
+
+### Example 3:
+- Input: `l1 = [9,9,9,9,9,9,9], l2 = [9,9,9,9]`
+- Output: `[8,9,9,9,0,0,0,1]`
+
+### Constraints:
+
+- The number of nodes in each linked list is in the range [1, 100].
+- `0 <= Node.val <= 9`
+- It is guaranteed that the list represents a number that does not have leading zeros.
+
+## Solution
+
+```py
+# Definition for singly-linked list.
+# class ListNode:
+#     def __init__(self, val=0, next=None):
+#         self.val = val
+#         self.next = next
+class Solution:
+    def addTwoNumbers(
+        self, l1: Optional[ListNode], l2: Optional[ListNode]
+    ) -> Optional[ListNode]:
+
+        dummy = ListNode()
+        carry = 0
+        curr = dummy
+        while l1 or l2 or carry:
+            s = (l1.val if l1 else 0) + (l2.val if l2 else 0) + carry
+            carry, val = divmod(s, 10)
+
+            curr.next = ListNode(val)
+            curr = curr.next
+
+            l1 = l1.next if l1 else None
+            l2 = l2.next if l2 else None
+
+        return dummy.next
+```

work/1/Medium/Array/48.rotate-image.py

@@ -0,0 +1,47 @@
+"""
+48. Rotate Image
+Difficulty: Medium
+https://leetcode.com/problems/rotate-image/
+
+──────────────────────────────────────────────────
+
+You are given an n x n 2D matrix representing an image, rotate the
+image by 90 degrees (clockwise).
+
+You have to rotate the image in-place, which means you have to modify
+the input 2D matrix directly. DO NOT allocate another 2D matrix and do
+the rotation.
+
+
+
+Example 1:
+
+Input: matrix = [[1,2,3],[4,5,6],[7,8,9]]
+Output: [[7,4,1],[8,5,2],[9,6,3]]
+
+Example 2:
+
+Input: matrix = [[5,1,9,11],[2,4,8,10],[13,3,6,7],[15,14,12,16]]
+Output: [[15,13,2,5],[14,3,4,1],[12,6,8,9],[16,7,10,11]]
+
+
+
+Constraints:
+
+        • n == matrix.length == matrix[i].length
+
+        • 1 <= n <= 20
+
+        • -1000 <= matrix[i][j] <= 1000
+"""
+
+
+class Solution:
+    def rotate(self, matrix: List[List[int]]) -> None:
+        n = len(matrix)
+        for r in range(n):
+            for c in range(r + 1, n):
+                matrix[r][c], matrix[c][r] = matrix[c][r], matrix[r][c]
+
+        for r in range(n):
+            matrix[r].reverse()

work/1/Medium/Array/54.spiral-matrix.py

@@ -0,0 +1,66 @@
+"""
+54. Spiral Matrix
+Difficulty: Medium
+https://leetcode.com/problems/spiral-matrix/
+
+──────────────────────────────────────────────────
+
+Given an m x n matrix, return all elements of the matrix in spiral
+order.
+
+
+
+Example 1:
+
+Input: matrix = [[1,2,3],[4,5,6],[7,8,9]]
+Output: [1,2,3,6,9,8,7,4,5]
+
+Example 2:
+
+Input: matrix = [[1,2,3,4],[5,6,7,8],[9,10,11,12]]
+Output: [1,2,3,4,8,12,11,10,9,5,6,7]
+
+
+
+Constraints:
+
+        • m == matrix.length
+
+        • n == matrix[i].length
+
+        • 1 <= m, n <= 10
+
+        • -100 <= matrix[i][j] <= 100
+"""
+
+
+class Solution:
+    def spiralOrder(self, matrix: List[List[int]]) -> List[int]:
+        res = []
+        top, bottom = 0, len(matrix) - 1
+        left, right = 0, len(matrix[0]) - 1
+
+        while top <= bottom and left <= right:
+            # 1. Top Row
+            for c in range(left, right + 1):
+                res.append(matrix[top][c])
+            top += 1
+
+            # 2. Right Column
+            for r in range(top, bottom + 1):
+                res.append(matrix[r][right])
+            right -= 1
+
+            # 3. Bottom Row
+            if top <= bottom:
+                for c in range(right, left - 1, -1):
+                    res.append(matrix[bottom][c])
+                bottom -= 1
+
+            # 4. Left Column
+            if left <= right:
+                for r in range(bottom, top - 1, -1):
+                    res.append(matrix[r][left])
+                left += 1
+
+        return res

work/1/Medium/Array/73.set-matrix-zeroes.py

@@ -0,0 +1,81 @@
+"""
+73. Set Matrix Zeroes
+Difficulty: Medium
+https://leetcode.com/problems/set-matrix-zeroes/
+
+──────────────────────────────────────────────────
+
+Given an m x n integer matrix matrix, if an element is 0, set its
+entire row and column to 0's.
+
+You must do it in place.
+
+
+
+Example 1:
+
+Input: matrix = [[1,1,1],[1,0,1],[1,1,1]]
+Output: [[1,0,1],[0,0,0],[1,0,1]]
+
+Example 2:
+
+Input: matrix = [[0,1,2,0],[3,4,5,2],[1,3,1,5]]
+Output: [[0,0,0,0],[0,4,5,0],[0,3,1,0]]
+
+
+
+Constraints:
+
+        • m == matrix.length
+
+        • n == matrix[0].length
+
+        • 1 <= m, n <= 200
+
+        • -2^31 <= matrix[i][j] <= 2^31 - 1
+
+
+
+Follow up:
+
+• A straightforward solution using O(mn) space is probably a bad
+idea.
+
+• A simple improvement uses O(m + n) space, but still not the best
+solution.
+
+        • Could you devise a constant space solution?
+"""
+
+
+class Solution:
+    def setZeroes(self, matrix: List[List[int]]) -> None:
+        """
+        Do not return anything, modify matrix in-place instead.
+        """
+        m, n = len(matrix), len(matrix[0])
+
+        # 1. remember if row 0 or column 0 have their own zeros
+        row0_zero = any(matrix[0][c] == 0 for c in range(n))
+        col0_zero = any(matrix[r][0] == 0 for r in range(m))
+
+        # 2. use row 0 and column 0 as marker lists
+        for r in range(1, m):
+            for c in range(1, n):
+                if matrix[r][c] == 0:
+                    matrix[r][0] = 0
+                    matrix[0][c] = 0
+
+        # 3. zero the inner cells from the markers
+        for r in range(1, m):
+            for c in range(1, n):
+                if matrix[r][0] == 0 or matrix[0][c] == 0:
+                    matrix[r][c] = 0
+
+        # 4. handle row 0 and column 0 last
+        if row0_zero:
+            for c in range(n):
+                matrix[0][c] = 0
+        if col0_zero:
+            for r in range(m):
+                matrix[r][0] = 0

work/1/Medium/Linked List/2.add-two-numbers.py

@@ -53,9 +53,18 @@ class Solution:
     def addTwoNumbers(
         self, l1: Optional[ListNode], l2: Optional[ListNode]
     ) -> Optional[ListNode]:
-        head = ListNode()
+
+        dummy = ListNode()
         carry = 0
-        l1curr = head
+        curr = dummy
-        l2curr = head
+        while l1 or l2 or carry:
-        while head:
+            s = (l1.val if l1 else 0) + (l2.val if l2 else 0) + carry
-            l1.val + l2.val
+            carry, val = divmod(s, 10)
+
+            curr.next = ListNode(val)
+            curr = curr.next
+
+            l1 = l1.next if l1 else None
+            l2 = l2.next if l2 else None
+
+        return dummy.next

work/3/Medium/Array/49.group-anagrams.py

@@ -0,0 +1,66 @@
+"""
+49. Group Anagrams
+Difficulty: Medium
+https://leetcode.com/problems/group-anagrams/
+
+──────────────────────────────────────────────────
+
+Given an array of strings strs, group the anagrams together. You can
+return the answer in any order.
+
+
+
+Example 1:
+
+Input: strs = ["eat","tea","tan","ate","nat","bat"]
+
+Output: [["bat"],["nat","tan"],["ate","eat","tea"]]
+
+Explanation:
+
+        • There is no string in strs that can be rearranged to form "bat".
+
+• The strings "nat" and "tan" are anagrams as they can be rearranged
+to form each other.
+
+• The strings "ate", "eat", and "tea" are anagrams as they can be
+rearranged to form each other.
+
+Example 2:
+
+Input: strs = [""]
+
+Output: [[""]]
+
+Example 3:
+
+Input: strs = ["a"]
+
+Output: [["a"]]
+
+
+
+Constraints:
+
+        • 1 <= strs.length <= 10^4
+
+        • 0 <= strs[i].length <= 100
+
+        • strs[i] consists of lowercase English letters.
+"""
+
+from collections import defaultdict
+
+
+class Solution:
+    def groupAnagrams(self, strs: List[str]) -> List[List[str]]:
+        if not strs:
+            return strs
+        res = defaultdict(list)
+        for s in strs:
+            count = [0] * 26
+            for c in s:
+                count[ord(c) - ord("a")] += 1
+            res[tuple(count)].append(s)
+
+        return res.values()