test: add more test cases

Author: wislertt

.amazonq/rules/test-case-enhancement.md

@@ -61,6 +61,7 @@ When user requests to enhance test cases for a problem, the assistant will:
 ### Coverage Requirements
 
 - **Minimum 10 test cases** per problem
+- **Total test cases after enhancement must exceed the threshold** used for detection (e.g., if threshold=10, final count must be >10)
 - **Edge cases**: 20-30% of total test cases
 - **Normal cases**: 50-60% of total test cases
 - **Corner cases**: 20-30% of total test cases
@@ -123,6 +124,7 @@ make p-lint PROBLEM={problem_name}
 ## Success Criteria
 
 - All tests pass with enhanced test cases
+- Total test cases exceed the threshold used for detection
 - Minimum 10 comprehensive test cases per problem
 - Original solution code preserved and working
 - JSON template updated for future regeneration

.templates/leetcode/json/diameter_of_binary_tree.json

@@ -50,7 +50,7 @@
                 "name": "test_diameter_of_binary_tree",
                 "signature": "(self, root_list: list[int | None], expected: int)",
                 "parametrize": "root_list, expected",
-                "test_cases": "[([1, 2, 3, 4, 5], 3), ([1, 2], 1), ([], 0), ([1], 0), ([1, 2, 3], 2), ([1, None, 2], 1)]",
+                "test_cases": "[([1, 2, 3, 4, 5], 3), ([1, 2], 1), ([], 0), ([1], 0), ([1, 2, 3], 2), ([1, None, 2], 1), ([1, 2, 3, 4, 5, None, None, 6, 7], 4), ([4, 2, 6, 1, 3, 5, 7], 4), ([1, 2, None, 3, None, 4], 3), ([1, 2, 3, None, None, 4, 5, None, None, 6, 7], 4), ([10, 5, 15, 3, 7, 12, 20], 4), ([1, None, 2, None, 3, None, 4], 3)]",
                 "body": "        result = run_diameter_of_binary_tree(Solution, root_list)\n        assert_diameter_of_binary_tree(result, expected)"
             }
         ]

.templates/leetcode/json/kth_smallest_element_in_a_bst.json

@@ -52,7 +52,7 @@
                 "name": "test_kth_smallest",
                 "signature": "(self, root_list: list[int | None], k: int, expected: int)",
                 "parametrize": "root_list, k, expected",
-                "test_cases": "[([3, 1, 4, None, 2], 1, 1), ([5, 3, 6, 2, 4, None, None, 1], 3, 3), ([1], 1, 1), ([2, 1, 3], 2, 2), ([4, 2, 6, 1, 3, 5, 7], 4, 4), ([1, None, 2], 2, 2)]",
+                "test_cases": "[([3, 1, 4, None, 2], 1, 1), ([5, 3, 6, 2, 4, None, None, 1], 3, 3), ([1], 1, 1), ([2, 1, 3], 2, 2), ([4, 2, 6, 1, 3, 5, 7], 4, 4), ([1, None, 2], 2, 2), ([5, 3, 6, 2, 4, None, None, 1], 1, 1), ([5, 3, 6, 2, 4, None, None, 1], 4, 4), ([10, 5, 15, 3, 7, 12, 20], 1, 3), ([10, 5, 15, 3, 7, 12, 20], 7, 20), ([1, None, 2, None, 3], 3, 3), ([3, 1, 4, None, 2], 4, 4)]",
                 "body": "        result = run_kth_smallest(Solution, root_list, k)\n        assert_kth_smallest(result, expected)"
             }
         ]

.templates/leetcode/json/lowest_common_ancestor_of_a_binary_search_tree.json

@@ -53,7 +53,7 @@
                 "name": "test_lowest_common_ancestor",
                 "signature": "(self, root_list: list[int | None], p_val: int, q_val: int, expected_val: int)",
                 "parametrize": "root_list, p_val, q_val, expected_val",
-                "test_cases": "[([6, 2, 8, 0, 4, 7, 9, None, None, 3, 5], 2, 8, 6), ([6, 2, 8, 0, 4, 7, 9, None, None, 3, 5], 2, 4, 2), ([2, 1], 2, 1, 2), ([2, 1], 1, 2, 2), ([6, 2, 8, 0, 4, 7, 9], 0, 4, 2), ([6, 2, 8, 0, 4, 7, 9], 7, 9, 8)]",
+                "test_cases": "[([6, 2, 8, 0, 4, 7, 9, None, None, 3, 5], 2, 8, 6), ([6, 2, 8, 0, 4, 7, 9, None, None, 3, 5], 2, 4, 2), ([2, 1], 2, 1, 2), ([2, 1], 1, 2, 2), ([6, 2, 8, 0, 4, 7, 9], 0, 4, 2), ([6, 2, 8, 0, 4, 7, 9], 7, 9, 8), ([5, 3, 6, 2, 4, None, None, 1], 1, 4, 3), ([10, 5, 15, 3, 7, 12, 20], 3, 7, 5), ([1, None, 2], 1, 2, 1), ([3, 1, 4, None, 2], 1, 2, 1), ([20, 8, 22, 4, 12, None, None, None, None, 10, 14], 10, 14, 12), ([50, 30, 70, 20, 40, 60, 80], 20, 40, 30)]",
                 "body": "        result = run_lowest_common_ancestor(Solution, root_list, p_val, q_val)\n        assert_lowest_common_ancestor(result, expected_val)"
             }
         ]

.templates/leetcode/json/lowest_common_ancestor_of_a_binary_tree.json

@@ -53,7 +53,7 @@
                 "name": "test_lowest_common_ancestor",
                 "signature": "(self, root_list: list[int | None], p_val: int, q_val: int, expected_val: int)",
                 "parametrize": "root_list, p_val, q_val, expected_val",
-                "test_cases": "[([3,5,1,6,2,0,8,None,None,7,4], 5, 1, 3), ([3,5,1,6,2,0,8,None,None,7,4], 5, 4, 5), ([1,2], 1, 2, 1), ([2,1], 2, 1, 2), ([3,5,1,6,2,0,8,None,None,7,4], 6, 7, 5), ([3,5,1,6,2,0,8,None,None,7,4], 0, 8, 1)]",
+                "test_cases": "[([3,5,1,6,2,0,8,None,None,7,4], 5, 1, 3), ([3,5,1,6,2,0,8,None,None,7,4], 5, 4, 5), ([1,2], 1, 2, 1), ([2,1], 2, 1, 2), ([3,5,1,6,2,0,8,None,None,7,4], 6, 7, 5), ([3,5,1,6,2,0,8,None,None,7,4], 0, 8, 1), ([1, None, 2, None, 3], 2, 3, 2), ([4, 2, 6, 1, 3, 5, 7], 1, 7, 4), ([10, 5, 15, 3, 7, None, 18], 3, 7, 5), ([1, 2, 3, 4, 5, 6, 7], 4, 5, 2), ([20, 8, 22, 4, 12, None, 25], 4, 12, 8), ([50, 30, 70, 20, 40, 60, 80], 20, 40, 30)]",
                 "body": "        result = run_lowest_common_ancestor(Solution, root_list, p_val, q_val)\n        assert_lowest_common_ancestor(result, expected_val)"
             }
         ]

.templates/leetcode/json/maximum_profit_in_job_scheduling.json

@@ -55,7 +55,7 @@
                 "name": "test_job_scheduling",
                 "signature": "(self, start_time: list[int], end_time: list[int], profit: list[int], expected: int)",
                 "parametrize": "start_time, end_time, profit, expected",
-                "test_cases": "[([1, 2, 3, 3], [3, 4, 5, 6], [50, 10, 40, 70], 120), ([1, 2, 3, 4, 6], [3, 5, 10, 6, 9], [20, 20, 100, 70, 60], 150), ([1, 1, 1], [2, 3, 4], [5, 6, 4], 6), ([1, 2], [2, 3], [100, 200], 300), ([6, 15, 7, 11, 1, 3, 16, 2], [19, 18, 19, 16, 10, 8, 19, 8], [2, 9, 1, 19, 5, 7, 3, 19], 41)]",
+                "test_cases": "[([1, 2, 3, 3], [3, 4, 5, 6], [50, 10, 40, 70], 120), ([1, 2, 3, 4, 6], [3, 5, 10, 6, 9], [20, 20, 100, 70, 60], 150), ([1, 1, 1], [2, 3, 4], [5, 6, 4], 6), ([1, 2], [2, 3], [100, 200], 300), ([6, 15, 7, 11, 1, 3, 16, 2], [19, 18, 19, 16, 10, 8, 19, 8], [2, 9, 1, 19, 5, 7, 3, 19], 41), ([1], [2], [100], 100), ([1, 2, 3], [2, 3, 4], [1, 1, 1], 3), ([1, 3, 6, 7, 8, 12], [4, 5, 10, 11, 12, 16], [20, 20, 100, 70, 60, 120], 240), ([1, 4, 6], [3, 5, 7], [50, 10, 40], 100), ([1, 2, 3, 4, 5], [6, 7, 8, 9, 10], [10, 20, 30, 40, 50], 50), ([5, 4, 3, 2, 1], [6, 5, 4, 3, 2], [1, 2, 3, 4, 5], 15), ([1, 1000000000], [2, 1000000001], [1, 10000], 10001)]",
                 "body": "        result = run_job_scheduling(Solution, start_time, end_time, profit)\n        assert_job_scheduling(result, expected)"
             }
         ]

.templates/leetcode/json/merge_intervals.json

@@ -55,7 +55,7 @@
                 "name": "test_merge",
                 "signature": "(self, intervals: list[list[int]], expected: list[list[int]])",
                 "parametrize": "intervals, expected",
-                "test_cases": "[([[1,3],[2,6],[8,10],[15,18]], [[1,6],[8,10],[15,18]]), ([[1,4],[4,5]], [[1,5]]), ([[4,7],[1,4]], [[1,7]]), ([[1,3]], [[1,3]]), ([[1,4],[2,3]], [[1,4]]), ([[1,2],[3,4],[5,6]], [[1,2],[3,4],[5,6]])]",
+                "test_cases": "[([[1,3],[2,6],[8,10],[15,18]], [[1,6],[8,10],[15,18]]), ([[1,4],[4,5]], [[1,5]]), ([[4,7],[1,4]], [[1,7]]), ([[1,3]], [[1,3]]), ([[1,4],[2,3]], [[1,4]]), ([[1,2],[3,4],[5,6]], [[1,2],[3,4],[5,6]]), ([[0,0]], [[0,0]]), ([[1,10],[2,3],[4,5],[6,7],[8,9]], [[1,10]]), ([[1,3],[2,6],[8,10],[9,12],[15,18]], [[1,6],[8,12],[15,18]]), ([[2,3],[4,5],[6,7],[8,9],[1,10]], [[1,10]]), ([[1,4],[0,4]], [[0,4]]), ([[1,4],[0,0],[3,5]], [[0,0],[1,5]])]",
                 "body": "        result = run_merge(Solution, intervals)\n        assert_merge(result, expected)"
             }
         ]

.templates/leetcode/json/reverse_linked_list_ii.json

@@ -50,7 +50,7 @@
                 "name": "test_reverse_between",
                 "signature": "(self, head_list: list[int], left: int, right: int, expected_list: list[int])",
                 "parametrize": "head_list, left, right, expected_list",
-                "test_cases": "[([1, 2, 3, 4, 5], 2, 4, [1, 4, 3, 2, 5]), ([5], 1, 1, [5]), ([1, 2], 1, 2, [2, 1]), ([1, 2, 3], 1, 3, [3, 2, 1]), ([1, 2, 3, 4, 5], 1, 5, [5, 4, 3, 2, 1]), ([1, 2, 3, 4, 5], 3, 3, [1, 2, 3, 4, 5])]",
+                "test_cases": "[([1, 2, 3, 4, 5], 2, 4, [1, 4, 3, 2, 5]), ([5], 1, 1, [5]), ([1, 2], 1, 2, [2, 1]), ([1, 2, 3], 1, 3, [3, 2, 1]), ([1, 2, 3, 4, 5], 1, 5, [5, 4, 3, 2, 1]), ([1, 2, 3, 4, 5], 3, 3, [1, 2, 3, 4, 5]), ([1, 2, 3, 4], 2, 3, [1, 3, 2, 4]), ([1, 2, 3, 4, 5, 6], 3, 5, [1, 2, 5, 4, 3, 6]), ([10], 1, 1, [10]), ([1, 2, 3, 4, 5, 6, 7], 1, 7, [7, 6, 5, 4, 3, 2, 1]), ([3, 5], 1, 1, [3, 5]), ([7, 9, 2, 10, 1, 8, 6], 4, 6, [7, 9, 2, 8, 1, 10, 6])]",
                 "body": "        result = run_reverse_between(Solution, head_list, left, right)\n        assert_reverse_between(result, expected_list)"
             }
         ]

.templates/leetcode/json/task_scheduler.json

@@ -55,7 +55,7 @@
                 "name": "test_least_interval",
                 "signature": "(self, tasks: list[str], n: int, expected: int)",
                 "parametrize": "tasks, n, expected",
-                "test_cases": "[(['A', 'A', 'A', 'B', 'B', 'B'], 2, 8), (['A', 'C', 'A', 'B', 'D', 'B'], 1, 6), (['A', 'A', 'A', 'B', 'B', 'B'], 3, 10), (['A'], 0, 1), (['A', 'A'], 1, 3), (['A', 'B'], 0, 2)]",
+                "test_cases": "[(['A', 'A', 'A', 'B', 'B', 'B'], 2, 8), (['A', 'C', 'A', 'B', 'D', 'B'], 1, 6), (['A', 'A', 'A', 'B', 'B', 'B'], 3, 10), (['A'], 0, 1), (['A', 'A'], 1, 3), (['A', 'B'], 0, 2), (['A', 'A', 'A'], 0, 3), (['A', 'B', 'C', 'D', 'E', 'F'], 2, 6), (['A', 'A', 'A', 'A', 'A', 'A', 'B', 'C', 'D', 'E', 'F', 'G'], 2, 16), (['A', 'A', 'B', 'B'], 2, 5), (['A', 'B', 'A', 'B'], 1, 4), (['A', 'A', 'A', 'A'], 3, 13)]",
                 "body": "        result = run_least_interval(Solution, tasks, n)\n        assert_least_interval(result, expected)"
             }
         ]

.templates/leetcode/json/three_sum.json

@@ -55,7 +55,7 @@
                 "name": "test_three_sum",
                 "signature": "(self, nums: list[int], expected: list[list[int]])",
                 "parametrize": "nums, expected",
-                "test_cases": "[([-1, 0, 1, 2, -1, -4], [[-1, -1, 2], [-1, 0, 1]]), ([0, 1, 1], []), ([0, 0, 0], [[0, 0, 0]]), ([-1, 0, 1], [[-1, 0, 1]]), ([1, 2, -2, -1], []), ([-2, 0, 1, 1, 2], [[-2, 0, 2], [-2, 1, 1]])]",
+                "test_cases": "[([-1, 0, 1, 2, -1, -4], [[-1, -1, 2], [-1, 0, 1]]), ([0, 1, 1], []), ([0, 0, 0], [[0, 0, 0]]), ([-1, 0, 1], [[-1, 0, 1]]), ([1, 2, -2, -1], []), ([-2, 0, 1, 1, 2], [[-2, 0, 2], [-2, 1, 1]]), ([1, -1, -1, 0], [[-1, 0, 1]]), ([-4, -2, -2, -2, 0, 1, 2, 2, 2, 3, 3, 4, 4, 6, 6], [[-4, -2, 6], [-4, 0, 4], [-4, 1, 3], [-4, 2, 2], [-2, -2, 4], [-2, 0, 2]]), ([3, 0, -2, -1, 1, 2], [[-2, -1, 3], [-2, 0, 2], [-1, 0, 1]]), ([0, 0, 0, 0], [[0, 0, 0]]), ([-1, -1, 2], [[-1, -1, 2]]), ([1, 1, -2], [[-2, 1, 1]])]",
                 "body": "        result = run_three_sum(Solution, nums)\n        assert_three_sum(result, expected)"
             }
         ]