LeetCode-in-Python · javadev · Jan 1, 2026 · Jan 1, 2026
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
@@ -3,30 +3,30 @@
 
 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)
+        min_stack = MinStack()
+        min_stack.push(-2)
+        min_stack.push(0)
+        min_stack.push(-3)
+        self.assertEqual(min_stack.getMin(), -3)
+        min_stack.pop()
+        self.assertEqual(min_stack.top(), 0)
+        self.assertEqual(min_stack.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)
+        min_stack = MinStack()
+        min_stack.push(0)
+        min_stack.push(1)
+        min_stack.push(0)
+        self.assertEqual(min_stack.getMin(), 0)
+        min_stack.pop()
+        self.assertEqual(min_stack.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)
+        min_stack = MinStack()
+        min_stack.push(1)
+        min_stack.push(2)
+        self.assertEqual(min_stack.top(), 2)
+        self.assertEqual(min_stack.getMin(), 1)
+        min_stack.pop()
+        self.assertEqual(min_stack.getMin(), 1)
+        self.assertEqual(min_stack.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
@@ -15,9 +15,9 @@ def __init__(self, x):
 #         self.val = x
 #         self.next = None
 class Solution:
-    def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:
-        node1, node2 = headA, headB
+    def getIntersectionNode(self, head_a: ListNode, head_b: ListNode) -> Optional[ListNode]:
+        node1, node2 = head_a, head_b
         while node1 != node2:
-            node1 = headB if node1 is None else node1.next
-            node2 = headA if node2 is None else node2.next
+            node1 = head_b if node1 is None else node1.next
+            node2 = head_a if node2 is None else node2.next
         return node1
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
@@ -1,42 +1,42 @@
 import unittest
 from Solution0160 import Solution, ListNode
 
-def build_intersecting_lists(listA, listB, skipA, skipB):
-    if not listA or not listB:
+def build_intersecting_lists(list_a, list_b, skip_a, skip_b):
+    if not list_a or not list_b:
         return None, None
 
-    nodesA = [ListNode(val) for val in listA]
-    nodesB = [ListNode(val) for val in listB]
+    nodes_a = [ListNode(val) for val in list_a]
+    nodes_b = [ListNode(val) for val in list_b]
 
     # Connect listA
-    for i in range(len(nodesA) - 1):
-        nodesA[i].next = nodesA[i + 1]
+    for i in range(len(nodes_a) - 1):
+        nodes_a[i].next = nodes_a[i + 1]
 
     # Connect listB
-    for i in range(len(nodesB) - 1):
-        nodesB[i].next = nodesB[i + 1]
+    for i in range(len(nodes_b) - 1):
+        nodes_b[i].next = nodes_b[i + 1]
 
     # Create intersection
-    if skipA < len(nodesA) and skipB < len(nodesB):
-        nodesB[-1].next = nodesA[skipA]
+    if skip_a < len(nodes_a) and skip_b < len(nodes_b):
+        nodes_b[-1].next = nodes_a[skip_a]
 
-    return nodesA[0], nodesB[0]
+    return nodes_a[0], nodes_b[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)
+        head_a, head_b = build_intersecting_lists([4,1,8,4,5], [5,6,1,8,4,5], 2, 3)
+        result = Solution().getIntersectionNode(head_a, head_b)
         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)
+        head_a, head_b = build_intersecting_lists([1,9,1,2,4], [3,2,4], 3, 1)
+        result = Solution().getIntersectionNode(head_a, head_b)
         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)
+        head_a, head_b = build_intersecting_lists([2,6,4], [1,5], 3, 2)
+        result = Solution().getIntersectionNode(head_a, head_b)
         self.assertIsNone(result)
diff --git a/src/main/python/g0101_0200/s0190_reverse_bits/Solution0190.py b/src/main/python/g0101_0200/s0190_reverse_bits/Solution0190.py
@@ -6,7 +6,7 @@ class Solution:
     def reverseBits(self, n: int) -> int:
         ret = 0
         # because there are 32 bits in total
-        for i in range(32):
+        for _ in range(32):
             ret = ret << 1
             # If the bit is 1 we OR it with 1, ie add 1
             if (n & 1) > 0:

diff --git a/src/main/python/g0201_0300/s0207_course_schedule/Solution0207.py b/src/main/python/g0201_0300/s0207_course_schedule/Solution0207.py
@@ -9,14 +9,14 @@ class Solution:
     GRAY = 1
     BLACK = 2
 
-    def canFinish(self, numCourses: int, prerequisites: List[List[int]]) -> bool:
-        adj = [[] for _ in range(numCourses)]
+    def canFinish(self, num_courses: int, prerequisites: List[List[int]]) -> bool:
+        adj = [[] for _ in range(num_courses)]
         for pre in prerequisites:
             adj[pre[1]].append(pre[0])
 
-        colors = [self.WHITE] * numCourses
+        colors = [self.WHITE] * num_courses
 
-        for i in range(numCourses):
+        for i in range(num_courses):
             if colors[i] == self.WHITE and adj[i] and self.hasCycle(adj, i, colors):
                 return False
         return True

diff --git a/src/main/python/g0201_0300/s0208_implement_trie_prefix_tree/Trie.py b/src/main/python/g0201_0300/s0208_implement_trie_prefix_tree/Trie.py
@@ -5,8 +5,8 @@
 
 class TrieNode:
     def __init__(self):
-        self.children = dict()
-        self.isWordEnd = False
+        self.children = {}
+        self.is_word_end = False
 
 class Trie:
     def __init__(self):
@@ -18,15 +18,15 @@ def insert(self, word: str) -> None:
             if c not in curr.children:
                 curr.children[c] = TrieNode()
             curr = curr.children[c]
-        curr.isWordEnd = True
+        curr.is_word_end = True
 
     def search(self, word: str) -> bool:
         curr = self.root
         for c in word:
             if c not in curr.children:
                 return False
             curr = curr.children[c]
-        return curr.isWordEnd 
+        return curr.is_word_end
 
     def startsWith(self, prefix: str) -> bool:
         curr = self.root

diff --git a/src/main/python/g0201_0300/s0210_course_schedule_ii/Solution0210.py b/src/main/python/g0201_0300/s0210_course_schedule_ii/Solution0210.py
@@ -5,9 +5,9 @@
 from typing import List, Dict
 
 class Solution:
-    def findOrder(self, numCourses: int, prerequisites: List[List[int]]) -> List[int]:
+    def findOrder(self, num_courses: int, prerequisites: List[List[int]]) -> List[int]:
         graph = {}
-        for i in range(numCourses):
+        for i in range(num_courses):
             graph[i] = []
         for classes in prerequisites:
             graph[classes[0]].append(classes[1])

diff --git a/src/main/python/g0201_0300/s0210_course_schedule_ii/Solution0210_test.py b/src/main/python/g0201_0300/s0210_course_schedule_ii/Solution0210_test.py
@@ -4,15 +4,15 @@
 class SolutionTest(unittest.TestCase):
     def test_courseScheduleII(self):
         prerequisites = [[1, 0]]
-        numCourses = 2
-        self.assertEqual(Solution().findOrder(numCourses, prerequisites), [0, 1])
+        num_courses = 2
+        self.assertEqual(Solution().findOrder(num_courses, prerequisites), [0, 1])
 
     def test_courseScheduleII2(self):
         prerequisites = [[1, 0], [2, 0], [3, 1], [3, 2]]
-        numCourses = 4
-        self.assertEqual(Solution().findOrder(numCourses, prerequisites), [0, 1, 2, 3])
+        num_courses = 4
+        self.assertEqual(Solution().findOrder(num_courses, prerequisites), [0, 1, 2, 3])
 
     def test_courseScheduleII3(self):
         prerequisites = []
-        numCourses = 1
-        self.assertEqual(Solution().findOrder(numCourses, prerequisites), [0])
+        num_courses = 1
+        self.assertEqual(Solution().findOrder(num_courses, prerequisites), [0])
diff --git a/src/main/python/g0201_0300/s0212_word_search_ii/Solution0212.py b/src/main/python/g0201_0300/s0212_word_search_ii/Solution0212.py
@@ -27,7 +27,7 @@ def remove_word(word, root = trie):
 
             return None
 
-        def getAns(m, n, root, word):
+        def get_ans(m, n, root, word):
 
             if root["end"]: 
                 ans.append(word)
@@ -38,14 +38,12 @@ def getAns(m, n, root, word):
             for i,j in [[1,0],[-1,0],[0,1],[0,-1]]:
                 a, b = m+i, n+j
                 if 0 <= a < y and 0 <= b < x and visited[a][b] == False and root[board[a][b]]:
-                    getAns(a, b, root[board[a][b]], word + board[a][b])
+                    get_ans(a, b, root[board[a][b]], word + board[a][b])
             visited[m][n] = False
 
-            return
-
         for i in range(y):
             for j in range(x):
                 if trie[board[i][j]]:
-                    getAns(i, j, trie[board[i][j]], board[i][j])
+                    get_ans(i, j, trie[board[i][j]], board[i][j])
 
         return ans
diff --git a/src/main/python/g0201_0300/s0226_invert_binary_tree/Solution0226_test.py b/src/main/python/g0201_0300/s0226_invert_binary_tree/Solution0226_test.py
@@ -48,4 +48,4 @@ def test_invertTree2(self):
     def test_invertTree3(self):
         root = build_tree([])
         result = Solution().invertTree(root)
-        self.assertEqual(result, None)
+        self.assertIsNone(result)
diff --git a/...main/python/g0201_0300/s0236_lowest_common_ancestor_of_a_binary_tree/Solution0236_test.py b/...main/python/g0201_0300/s0236_lowest_common_ancestor_of_a_binary_tree/Solution0236_test.py
@@ -3,22 +3,22 @@
 
 class SolutionTest(unittest.TestCase):
     def test_lowestCommonAncestor(self):
-        leftNodeLeftNode = TreeNode(6)
-        leftNodeRightNode = TreeNode(2, TreeNode(7), TreeNode(4))
-        leftNode = TreeNode(5, leftNodeLeftNode, leftNodeRightNode)
-        rightNode = TreeNode(1, TreeNode(0), TreeNode(8))
-        root = TreeNode(3, leftNode, rightNode)
+        left_node_left_node = TreeNode(6)
+        left_node_right_node = TreeNode(2, TreeNode(7), TreeNode(4))
+        left_node = TreeNode(5, left_node_left_node, left_node_right_node)
+        right_node = TreeNode(1, TreeNode(0), TreeNode(8))
+        root = TreeNode(3, left_node, right_node)
         self.assertEqual(
             Solution().lowestCommonAncestor(root, TreeNode(5), TreeNode(1)).val,
             3
         )
 
     def test_lowestCommonAncestor2(self):
-        leftNodeLeftNode = TreeNode(6)
-        leftNodeRightNode = TreeNode(2, TreeNode(7), TreeNode(4))
-        leftNode = TreeNode(5, leftNodeLeftNode, leftNodeRightNode)
-        rightNode = TreeNode(1, TreeNode(0), TreeNode(8))
-        root = TreeNode(3, leftNode, rightNode)
+        left_node_left_node = TreeNode(6)
+        left_node_right_node = TreeNode(2, TreeNode(7), TreeNode(4))
+        left_node = TreeNode(5, left_node_left_node, left_node_right_node)
+        right_node = TreeNode(1, TreeNode(0), TreeNode(8))
+        root = TreeNode(3, left_node, right_node)
         self.assertEqual(
             Solution().lowestCommonAncestor(root, TreeNode(5), TreeNode(4)).val,
             5

diff --git a/src/main/python/g0201_0300/s0240_search_a_2d_matrix_ii/Solution0240_test.py b/src/main/python/g0201_0300/s0240_search_a_2d_matrix_ii/Solution0240_test.py
@@ -10,7 +10,7 @@ def test_searchMatrix(self):
             [10, 13, 14, 17, 24],
             [18, 21, 23, 26, 30]
         ]
-        self.assertEqual(Solution().searchMatrix(matrix, 5), True)
+        self.assertTrue(Solution().searchMatrix(matrix, 5))
 
     def test_searchMatrix2(self):
         matrix = [
@@ -20,4 +20,4 @@ def test_searchMatrix2(self):
             [10, 13, 14, 17, 24],
             [18, 21, 23, 26, 30]
         ]
-        self.assertEqual(Solution().searchMatrix(matrix, 20), False)
+        self.assertFalse(Solution().searchMatrix(matrix, 20))
diff --git a/src/main/python/g0201_0300/s0283_move_zeroes/Solution0283.py b/src/main/python/g0201_0300/s0283_move_zeroes/Solution0283.py
@@ -9,11 +9,11 @@ def moveZeroes(self, nums: List[int]) -> None:
         """
         Do not return anything, modify nums in-place instead.
         """
-        firstZero = 0
+        first_zero = 0
         for i in range(len(nums)):
             if nums[i] != 0:
-                self.swap(firstZero, i, nums)
-                firstZero += 1
+                self.swap(first_zero, i, nums)
+                first_zero += 1
 
     def swap(self, index1: int, index2: int, nums: List[int]) -> None:
         nums[index1], nums[index2] = nums[index2], nums[index1]
diff --git a/src/main/python/g0201_0300/s0295_find_median_from_data_stream/MedianFinder_test.py b/src/main/python/g0201_0300/s0295_find_median_from_data_stream/MedianFinder_test.py
@@ -3,16 +3,16 @@
 
 class MedianFinderTest(unittest.TestCase):
     def test_medianFinder(self):
-        medianFinder = MedianFinder()
-        medianFinder.addNum(1)
-        medianFinder.addNum(2)
-        self.assertEqual(medianFinder.findMedian(), 1.5)
-        medianFinder.addNum(3)
-        self.assertEqual(medianFinder.findMedian(), 2.0)
+        median_finder = MedianFinder()
+        median_finder.addNum(1)
+        median_finder.addNum(2)
+        self.assertEqual(median_finder.findMedian(), 1.5)
+        median_finder.addNum(3)
+        self.assertEqual(median_finder.findMedian(), 2.0)
 
     def test_medianFinder2(self):
-        medianFinder = MedianFinder()
-        medianFinder.addNum(1)
-        medianFinder.addNum(3)
-        medianFinder.addNum(-1)
-        self.assertEqual(medianFinder.findMedian(), 1.0)
+        median_finder = MedianFinder()
+        median_finder.addNum(1)
+        median_finder.addNum(3)
+        median_finder.addNum(-1)
+        self.assertEqual(median_finder.findMedian(), 1.0)
diff --git a/src/main/python/g0301_0400/s0338_counting_bits/Solution0338.py b/src/main/python/g0301_0400/s0338_counting_bits/Solution0338.py
@@ -7,16 +7,16 @@
 class Solution:
     def countBits(self, num: int) -> List[int]:
         result = [0] * (num + 1)
-        borderPos = 1
-        incrPos = 1
+        border_pos = 1
+        incr_pos = 1
 
         for i in range(1, len(result)):
-            if incrPos == borderPos:
+            if incr_pos == border_pos:
                 result[i] = 1
-                incrPos = 1
-                borderPos = i
+                incr_pos = 1
+                border_pos = i
             else:
-                result[i] = 1 + result[incrPos]
-                incrPos += 1
+                result[i] = 1 + result[incr_pos]
+                incr_pos += 1
 
         return result
diff --git a/src/main/python/g0301_0400/s0383_ransom_note/Solution0383.py b/src/main/python/g0301_0400/s0383_ransom_note/Solution0383.py
@@ -2,11 +2,11 @@
 # #2025_09_20_Time_11_ms_(89.85%)_Space_17.93_MB_(54.38%)
 
 class Solution:
-    def canConstruct(self, ransomNote: str, magazine: str) -> bool:
+    def canConstruct(self, ransom_note: str, magazine: str) -> bool:
         freq = [0] * 26
-        n = len(ransomNote)
+        n = len(ransom_note)
         for i in range(n):
-            freq[ord(ransomNote[i]) - 97] += 1
+            freq[ord(ransom_note[i]) - 97] += 1
         for i in range(len(magazine)):
             if n == 0:
                 break

diff --git a/src/main/python/g0401_0500/s0416_partition_equal_subset_sum/Solution0416_test.py b/src/main/python/g0401_0500/s0416_partition_equal_subset_sum/Solution0416_test.py
@@ -3,7 +3,7 @@
 
 class SolutionTest(unittest.TestCase):
     def test_canPartition(self):
-        self.assertEqual(Solution().canPartition([1, 5, 11, 5]), True)
+        self.assertTrue(Solution().canPartition([1, 5, 11, 5]))
 
     def test_canPartition2(self):
-        self.assertEqual(Solution().canPartition([1, 2, 3, 5]), False)
+        self.assertFalse(Solution().canPartition([1, 2, 3, 5]))