D. J.:

- Added the leetcode problem and solution for 1035 and 1312

Author: nobodyPerfecZ

README.md

@@ -232,8 +232,10 @@ This repository contains awesome LeetCode problems and solutions written in Pyth
 - [918 Maximum Sum Circular Subarray](https://leetcode.com/problems/maximum-sum-circular-subarray/description/)
 - [931 Minimum Falling Path Sum](https://leetcode.com/problems/minimum-falling-path-sum/description/)
 - [983 Minimum Cost for Tickets](https://leetcode.com/problems/minimum-cost-for-tickets/description/)
+- [1035 Uncrossed Lines](https://leetcode.com/problems/uncrossed-lines/description/)
 - [1137 N-th Tribonacci Number](https://leetcode.com/problems/n-th-tribonacci-number/description/)
 - [1143 Longest Common Subsequence](https://leetcode.com/problems/longest-common-subsequence/description/)
+- [1312 Minimum Insertion Steps to Make a String Palindrome](https://leetcode.com/problems/minimum-insertion-steps-to-make-a-string-palindrome/description/)
 - [1534 Count Good Triplets](https://leetcode.com/problems/count-good-triplets/description)
 - [1922 Count Good Numbers](https://leetcode.com/problems/count-good-numbers/description/)
 - [2140 Solving Questions With Brainpower](https://leetcode.com/problems/solving-questions-with-brainpower/description/)

awesome_python_leetcode/_1035_uncrossed_lines.py

@@ -0,0 +1,30 @@
+from typing import List
+
+
+class Solution:
+    """Base class for all LeetCode Problems."""
+
+    def maxUncrossedLines(self, nums1: List[int], nums2: List[int]) -> int:
+        """
+        You are given two integer arrays nums1 and nums2. We write the integers of
+        nums1 and nums2 (in the order they are given) on two separate horizontal lines.
+
+        We may draw connecting lines: a straight line connecting two numbers nums1[i]
+        and nums2[j] such that:
+        - nums1[i] == nums2[j], and
+        - the line we draw does not intersect any other connecting (non-horizontal)
+        line.
+
+        Note that a connecting line cannot intersect even at the endpoints (i.e., each
+        number can only belong to one connecting line).
+
+        Return the maximum number of connecting lines we can draw in this way.
+        """
+        dp = [[0 for _ in range(len(nums2) + 1)] for _ in range(len(nums1) + 1)]
+        for i in range(len(nums1) - 1, -1, -1):
+            for j in range(len(nums2) - 1, -1, -1):
+                if nums1[i] == nums2[j]:
+                    dp[i][j] = 1 + dp[i + 1][j + 1]
+                else:
+                    dp[i][j] = max(dp[i + 1][j], dp[i][j + 1])
+        return dp[0][0]

awesome_python_leetcode/_1312_minimum_insertion_steps_to_make_a_string_palindrome.py

@@ -0,0 +1,20 @@
+class Solution:
+    """Base class for all LeetCode Problems."""
+
+    def minInsertions(self, s: str) -> int:
+        """
+        Given a string s. In one step you can insert any character at any index of the
+        string.
+
+        Return the minimum number of steps to make s palindrome.
+
+        A Palindrome String is one that reads the same backward as well as forward.
+        """
+        dp = [[0 for _ in range(len(s) + 1)] for _ in range(len(s) + 1)]
+        for i in range(len(s) - 1, -1, -1):
+            for j in range(len(s) - 1, -1, -1):
+                if s[i] == s[len(s) - 1 - j]:
+                    dp[i][j] = 1 + dp[i + 1][j + 1]
+                else:
+                    dp[i][j] = max(dp[i + 1][j], dp[i][j + 1])
+        return len(s) - dp[0][0]

tests/test_1035_uncrossed_lines.py

@@ -0,0 +1,19 @@
+from typing import List
+
+import pytest
+
+from awesome_python_leetcode._1035_uncrossed_lines import Solution
+
+
+@pytest.mark.parametrize(
+    argnames=["nums1", "nums2", "expected"],
+    argvalues=[
+        ([1, 4, 2], [1, 2, 4], 2),
+        ([2, 5, 1, 2, 5], [10, 5, 2, 1, 5, 2], 3),
+        ([1, 3, 7, 1, 7, 5], [1, 9, 2, 5, 1], 2),
+    ],
+)
+def test_func(nums1: List[int], nums2: List[int], expected: int):
+    """Tests the solution of a LeetCode problem."""
+    max_crossed_lines = Solution().maxUncrossedLines(nums1, nums2)
+    assert max_crossed_lines == expected

tests/test_1312_minimum_insertion_steps_to_make_a_string_palindrome.py

@@ -0,0 +1,21 @@
+# flake8: noqa
+
+import pytest
+
+from awesome_python_leetcode._1312_minimum_insertion_steps_to_make_a_string_palindrome import (
+    Solution,
+)
+
+
+@pytest.mark.parametrize(
+    argnames=["s", "expected"],
+    argvalues=[
+        ("zzazz", 0),
+        ("mbadm", 2),
+        ("leetcode", 5),
+    ],
+)
+def test_func(s: str, expected: int):
+    """Tests the solution of a LeetCode problem."""
+    min_insertions = Solution().minInsertions(s)
+    assert min_insertions == expected