Improved tasks 155-452

Author: ThanhNIT

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)

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

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)

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:

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

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

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])

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])

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

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)