apply code review

Author: dolphinflow86

find-minimum-in-rotated-sorted-array/dolphinflow86.py

@@ -11,10 +11,10 @@ def findMin(self, nums: List[int]) -> int:
         right = n-1
 
         while left < right:
-            pivot = left + (right - left) // 2
-            if nums[pivot] < nums[right]:
-                right = pivot
+            mid = left + (right - left) // 2
+            if nums[mid] < nums[right]:
+                right = mid
             else:
-                left = pivot + 1
+                left = mid + 1
 
         return nums[right]

word-search/dolphinflow86.py

@@ -2,40 +2,40 @@
 # TC: O(N*M*3^W) where N is len(row), M is len(col) and W is len(word)
 # SC: O(N*M) representing the maximum depth of the recursion tack.
 class Solution:
-    def dfs(self, board: List[List[str]], word: str, row: int, col: int, wordIdx: int) -> bool:
+    def dfs(self, board: List[List[str]], word: str, row: int, col: int, word_idx: int) -> bool:
         if row < 0 or col < 0 or row >= len(board) or col >= len(board[0]):
             return False
 
-        if wordIdx >= len(word) or board[row][col] != word[wordIdx]:
+        if word_idx >= len(word) or board[row][col] != word[word_idx]:
             return False
 
-        if wordIdx == len(word) - 1:
+        if word_idx == len(word) - 1:
             return True
 
         temp = board[row][col]
         board[row][col] = '#'
 
         found = (
-            self.dfs(board, word, row + 1, col, wordIdx + 1) or
-            self.dfs(board, word, row - 1, col, wordIdx + 1) or
-            self.dfs(board, word, row, col + 1, wordIdx + 1) or
-            self.dfs(board, word, row, col - 1, wordIdx + 1)
+            self.dfs(board, word, row + 1, col, word_idx + 1) or
+            self.dfs(board, word, row - 1, col, word_idx + 1) or
+            self.dfs(board, word, row, col + 1, word_idx + 1) or
+            self.dfs(board, word, row, col - 1, word_idx + 1)
         )
 
         board[row][col] = temp
 
         return found
 
     def exist(self, board: List[List[str]], word: str) -> bool:
-        n = len(board)
-        m = len(board[0])
-        w = len(word)
+        row_len = len(board)
+        column_len = len(board[0])
+        word_len = len(word)
 
         # Early return if the board contains fewer cells than the word length.
-        if n * m < w: return False
+        if row_len * column_len < word_len: return False
 
-        for i in range(n):
-            for j in range(m):
+        for i in range(row_len):
+            for j in range(column_len):
                 if self.dfs(board, word, i, j, 0):
                     return True