refactor for format

fishercoder1534 · fishercoder1534 · commit 5f28ec0ba010 · 2017-08-24T19:15:23.000-07:00
diff --git a/src/main/java/com/fishercoder/solutions/_50.java b/src/main/java/com/fishercoder/solutions/_50.java
@@ -6,8 +6,9 @@
 public class _50 {
 
     public double myPow(double x, int n) {
-        if (n == 0)
+        if (n == 0) {
             return 1;
+        }
         if (n == Integer.MIN_VALUE) {
             ++n;
             n = -n;
diff --git a/src/main/java/com/fishercoder/solutions/_501.java b/src/main/java/com/fishercoder/solutions/_501.java
@@ -30,7 +30,9 @@ public class _501 {
     public int[] findMode(TreeNode root) {
         int[] result = new int[]{};
         Map<Integer, Integer> map = new HashMap();
-        if (root == null) return result;
+        if (root == null) {
+            return result;
+        }
         List<Integer> list = bfs(root, map);
         result = new int[list.size()];
         for (int i = 0; i < list.size(); i++) {
@@ -46,8 +48,12 @@ private List<Integer> bfs(TreeNode root, Map<Integer, Integer> map) {
             int size = queue.size();
             for (int i = 0; i < size; i++) {
                 TreeNode treeNode = queue.poll();
-                if (treeNode.left != null) queue.offer(treeNode.left);
-                if (treeNode.right != null) queue.offer(treeNode.right);
+                if (treeNode.left != null) {
+                    queue.offer(treeNode.left);
+                }
+                if (treeNode.right != null) {
+                    queue.offer(treeNode.right);
+                }
                 map.put(treeNode.val, map.getOrDefault(treeNode.val, 0) + 1);
             }
         }
diff --git a/src/main/java/com/fishercoder/solutions/_502.java b/src/main/java/com/fishercoder/solutions/_502.java
@@ -40,7 +40,9 @@ public int findMaximizedCapital(int k, int W, int[] Profits, int[] Capital) {
             while (!capitalHeap.isEmpty() && capitalHeap.peek()[0] <= W) {
                 profitHeap.add(capitalHeap.poll());
             }
-            if (profitHeap.isEmpty()) break;
+            if (profitHeap.isEmpty()) {
+                break;
+            }
             W += profitHeap.poll()[1];
         }
         return W;
diff --git a/src/main/java/com/fishercoder/solutions/_503.java b/src/main/java/com/fishercoder/solutions/_503.java
@@ -21,7 +21,9 @@ public class _503 {
     //Credit: https://discuss.leetcode.com/topic/77881/typical-ways-to-solve-circular-array-problems-java-solution
     //Note: we store INDEX into the stack, reversely, the larger index put at the bottom of the stack, the smaller index at the top
     public int[] nextGreaterElements(int[] nums) {
-        if (nums == null || nums.length == 0) return nums;
+        if (nums == null || nums.length == 0) {
+            return nums;
+        }
         int len = nums.length;
         Stack<Integer> stack = new Stack<>();
         for (int i = len - 1; i >= 0; i--) {
diff --git a/src/main/java/com/fishercoder/solutions/_505.java b/src/main/java/com/fishercoder/solutions/_505.java
@@ -67,7 +67,9 @@ public int shortestDistance(int[][] maze, int[] start, int[] destination) {
 
         while (!queue.isEmpty()) {
             Point curr = queue.poll();
-            if (length[curr.x][curr.y] <= curr.distance) continue;
+            if (length[curr.x][curr.y] <= curr.distance) {
+                continue;
+            }
             length[curr.x][curr.y] = curr.distance;
             for (int i = 0; i < directions.length - 1; i++) {
                 int x = curr.x;
diff --git a/src/main/java/com/fishercoder/solutions/_506.java b/src/main/java/com/fishercoder/solutions/_506.java
@@ -28,10 +28,15 @@ public String[] findRelativeRanks(int[] nums) {
         Map<Integer, String> rankMap = new HashMap();
         int len = nums.length;
         for (int i = len - 1; i >= 0; i--) {
-            if (i == len - 1) rankMap.put(tmp[i], "Gold Medal");
-            else if (i == len - 2) rankMap.put(tmp[i], "Silver Medal");
-            else if (i == len - 3) rankMap.put(tmp[i], "Bronze Medal");
-            else rankMap.put(tmp[i], String.valueOf(len - i));
+            if (i == len - 1) {
+                rankMap.put(tmp[i], "Gold Medal");
+            } else if (i == len - 2) {
+                rankMap.put(tmp[i], "Silver Medal");
+            } else if (i == len - 3) {
+                rankMap.put(tmp[i], "Bronze Medal");
+            } else {
+                rankMap.put(tmp[i], String.valueOf(len - i));
+            }
         }
         String[] result = new String[len];
         for (int i = 0; i < len; i++) {
diff --git a/src/main/java/com/fishercoder/solutions/_507.java b/src/main/java/com/fishercoder/solutions/_507.java
@@ -16,12 +16,16 @@
 public class _507 {
 
     public boolean checkPerfectNumber(int num) {
-        if (num == 1) return false;
+        if (num == 1) {
+            return false;
+        }
         int sum = 0;
         for (int i = 2; i <= Math.sqrt(num); i++) {
             if (num % i == 0) {
                 sum += i;
-                if (i != num / i) sum += num / i;
+                if (i != num / i) {
+                    sum += num / i;
+                }
             }
         }
         sum++;
diff --git a/src/main/java/com/fishercoder/solutions/_508.java b/src/main/java/com/fishercoder/solutions/_508.java
@@ -39,7 +39,9 @@ public class _508 {
     public static class Solution1 {
         //my purely original but verbose solution
         public int[] findFrequentTreeSum(TreeNode root) {
-            if (root == null) return new int[]{};
+            if (root == null) {
+                return new int[]{};
+            }
 
             Map<TreeNode, Integer> map = new HashMap();
             postOrder(root, map);
diff --git a/src/main/java/com/fishercoder/solutions/_51.java b/src/main/java/com/fishercoder/solutions/_51.java
@@ -31,7 +31,9 @@ public class _51 {
 
     public List<List<String>> solveNQueens(int n) {
         List<List<String>> result = new ArrayList<>();
-        if (n <= 0) return result;
+        if (n <= 0) {
+            return result;
+        }
         search(n, new ArrayList<>(), result);
         return result;
     }
diff --git a/src/main/java/com/fishercoder/solutions/_513.java b/src/main/java/com/fishercoder/solutions/_513.java
@@ -46,8 +46,12 @@ public int findBottomLeftValue(TreeNode root) {
                 if (i == 0) {
                     leftMost = curr;
                 }
-                if (curr.left != null) queue.offer(curr.left);
-                if (curr.right != null) queue.offer(curr.right);
+                if (curr.left != null) {
+                    queue.offer(curr.left);
+                }
+                if (curr.right != null) {
+                    queue.offer(curr.right);
+                }
             }
         }
         return leftMost.val;
diff --git a/src/main/java/com/fishercoder/solutions/_515.java b/src/main/java/com/fishercoder/solutions/_515.java
@@ -34,8 +34,12 @@ public List<Integer> largestValues(TreeNode root) {
                 for (int i = 0; i < size; i++) {
                     TreeNode curr = queue.poll();
                     max = Math.max(max, curr.val);
-                    if (curr.left != null) queue.offer(curr.left);
-                    if (curr.right != null) queue.offer(curr.right);
+                    if (curr.left != null) {
+                        queue.offer(curr.left);
+                    }
+                    if (curr.right != null) {
+                        queue.offer(curr.right);
+                    }
                 }
                 list.add(max);
             }
diff --git a/src/main/java/com/fishercoder/solutions/_52.java b/src/main/java/com/fishercoder/solutions/_52.java
@@ -10,7 +10,9 @@ public class _52 {
 
     public int totalNQueens(int n) {
         List<List<String>> result = new ArrayList<>();
-        if (n <= 0) return result.size();
+        if (n <= 0) {
+            return result.size();
+        }
         search(n, new ArrayList<>(), result);
         return result.size();
     }
diff --git a/src/main/java/com/fishercoder/solutions/_520.java b/src/main/java/com/fishercoder/solutions/_520.java
@@ -22,22 +22,28 @@ public class _520 {
     public boolean detectCapitalUse(String word) {
         char[] words = word.toCharArray();
         boolean firstLetterCap = false;
-        if (Character.isUpperCase(words[0])) firstLetterCap = true;
+        if (Character.isUpperCase(words[0])) {
+            firstLetterCap = true;
+        }
 
         if (firstLetterCap) {
             if (words.length >= 2) {
                 int i = 2;
                 if (Character.isUpperCase(words[1])) {
                     //then all following must be all uppercase
                     while (i < words.length) {
-                        if (!Character.isUpperCase(words[i])) return false;
+                        if (!Character.isUpperCase(words[i])) {
+                            return false;
+                        }
                         i++;
                     }
                     return true;
                 } else {
                     //then all following must be all lowercase
                     while (i < words.length) {
-                        if (!Character.isLowerCase(words[i])) return false;
+                        if (!Character.isLowerCase(words[i])) {
+                            return false;
+                        }
                         i++;
                     }
                     return true;
@@ -48,7 +54,9 @@ public boolean detectCapitalUse(String word) {
             //then all following must be all lowercase
             int i = 1;
             while (i < words.length) {
-                if (!Character.isLowerCase(words[i])) return false;
+                if (!Character.isLowerCase(words[i])) {
+                    return false;
+                }
                 i++;
             }
             return true;
diff --git a/src/main/java/com/fishercoder/solutions/_521.java b/src/main/java/com/fishercoder/solutions/_521.java
@@ -26,7 +26,9 @@ public class _521 {
 
     //Or in other words, when a.length() != b.length(), no subsequence of b will be equal to a, so return Math.max(a.length(), b.length())
     public int findLUSlength(String a, String b) {
-        if (a.equals(b)) return -1;
+        if (a.equals(b)) {
+            return -1;
+        }
         return Math.max(a.length(), b.length());
     }
 
diff --git a/src/main/java/com/fishercoder/solutions/_522.java b/src/main/java/com/fishercoder/solutions/_522.java
@@ -33,21 +33,26 @@ public int compare(String o1, String o2) {
         for (int i = 0; i < strs.length; i++) {
             boolean found = true;
             for (int j = 0; j < strs.length; j++) {
-                if (i == j) continue;
-                else if (isSubsequence(strs[i], strs[j])) {
+                if (i == j) {
+                    continue;
+                } else if (isSubsequence(strs[i], strs[j])) {
                     found = false;
                     break;
                 }
             }
-            if (found) return strs[i].length();
+            if (found) {
+                return strs[i].length();
+            }
         }
         return -1;
     }
 
     private boolean isSubsequence(String a, String b) {
         int i = 0;
         for (int j = 0; i < a.length() && j < b.length(); j++) {
-            if (a.charAt(i) == b.charAt(j)) i++;
+            if (a.charAt(i) == b.charAt(j)) {
+                i++;
+            }
         }
         return i == a.length();
     }
diff --git a/src/main/java/com/fishercoder/solutions/_523.java b/src/main/java/com/fishercoder/solutions/_523.java
@@ -60,15 +60,21 @@ public boolean checkSubarraySumOnTimeO1Space(int[] nums, int k) {
     }
 
     public boolean checkSubarraySum(int[] nums, int k) {
-        if (nums == null || nums.length == 0) return false;
+        if (nums == null || nums.length == 0) {
+            return false;
+        }
 
         //Two continuous zeroes will form a subarray of length 2 with sum 0, 0*k = 0 will always be true
         for (int i = 0; i < nums.length - 1; i++) {
-            if (nums[i] == 0 && nums[i + 1] == 0) return true;
+            if (nums[i] == 0 && nums[i + 1] == 0) {
+                return true;
+            }
         }
 
         //then k cannot be zero any more
-        if (k == 0 || nums.length < 2) return false;
+        if (k == 0 || nums.length < 2) {
+            return false;
+        }
 
         int[] preSums = new int[nums.length + 1];
         for (int i = 1; i <= nums.length; i++) {
@@ -77,7 +83,9 @@ public boolean checkSubarraySum(int[] nums, int k) {
 
         for (int i = 1; i <= nums.length; i++) {
             for (int j = 0; j < i - 1; j++) {
-                if ((preSums[i] - preSums[j]) % k == 0) return true;
+                if ((preSums[i] - preSums[j]) % k == 0) {
+                    return true;
+                }
             }
         }
         return false;
diff --git a/src/main/java/com/fishercoder/solutions/_524.java b/src/main/java/com/fishercoder/solutions/_524.java
@@ -41,7 +41,9 @@ public String findLongestWord(String s, List<String> d) {
                     i++;
                 }
             }
-            if (i == dictWord.length()) return dictWord;
+            if (i == dictWord.length()) {
+                return dictWord;
+            }
         }
         return "";
     }
diff --git a/src/main/java/com/fishercoder/solutions/_525.java b/src/main/java/com/fishercoder/solutions/_525.java
@@ -24,7 +24,9 @@ public class _525 {
 
     //credit: https://leetcode.com/articles/contiguous-array/#approach-3-using-hashmap-accepted
     public int findMaxLength(int[] nums) {
-        if (nums == null || nums.length == 0) return 0;
+        if (nums == null || nums.length == 0) {
+            return 0;
+        }
         int count = 0;
         int max = 0;
         Map<Integer, Integer> map = new HashMap();
diff --git a/src/main/java/com/fishercoder/solutions/_527.java b/src/main/java/com/fishercoder/solutions/_527.java
@@ -41,12 +41,17 @@ public List<String> wordsAbbreviation(List<String> dict) {
             while (true) {
                 HashSet<Integer> set = new HashSet<>();
                 for (int j = i + 1; j < len; j++) {
-                    if (ans[j].equals(ans[i])) set.add(j); // check all strings with the same abbreviation
+                    if (ans[j].equals(ans[i])) {
+                        set.add(j); // check all strings with the same abbreviation
+                    }
+                }
+                if (set.isEmpty()) {
+                    break;
                 }
-                if (set.isEmpty()) break;
                 set.add(i);
-                for (int k : set)
+                for (int k : set) {
                     ans[k] = abbreviate(dict.get(k), ++prefix[k]); // increase the prefix
+                }
             }
         }
         return Arrays.asList(ans);
diff --git a/src/main/java/com/fishercoder/solutions/_529.java b/src/main/java/com/fishercoder/solutions/_529.java
@@ -75,10 +75,14 @@ public char[][] updateBoard(char[][] board, int[] click) {
                 int count = 0;
                 for (int i = -1; i < 2; i++) {
                     for (int j = -1; j < 2; j++) {
-                        if (i == 0 && j == 0) continue;
+                        if (i == 0 && j == 0) {
+                            continue;
+                        }
                         int r = row + i;
                         int c = col + j;
-                        if (r >= m || r < 0 || c >= n || c < 0) continue;
+                        if (r >= m || r < 0 || c >= n || c < 0) {
+                            continue;
+                        }
                         if (board[r][c] == 'M' || board[r][c] == 'X') {
                             count++;
                         }
@@ -91,10 +95,14 @@ public char[][] updateBoard(char[][] board, int[] click) {
                     board[row][col] = 'B';
                     for (int i = -1; i < 2; i++) {
                         for (int j = -1; j < 2; j++) {
-                            if (i == 0 && j == 0) continue;
+                            if (i == 0 && j == 0) {
+                                continue;
+                            }
                             int r = row + i;
                             int c = col + j;
-                            if (r >= m || r < 0 || c >= n || c < 0) continue;
+                            if (r >= m || r < 0 || c >= n || c < 0) {
+                                continue;
+                            }
                             if (board[r][c] == 'E') {
                                 queue.offer(new int[]{r, c});
                                 board[r][c] = 'B';

Original file line number	Diff line number	Diff line change
`@@ -40,7 +40,9 @@ public int findMaximizedCapital(int k, int W, int[] Profits, int[] Capital) {`
`40`	`40`	`while (!capitalHeap.isEmpty() && capitalHeap.peek()[0] <= W) {`
`41`	`41`	`profitHeap.add(capitalHeap.poll());`
`42`	`42`	`}`
`43`		`- if (profitHeap.isEmpty()) break;`
	`43`	`+ if (profitHeap.isEmpty()) {`
	`44`	`+ break;`
	`45`	`+ }`
`44`	`46`	`W += profitHeap.poll()[1];`
`45`	`47`	`}`
`46`	`48`	`return W;`
Original file line number	Diff line number	Diff line change
`@@ -46,8 +46,12 @@ public int findBottomLeftValue(TreeNode root) {`
`46`	`46`	`if (i == 0) {`
`47`	`47`	`leftMost = curr;`
`48`	`48`	`}`
`49`		`- if (curr.left != null) queue.offer(curr.left);`
`50`		`- if (curr.right != null) queue.offer(curr.right);`
	`49`	`+ if (curr.left != null) {`
	`50`	`+ queue.offer(curr.left);`
	`51`	`+ }`
	`52`	`+ if (curr.right != null) {`
	`53`	`+ queue.offer(curr.right);`
	`54`	`+ }`
`51`	`55`	`}`
`52`	`56`	`}`
`53`	`57`	`return leftMost.val;`