D. J.:

- Added the leetcode problem and solution for1329

Author: nobodyPerfecZ

README.md

@@ -281,6 +281,7 @@
 - [1143 Longest Common Subsequence](https://leetcode.com/problems/longest-common-subsequence/description/)
 - [1218 Longest Arithmetic Subsequence of Given Difference](https://leetcode.com/problems/longest-arithmetic-subsequence-of-given-difference/description/)
 - [1312 Minimum Insertion Steps to Make a String Palindrome](https://leetcode.com/problems/minimum-insertion-steps-to-make-a-string-palindrome/description/)
+- [1329 Sort the Matrix Diagonally](https://leetcode.com/problems/sort-the-matrix-diagonally/description/)
 - [1456 Maximum Number of Vowels in a Substring of Given Length](https://leetcode.com/problems/maximum-number-of-vowels-in-a-substring-of-given-length/description/)
 - [1534 Count Good Triplets](https://leetcode.com/problems/count-good-triplets/description/)
 - [1679 Max Number of K-Sum Pairs](https://leetcode.com/problems/max-number-of-k-sum-pairs/description/)

awesome_python_leetcode/_1329_sort_the_matrix_diagonally.py

@@ -0,0 +1,43 @@
+from typing import List
+
+
+class Solution:
+    """Base class for all LeetCode Problems."""
+
+    def diagonalSort(self, mat: List[List[int]]) -> List[List[int]]:
+        """
+        A matrix diagonal is a diagonal line of cells starting from some cell in either
+        the topmost row or leftmost column and going in the bottom-right direction until
+        reaching the matrix's end. For example, the matrix diagonal starting from
+        mat[2][0], where mat is a 6 x 3 matrix, includes cells mat[2][0], mat[3][1],
+        and mat[4][2].
+
+        Given an m x n matrix mat of integers, sort each matrix diagonal in ascending
+        order and return the resulting matrix.
+        """
+        # Collect diagonals
+        diag = {}
+        for i in range(len(mat)):
+            for j in range(len(mat[0])):
+                key = i - j
+                if key not in diag:
+                    diag[key] = []
+                diag[key].append(mat[i][j])
+
+        # Sort in decreasing / increasing order for each diagonal
+        diag = dict(
+            zip(
+                diag.keys(),
+                map(lambda key: sorted(diag[key]), diag.keys()),
+                strict=False,
+            )
+        )
+
+        # Apply the results to the result matrix
+        result = [[0 for _ in range(len(mat[0]))] for _ in range(len(mat))]
+        for i in range(len(mat)):
+            for j in range(len(mat[0])):
+                key = i - j
+                result[i][j] = diag[key].pop(0)
+
+        return result

tests/test_1329_sort_the_matrix_diagonally.py

@@ -0,0 +1,36 @@
+from typing import List
+
+import pytest
+
+from awesome_python_leetcode._1329_sort_the_matrix_diagonally import Solution
+
+
+@pytest.mark.parametrize(
+    argnames=["mat", "expected"],
+    argvalues=[
+        (
+            [[3, 3, 1, 1], [2, 2, 1, 2], [1, 1, 1, 2]],
+            [[1, 1, 1, 1], [1, 2, 2, 2], [1, 2, 3, 3]],
+        ),
+        (
+            [
+                [11, 25, 66, 1, 69, 7],
+                [23, 55, 17, 45, 15, 52],
+                [75, 31, 36, 44, 58, 8],
+                [22, 27, 33, 25, 68, 4],
+                [84, 28, 14, 11, 5, 50],
+            ],
+            [
+                [5, 17, 4, 1, 52, 7],
+                [11, 11, 25, 45, 8, 69],
+                [14, 23, 25, 44, 58, 15],
+                [22, 27, 31, 36, 50, 66],
+                [84, 28, 75, 33, 55, 68],
+            ],
+        ),
+    ],
+)
+def test_func(mat: List[List[int]], expected: List[List[int]]):
+    """Tests the solution of a LeetCode problem."""
+    sorted_mat = Solution().diagonalSort(mat)
+    assert sorted_mat == expected