remove semicolons

Author: kamyu104

Python/coin-change-2.py

@@ -9,7 +9,7 @@ def change(self, amount, coins):
         :rtype: int
         """
         dp = [0] * (amount+1)
-        dp[0] = 1;
+        dp[0] = 1
         for coin in coins:
             for i in xrange(coin, amount+1):
                 dp[i] += dp[i-coin]

Python/convert-bst-to-greater-tree.py

@@ -14,7 +14,7 @@ def convertBSTHelper(root, cur_sum):
             if root.right:
                 cur_sum = convertBSTHelper(root.right, cur_sum)
             cur_sum += root.val
-            root.val = cur_sum;
+            root.val = cur_sum
             if root.left:
                 cur_sum = convertBSTHelper(root.left, cur_sum)
             return cur_sum

Python/count-of-smaller-numbers-after-self.py

@@ -121,9 +121,9 @@ def insertNode(self, val):
                 if node.val < curr.val:
                     curr.count += 1  # Increase the number of left children.
                     if curr.left:
-                        curr = curr.left;
+                        curr = curr.left
                     else:
-                        curr.left = node;
+                        curr.left = node
                         break
                 else:  # Insert right if larger or equal.
                     if curr.right:

Python/count-univalue-subtrees.py

@@ -5,8 +5,8 @@ class Solution(object):
     # @param {TreeNode} root
     # @return {integer}
     def countUnivalSubtrees(self, root):
-        [is_uni, count] = self.isUnivalSubtrees(root, 0);
-        return count;
+        [is_uni, count] = self.isUnivalSubtrees(root, 0)
+        return count
 
     def isUnivalSubtrees(self, root, count):
         if not root:

Python/data-stream-as-disjoint-intervals.py

@@ -37,7 +37,7 @@ def upper_bound(nums, target):
         while i != len(self.__intervals) and \
               end + 1 >= self.__intervals[i].start:
             start = min(start, self.__intervals[i].start)
-            end = max(end, self.__intervals[i].end);
+            end = max(end, self.__intervals[i].end)
             del self.__intervals[i]
         self.__intervals.insert(i, Interval(start, end))
 

Python/design-excel-sum-formula.py

@@ -26,8 +26,8 @@ def set(self, r, c, v):
         :type v: int
         :rtype: void
         """
-        self.__reset_dependency(r, c);
-        self.__update_others(r, c, v);
+        self.__reset_dependency(r, c)
+        self.__update_others(r, c, v)
 
 
     def get(self, r, c):

Python/design-twitter.py

@@ -44,10 +44,10 @@ def getNewsFeed(self, userId):
         result = []
         while max_heap and len(result) < self.__number_of_most_recent_tweets:
             t, uid, curr = heapq.heappop(max_heap)
-            nxt = curr + 1;
+            nxt = curr + 1
             if nxt != len(self.__messages[uid]):
                 heapq.heappush(max_heap, (-self.__messages[uid][-(nxt+1)][0], uid, nxt))
-            result.append(self.__messages[uid][-(curr+1)][1]);
+            result.append(self.__messages[uid][-(curr+1)][1])
         return result
 
     def follow(self, followerId, followeeId):

Python/employee-importance.py

@@ -44,7 +44,7 @@ def getImportance(self, employees, id):
         while q:
             curr = q.popleft()
             employee = employees[curr-1]
-            result += employee.importance;
+            result += employee.importance
             for id in employee.subordinates:
                 q.append(id)
         return result

Python/encode-n-ary-tree-to-binary-tree.py

@@ -26,16 +26,16 @@ def encode(self, root):
         def encodeHelper(root, parent, index):
             if not root:
                 return None
-            node = TreeNode(root.val);
+            node = TreeNode(root.val)
             if index+1 < len(parent.children):
                 node.left = encodeHelper(parent.children[index+1], parent, index+1)
             if root.children:
-                node.right = encodeHelper(root.children[0], root, 0);
+                node.right = encodeHelper(root.children[0], root, 0)
             return node
 
         if not root:
             return None
-        node = TreeNode(root.val);
+        node = TreeNode(root.val)
         if root.children:
             node.right = encodeHelper(root.children[0], root, 0)
         return node

Python/factor-combinations.py

@@ -14,11 +14,11 @@ def getResult(self, n, result, factors):
         i = 2 if not factors else factors[-1]
         while i <= n / i:
             if n % i == 0:
-                factors.append(i);
-                factors.append(n / i);
-                result.append(list(factors));
-                factors.pop();
-                self.getResult(n / i, result, factors);
+                factors.append(i)
+                factors.append(n / i)
+                result.append(list(factors))
+                factors.pop()
+                self.getResult(n / i, result, factors)
                 factors.pop()
             i += 1
 

Python/falling-squares.py

@@ -63,14 +63,14 @@ def update(self, L, R, h):
             if R & 1 == 0:
                 self.__apply(R, h)
                 R -= 1
-            L /= 2; R /= 2
+            L /= 2 R /= 2
         self.__pull(L0)
         self.__pull(R0)
 
     def query(self, L, R):
         L += self.N
         R += self.N
-        self.__push(L); self.__push(R)
+        self.__push(L) self.__push(R)
         result = 0
         while L <= R:
             if L & 1:
@@ -79,7 +79,7 @@ def query(self, L, R):
             if R & 1 == 0:
                 result = self.query_fn(result, self.tree[R])
                 R -= 1
-            L /= 2; R /= 2
+            L /= 2 R /= 2
         return result
 
 
@@ -90,7 +90,7 @@ class Solution2(object):
     def fallingSquares(self, positions):
         index = set()
         for left, size in positions:
-            index.add(left);
+            index.add(left)
             index.add(left+size-1)
         index = sorted(list(index))
         tree = SegmentTree(len(index), max, max)
@@ -137,7 +137,7 @@ def update(heights, left, right, B, blocks, blocks_read, h):
 
         index = set()
         for left, size in positions:
-            index.add(left);
+            index.add(left)
             index.add(left+size-1)
         index = sorted(list(index))
         W = len(index)

Python/find-mode-in-binary-search-tree.py

@@ -18,7 +18,7 @@ def inorder(root, prev, cnt, max_cnt, result):
                 else:
                     cnt = 1
             if cnt > max_cnt:
-                max_cnt = cnt;
+                max_cnt = cnt
                 del result[:]
                 result.append(root.val)
             elif cnt == max_cnt:
@@ -28,6 +28,6 @@ def inorder(root, prev, cnt, max_cnt, result):
         if not root:
             return []
         result = []
-        inorder(root, None, 1, 0, result);
+        inorder(root, None, 1, 0, result)
         return result
 

Python/flip-game-ii.py

@@ -12,7 +12,7 @@ def canWin(self, s):
         g, g_final = [0], 0
         for p in itertools.imap(len, re.split('-+', s)):
             while len(g) <= p:
-                # Theorem 2: g[game] = g[subgame1]^g[subgame2]^g[subgame3]...;
+                # Theorem 2: g[game] = g[subgame1]^g[subgame2]^g[subgame3]...
                 # and find first missing number.
                 g += min(set(xrange(p)) - {x^y for x, y in itertools.izip(g[:len(g)/2], g[-2:-len(g)/2-2:-1])}),
             g_final ^= g[p]

Python/h-index.py

@@ -7,7 +7,7 @@ def hIndex(self, citations):
         :type citations: List[int]
         :rtype: int
         """
-        n = len(citations);
+        n = len(citations)
         count = [0] * (n + 1)
         for x in citations:
             # Put all x >= n in the same bucket.

Python/house-robber-ii.py

@@ -18,7 +18,7 @@ def robRange(self, nums, start, end):
         num_i, num_i_1 = nums[start], 0
         for i in xrange(start + 1, end):
             num_i_1, num_i_2 = num_i, num_i_1
-            num_i = max(nums[i] + num_i_2, num_i_1);
+            num_i = max(nums[i] + num_i_2, num_i_1)
 
         return num_i
 

Python/house-robber.py

@@ -14,7 +14,7 @@ def rob(self, num):
         num_i, num_i_1 = max(num[1], num[0]), num[0]
         for i in xrange(2, len(num)):
             num_i_1, num_i_2 = num_i, num_i_1
-            num_i = max(num[i] + num_i_2, num_i_1);
+            num_i = max(num[i] + num_i_2, num_i_1)
 
         return num_i
 

Python/image-smoother.py

@@ -20,6 +20,6 @@ def getGray(M, i, j):
         result = [[0 for _ in xrange(len(M[0]))] for _ in xrange(len(M))]
         for i in xrange(len(M)):
             for j in xrange(len(M[0])):
-                result[i][j] = getGray(M, i, j);
+                result[i][j] = getGray(M, i, j)
         return result
 

Python/k-empty-slots.py

@@ -17,7 +17,7 @@ def kEmptySlots(self, flowers, k):
             if days[i] < days[left] or days[i] <= days[right]:
                 if i == right:
                     result = min(result, max(days[left], days[right]))
-                left, right = i, k+1+i;
+                left, right = i, k+1+i
             i += 1
         return -1 if result == float("inf") else result+1
 

Python/kill-process.py

@@ -50,7 +50,7 @@ def killAll(pid, children, killed):
         q.append(kill)
         while q:
             p = q.popleft()
-            result.append(p);
+            result.append(p)
             for child in children[p]:
                 q.append(child)
         return result

Python/knight-probability-in-chessboard.py

@@ -12,7 +12,7 @@ def knightProbability(self, N, K, r, c):
         """
         directions = \
             [[ 1, 2], [ 1, -2], [ 2, 1], [ 2, -1], \
-             [-1, 2], [-1, -2], [-2, 1], [-2, -1]];
+             [-1, 2], [-1, -2], [-2, 1], [-2, -1]]
         dp = [[[1 for _ in xrange(N)] for _ in xrange(N)] for _ in xrange(2)]
         for step in xrange(1, K+1):
             for i in xrange(N):
@@ -21,7 +21,7 @@ def knightProbability(self, N, K, r, c):
                     for direction in directions:
                         rr, cc = i+direction[0], j+direction[1]
                         if 0 <= cc < N and 0 <= rr < N:
-                            dp[step%2][i][j] += 0.125 * dp[(step-1)%2][rr][cc];
+                            dp[step%2][i][j] += 0.125 * dp[(step-1)%2][rr][cc]
 
         return dp[K%2][r][c]
 

Python/kth-smallest-number-in-multiplication-table.py

@@ -12,7 +12,7 @@ def findKthNumber(self, m, n, k):
         def count(target, m, n):
             return sum(min(target//i, n) for i in xrange(1, m+1))
 
-        left, right = 1, m*n;
+        left, right = 1, m*n
         while left <= right:
             mid = left + (right-left)/2
             if count(mid, m, n) >= k:

Python/longest-increasing-path-in-a-matrix.py

@@ -20,7 +20,7 @@ def longestpath(matrix, i, j, max_lengths):
                 x, y = i + d[0], j + d[1]
                 if 0 <= x < len(matrix) and 0 <= y < len(matrix[0]) and \
                    matrix[x][y] < matrix[i][j]:
-                    max_depth = max(max_depth, longestpath(matrix, x, y, max_lengths));
+                    max_depth = max(max_depth, longestpath(matrix, x, y, max_lengths))
             max_lengths[i][j] = max_depth + 1
             return max_lengths[i][j]
 

Python/longest-increasing-subsequence.py

@@ -19,7 +19,7 @@ def insert(target):
                     left = mid + 1
             # If not found, append the target.
             if left == len(LIS):
-                LIS.append(target);
+                LIS.append(target)
             else:
                 LIS[left] = target
 

Python/max-stack.py

@@ -66,7 +66,7 @@ def popMax(self):
 
     def __remove(self, val):
         idx = self.__val_to_idxs[val][-1]
-        self.__val_to_idxs[val].pop();
+        self.__val_to_idxs[val].pop()
         if not self.__val_to_idxs[val]:
             del self.__val_to_idxs[val]
         del self.__idx_to_val[idx]

Python/max-sum-of-sub-matrix-no-larger-than-k.py

@@ -94,7 +94,7 @@ def lower_bound(self, val):  # Time: O(h) = O(logn) ~ O(n)
                 accu_sum = 0
                 for sum in sums:
                     accu_sum += sum
-                    node = accu_sum_set.lower_bound(accu_sum - k);
+                    node = accu_sum_set.lower_bound(accu_sum - k)
                     if node:
                         result = max(result, accu_sum - node.val)
                     accu_sum_set.insert(accu_sum)

Python/maximal-square.py

@@ -110,6 +110,6 @@ def maximalSquare(self, matrix):
                     s[i][j] = side
                     max_square_area = max(max_square_area, side * side)
 
-        return max_square_area;
+        return max_square_area
 
 

Python/maximum-binary-tree.py

@@ -17,7 +17,7 @@ def constructMaximumBinaryTree(self, nums):
         # https://github.com/kamyu104/LintCode/blob/master/C++/max-tree.cpp
         nodeStack = []
         for num in nums:
-            node = TreeNode(num);
+            node = TreeNode(num)
             while nodeStack and num > nodeStack[-1].val:
                 node.left = nodeStack.pop()
             if nodeStack:

Python/maximum-sum-of-3-non-overlapping-subarrays.py

@@ -26,7 +26,7 @@ def maxSumOfThreeSubarrays(self, nums, k):
         total = accu[n]-accu[n-k]
         for i in reversed(xrange(n-k)):
             if accu[i+k]-accu[i] > total:
-                right_pos[i] = i;
+                right_pos[i] = i
                 total = accu[i+k]-accu[i]
             else:
                 right_pos[i] = right_pos[i+1]

Python/median-of-two-sorted-arrays.py

@@ -84,7 +84,7 @@ def findMedianSortedArrays(self, A, B):
             return -1.0
         lenA = len(A)
         lenB = len(B)
-        lenn = lenA + lenB;
+        lenn = lenA + lenB
 
         indexA,indexB,indexC = 0,0,0
         C = [False for i in xrange(lenn)]

Python/merge-k-sorted-lists.py

@@ -33,7 +33,7 @@ def mergeTwoLists(l1, l2):
 
         if not lists:
             return None
-        left, right = 0, len(lists) - 1;
+        left, right = 0, len(lists) - 1
         while right > 0:
             if left >= right:
                 left = 0

Python/mini-parser.py

@@ -61,7 +61,7 @@ def deserialize(self, s):
                     stk[-1].add(NestedInteger(int(s[i:j])))
                 if s[j] == ']' and len(stk) > 1:
                     cur = stk[-1]
-                    stk.pop();
+                    stk.pop()
                     stk[-1].add(cur)
                 i = j+1
 

Python/most-common-word.py

@@ -12,7 +12,7 @@ def mostCommonWord(self, paragraph, banned):
         :rtype: str
         """
         lookup = set(banned)
-        counts = collections.Counter(word.strip("!?',;.")
+        counts = collections.Counter(word.strip("!?',.")
                                      for word in paragraph.lower().split())
 
         result = ''

Python/n-queens.py

@@ -29,7 +29,7 @@ def dfs(curr, cols, main_diag, anti_diag, result):
 
 # For any point (x,y), if we want the new point (p,q) don't share the same row, column, or diagonal.
 # then there must have ```p+q != x+y``` and ```p-q!= x-y```
-# the former focus on eliminate 'left bottom right top' diagonal;
+# the former focus on eliminate 'left bottom right top' diagonal
 # the latter focus on eliminate 'left top right bottom' diagonal
 
 # - col_per_row: the list of column index per row

Python/number-of-digit-one.py

@@ -5,7 +5,7 @@ class Solution(object):
     # @param {integer} n
     # @return {integer}
     def countDigitOne(self, n):
-        k = 1;
+        k = 1
         cnt, multiplier, left_part = 0, 1, n
 
         while left_part > 0:

Python/number-of-distinct-islands-ii.py

@@ -15,7 +15,7 @@ def dfs(i, j, grid, island):
                     grid[i][j] > 0):
                 return False
             grid[i][j] *= -1
-            island.append((i, j));
+            island.append((i, j))
             for d in directions:
                 dfs(i+d[0], j+d[1], grid, island)
             return True