Added tests 141-189

ThanhNIT · javadev · commit 4d6b1f405634 · 2025-09-07T11:30:17.000+03:00
diff --git a/src/main/python/g0101_0200/s0141_linked_list_cycle/Solution0141.py b/src/main/python/g0101_0200/s0141_linked_list_cycle/Solution0141.py
@@ -2,6 +2,12 @@
 # #Data_Structure_I_Day_7_Linked_List #Udemy_Linked_List #Top_Interview_150_Linked_List
 # #Big_O_Time_O(N)_Space_O(1) #2025_07_25_Time_44_ms_(80.06%)_Space_19.98_MB_(29.66%)
 
+from typing import Optional
+class ListNode:
+    def __init__(self, x):
+        self.val = x
+        self.next = None
+
 # Definition for singly-linked list.
 # class ListNode:
 #     def __init__(self, x):
diff --git a/src/main/python/g0101_0200/s0141_linked_list_cycle/Solution0141_test.py b/src/main/python/g0101_0200/s0141_linked_list_cycle/Solution0141_test.py
@@ -0,0 +1,28 @@
+import unittest
+from Solution0141 import Solution, ListNode
+
+def build_list_with_cycle(values, cycle_pos):
+    if not values:
+        return None
+    
+    nodes = [ListNode(val) for val in values]
+    for i in range(len(nodes) - 1):
+        nodes[i].next = nodes[i + 1]
+    
+    if cycle_pos >= 0 and cycle_pos < len(nodes):
+        nodes[-1].next = nodes[cycle_pos]
+    
+    return nodes[0]
+
+class SolutionTest(unittest.TestCase):
+    def test_hasCycle(self):
+        head = build_list_with_cycle([3, 2, 0, -4], 1)
+        self.assertTrue(Solution().hasCycle(head))
+
+    def test_hasCycle2(self):
+        head = build_list_with_cycle([1, 2], 0)
+        self.assertTrue(Solution().hasCycle(head))
+
+    def test_hasCycle3(self):
+        head = build_list_with_cycle([1], -1)
+        self.assertFalse(Solution().hasCycle(head))
diff --git a/src/main/python/g0101_0200/s0142_linked_list_cycle_ii/Solution0142.py b/src/main/python/g0101_0200/s0142_linked_list_cycle_ii/Solution0142.py
@@ -2,6 +2,12 @@
 # #Data_Structure_II_Day_10_Linked_List #Level_1_Day_4_Linked_List #Udemy_Linked_List
 # #Big_O_Time_O(N)_Space_O(1) #2025_07_25_Time_38_ms_(94.15%)_Space_19.60_MB_(79.86%)
 
+from typing import Optional
+class ListNode:
+    def __init__(self, x):
+        self.val = x
+        self.next = None
+
 # Definition for singly-linked list.
 # class ListNode:
 #     def __init__(self, x):
diff --git a/src/main/python/g0101_0200/s0142_linked_list_cycle_ii/Solution0142_test.py b/src/main/python/g0101_0200/s0142_linked_list_cycle_ii/Solution0142_test.py
@@ -0,0 +1,31 @@
+import unittest
+from Solution0142 import Solution, ListNode
+
+def build_list_with_cycle(values, cycle_pos):
+    if not values:
+        return None
+    
+    nodes = [ListNode(val) for val in values]
+    for i in range(len(nodes) - 1):
+        nodes[i].next = nodes[i + 1]
+    
+    if cycle_pos >= 0 and cycle_pos < len(nodes):
+        nodes[-1].next = nodes[cycle_pos]
+    
+    return nodes[0]
+
+class SolutionTest(unittest.TestCase):
+    def test_detectCycle(self):
+        head = build_list_with_cycle([3, 2, 0, -4], 1)
+        result = Solution().detectCycle(head)
+        self.assertEqual(result.val, 2)
+
+    def test_detectCycle2(self):
+        head = build_list_with_cycle([1, 2], 0)
+        result = Solution().detectCycle(head)
+        self.assertEqual(result.val, 1)
+
+    def test_detectCycle3(self):
+        head = build_list_with_cycle([1], -1)
+        result = Solution().detectCycle(head)
+        self.assertIsNone(result)
diff --git a/src/main/python/g0101_0200/s0146_lru_cache/LRUCache_test.py b/src/main/python/g0101_0200/s0146_lru_cache/LRUCache_test.py
@@ -0,0 +1,32 @@
+import unittest
+from LRUCache import LRUCache
+
+class LRUCacheTest(unittest.TestCase):
+    def test_lruCache(self):
+        lru = LRUCache(2)
+        lru.put(1, 1)
+        lru.put(2, 2)
+        self.assertEqual(lru.get(1), 1)
+        lru.put(3, 3)
+        self.assertEqual(lru.get(2), -1)
+        lru.put(4, 4)
+        self.assertEqual(lru.get(1), -1)
+        self.assertEqual(lru.get(3), 3)
+        self.assertEqual(lru.get(4), 4)
+
+    def test_lruCache2(self):
+        lru = LRUCache(1)
+        lru.put(2, 1)
+        self.assertEqual(lru.get(2), 1)
+
+    def test_lruCache3(self):
+        lru = LRUCache(2)
+        lru.put(1, 0)
+        lru.put(2, 2)
+        self.assertEqual(lru.get(1), 0)
+        lru.put(3, 3)
+        self.assertEqual(lru.get(2), -1)
+        lru.put(4, 4)
+        self.assertEqual(lru.get(1), -1)
+        self.assertEqual(lru.get(3), 3)
+        self.assertEqual(lru.get(4), 4)
diff --git a/src/main/python/g0101_0200/s0148_sort_list/Solution0148.py b/src/main/python/g0101_0200/s0148_sort_list/Solution0148.py
@@ -2,6 +2,13 @@
 # #Divide_and_Conquer #Merge_Sort #Level_2_Day_4_Linked_List #Top_Interview_150_Divide_and_Conquer
 # #Big_O_Time_O(log(N))_Space_O(log(N)) #2025_07_25_Time_186_ms_(43.67%)_Space_32.96_MB_(41.09%)
 
+from typing import Optional
+
+class ListNode:
+    def __init__(self, val=0, next=None):
+        self.val = val
+        self.next = next
+
 # Definition for singly-linked list.
 # class ListNode:
 #     def __init__(self, val=0, next=None):
diff --git a/src/main/python/g0101_0200/s0148_sort_list/Solution0148_test.py b/src/main/python/g0101_0200/s0148_sort_list/Solution0148_test.py
@@ -0,0 +1,34 @@
+import unittest
+from Solution0148 import Solution, ListNode
+
+def from_list(values):
+    dummy = ListNode(0)
+    curr = dummy
+    for v in values:
+        curr.next = ListNode(v)
+        curr = curr.next
+    return dummy.next
+
+def to_list(head):
+    result = []
+    curr = head
+    while curr is not None:
+        result.append(curr.val)
+        curr = curr.next
+    return result
+
+class SolutionTest(unittest.TestCase):
+    def test_sortList(self):
+        head = from_list([4, 2, 1, 3])
+        result = Solution().sortList(head)
+        self.assertEqual(to_list(result), [1, 2, 3, 4])
+
+    def test_sortList2(self):
+        head = from_list([-1, 5, 3, 4, 0])
+        result = Solution().sortList(head)
+        self.assertEqual(to_list(result), [-1, 0, 3, 4, 5])
+
+    def test_sortList3(self):
+        head = from_list([])
+        result = Solution().sortList(head)
+        self.assertEqual(to_list(result), [])
diff --git a/src/main/python/g0101_0200/s0152_maximum_product_subarray/Solution0152.py b/src/main/python/g0101_0200/s0152_maximum_product_subarray/Solution0152.py
@@ -2,6 +2,8 @@
 # #Dynamic_Programming_I_Day_6 #Level_2_Day_13_Dynamic_Programming #Udemy_Dynamic_Programming
 # #Big_O_Time_O(N)_Space_O(1) #2025_07_25_Time_3_ms_(98.51%)_Space_18.56_MB_(15.01%)
 
+from typing import List
+
 class Solution:
     def maxProduct(self, nums: List[int]) -> int:
         ans = float('-inf')
diff --git a/src/main/python/g0101_0200/s0152_maximum_product_subarray/Solution0152_test.py b/src/main/python/g0101_0200/s0152_maximum_product_subarray/Solution0152_test.py
@@ -0,0 +1,15 @@
+import unittest
+from Solution0152 import Solution
+
+class SolutionTest(unittest.TestCase):
+    def test_maxProduct(self):
+        self.assertEqual(Solution().maxProduct([2,3,-2,4]), 6)
+
+    def test_maxProduct2(self):
+        self.assertEqual(Solution().maxProduct([-2,0,-1]), 0)
+
+    def test_maxProduct3(self):
+        self.assertEqual(Solution().maxProduct([-2]), -2)
+
+    def test_maxProduct4(self):
+        self.assertEqual(Solution().maxProduct([-2,3,-4]), 24)
diff --git a/src/main/python/g0101_0200/s0153_find_minimum_in_rotated_sorted_array/Solution0153.py b/src/main/python/g0101_0200/s0153_find_minimum_in_rotated_sorted_array/Solution0153.py
@@ -2,6 +2,8 @@
 # #Binary_Search_I_Day_12 #Udemy_Binary_Search #Top_Interview_150_Binary_Search
 # #Big_O_Time_O(log_N)_Space_O(log_N) #2025_07_25_Time_0_ms_(100.00%)_Space_18.07_MB_(50.37%)
 
+from typing import List
+
 class Solution:
     def findMinUtil(self, nums: List[int], l: int, r: int) -> int:
         if l == r:
diff --git a/src/main/python/g0101_0200/s0153_find_minimum_in_rotated_sorted_array/Solution0153_test.py b/src/main/python/g0101_0200/s0153_find_minimum_in_rotated_sorted_array/Solution0153_test.py
@@ -0,0 +1,15 @@
+import unittest
+from Solution0153 import Solution
+
+class SolutionTest(unittest.TestCase):
+    def test_findMin(self):
+        self.assertEqual(Solution().findMin([3,4,5,1,2]), 1)
+
+    def test_findMin2(self):
+        self.assertEqual(Solution().findMin([4,5,6,7,0,1,2]), 0)
+
+    def test_findMin3(self):
+        self.assertEqual(Solution().findMin([11,13,15,17]), 11)
+
+    def test_findMin4(self):
+        self.assertEqual(Solution().findMin([1]), 1)
diff --git a/src/main/python/g0101_0200/s0155_min_stack/MinStack_test.py b/src/main/python/g0101_0200/s0155_min_stack/MinStack_test.py
@@ -0,0 +1,32 @@
+import unittest
+from MinStack import MinStack
+
+class MinStackTest(unittest.TestCase):
+    def test_minStack(self):
+        minStack = MinStack()
+        minStack.push(-2)
+        minStack.push(0)
+        minStack.push(-3)
+        self.assertEqual(minStack.getMin(), -3)
+        minStack.pop()
+        self.assertEqual(minStack.top(), 0)
+        self.assertEqual(minStack.getMin(), -2)
+
+    def test_minStack2(self):
+        minStack = MinStack()
+        minStack.push(0)
+        minStack.push(1)
+        minStack.push(0)
+        self.assertEqual(minStack.getMin(), 0)
+        minStack.pop()
+        self.assertEqual(minStack.getMin(), 0)
+
+    def test_minStack3(self):
+        minStack = MinStack()
+        minStack.push(1)
+        minStack.push(2)
+        self.assertEqual(minStack.top(), 2)
+        self.assertEqual(minStack.getMin(), 1)
+        minStack.pop()
+        self.assertEqual(minStack.getMin(), 1)
+        self.assertEqual(minStack.top(), 1)
diff --git a/src/main/python/g0101_0200/s0160_intersection_of_two_linked_lists/Solution0160.py b/src/main/python/g0101_0200/s0160_intersection_of_two_linked_lists/Solution0160.py
@@ -2,6 +2,13 @@
 # #Data_Structure_II_Day_11_Linked_List #Udemy_Linked_List #Big_O_Time_O(M+N)_Space_O(1)
 # #2025_07_25_Time_83_ms_(67.29%)_Space_27.89_MB_(40.40%)
 
+from typing import Optional
+
+class ListNode:
+    def __init__(self, x):
+        self.val = x
+        self.next = None
+
 # Definition for singly-linked list.
 # class ListNode:
 #     def __init__(self, x):
diff --git a/src/main/python/g0101_0200/s0160_intersection_of_two_linked_lists/Solution0160_test.py b/src/main/python/g0101_0200/s0160_intersection_of_two_linked_lists/Solution0160_test.py
@@ -0,0 +1,42 @@
+import unittest
+from Solution0160 import Solution, ListNode
+
+def build_intersecting_lists(listA, listB, skipA, skipB):
+    if not listA or not listB:
+        return None, None
+    
+    nodesA = [ListNode(val) for val in listA]
+    nodesB = [ListNode(val) for val in listB]
+    
+    # Connect listA
+    for i in range(len(nodesA) - 1):
+        nodesA[i].next = nodesA[i + 1]
+    
+    # Connect listB
+    for i in range(len(nodesB) - 1):
+        nodesB[i].next = nodesB[i + 1]
+    
+    # Create intersection
+    if skipA < len(nodesA) and skipB < len(nodesB):
+        nodesB[-1].next = nodesA[skipA]
+    
+    return nodesA[0], nodesB[0]
+
+class SolutionTest(unittest.TestCase):
+    def test_getIntersectionNode(self):
+        # listA = [4,1,8,4,5], listB = [5,6,1,8,4,5], skipA = 2, skipB = 3
+        headA, headB = build_intersecting_lists([4,1,8,4,5], [5,6,1,8,4,5], 2, 3)
+        result = Solution().getIntersectionNode(headA, headB)
+        self.assertEqual(result.val, 8)
+
+    def test_getIntersectionNode2(self):
+        # listA = [1,9,1,2,4], listB = [3,2,4], skipA = 3, skipB = 1
+        headA, headB = build_intersecting_lists([1,9,1,2,4], [3,2,4], 3, 1)
+        result = Solution().getIntersectionNode(headA, headB)
+        self.assertEqual(result.val, 2)
+
+    def test_getIntersectionNode3(self):
+        # listA = [2,6,4], listB = [1,5], skipA = 3, skipB = 2
+        headA, headB = build_intersecting_lists([2,6,4], [1,5], 3, 2)
+        result = Solution().getIntersectionNode(headA, headB)
+        self.assertIsNone(result)
diff --git a/src/main/python/g0101_0200/s0169_majority_element/Solution0169.py b/src/main/python/g0101_0200/s0169_majority_element/Solution0169.py
@@ -3,6 +3,8 @@
 # #Top_Interview_150_Array/String #Big_O_Time_O(n)_Space_O(1)
 # #2025_07_25_Time_7_ms_(56.72%)_Space_19.50_MB_(19.10%)
 
+from typing import List
+
 class Solution:
     def majorityElement(self, nums: List[int]) -> int:
         count = 1
diff --git a/src/main/python/g0101_0200/s0169_majority_element/Solution0169_test.py b/src/main/python/g0101_0200/s0169_majority_element/Solution0169_test.py
@@ -0,0 +1,15 @@
+import unittest
+from Solution0169 import Solution
+
+class SolutionTest(unittest.TestCase):
+    def test_majorityElement(self):
+        self.assertEqual(Solution().majorityElement([3,2,3]), 3)
+
+    def test_majorityElement2(self):
+        self.assertEqual(Solution().majorityElement([2,2,1,1,1,2,2]), 2)
+
+    def test_majorityElement3(self):
+        self.assertEqual(Solution().majorityElement([1]), 1)
+
+    def test_majorityElement4(self):
+        self.assertEqual(Solution().majorityElement([1,1,1,2,2,2,2]), 2)
diff --git a/src/main/python/g0101_0200/s0189_rotate_array/Solution0189.py b/src/main/python/g0101_0200/s0189_rotate_array/Solution0189.py
@@ -1,6 +1,7 @@
 # #Medium #Top_100_Liked_Questions #Top_Interview_Questions #Array #Math #Two_Pointers
 # #Algorithm_I_Day_2_Two_Pointers #Udemy_Arrays #Top_Interview_150_Array/String
 # #Big_O_Time_O(n)_Space_O(1) #2025_07_25_Time_3_ms_(74.65%)_Space_25.70_MB_(46.80%)
+from typing import List
 
 class Solution:
     def rotate(self, nums: List[int], k: int) -> None:
diff --git a/src/main/python/g0101_0200/s0189_rotate_array/Solution0189_test.py b/src/main/python/g0101_0200/s0189_rotate_array/Solution0189_test.py
@@ -0,0 +1,23 @@
+import unittest
+from Solution0189 import Solution
+
+class SolutionTest(unittest.TestCase):
+    def test_rotate(self):
+        nums = [1,2,3,4,5,6,7]
+        Solution().rotate(nums, 3)
+        self.assertEqual(nums, [5,6,7,1,2,3,4])
+
+    def test_rotate2(self):
+        nums = [-1,-100,3,99]
+        Solution().rotate(nums, 2)
+        self.assertEqual(nums, [3,99,-1,-100])
+
+    def test_rotate3(self):
+        nums = [1,2]
+        Solution().rotate(nums, 1)
+        self.assertEqual(nums, [2,1])
+
+    def test_rotate4(self):
+        nums = [1,2,3,4,5,6]
+        Solution().rotate(nums, 2)
+        self.assertEqual(nums, [5,6,1,2,3,4])
