refactor for format

Author: fishercoder1534

src/main/java/com/fishercoder/solutions/_4.java

@@ -45,13 +45,13 @@ public double getkth(int[] A, int aStart, int[] B, int bStart, int k) {
             if (k == 1) return Math.min(A[aStart], B[bStart]);
 
             int aMid = Integer.MAX_VALUE, bMid = Integer.MAX_VALUE;
-            if (aStart + k/2 - 1 < A.length) aMid = A[aStart + k/2 - 1];
-            if (bStart + k/2 - 1 < B.length) bMid = B[bStart + k/2 - 1];
+            if (aStart + k / 2 - 1 < A.length) aMid = A[aStart + k / 2 - 1];
+            if (bStart + k / 2 - 1 < B.length) bMid = B[bStart + k / 2 - 1];
 
             if (aMid < bMid)
-                return getkth(A, aStart + k/2, B, bStart,       k - k/2);// Check: aRight + bLeft
+                return getkth(A, aStart + k / 2, B, bStart, k - k / 2);// Check: aRight + bLeft
             else
-                return getkth(A, aStart,       B, bStart + k/2, k - k/2);// Check: bRight + aLeft
+                return getkth(A, aStart, B, bStart + k / 2, k - k / 2);// Check: bRight + aLeft
         }
     }
 

src/main/java/com/fishercoder/solutions/_40.java

@@ -28,24 +28,25 @@ public List<List<Integer>> combinationSum2(int[] candidates, int target) {
         helper(candidates, target, 0, new ArrayList(), result);
         return result;
     }
-    
-    void helper(int[] candidates, int target, int start, List<Integer> curr, List<List<Integer>> result){
-        if(target > 0){
-            for(int i = start; i < candidates.length && target >= candidates[i]; i++){
-                if(i > start && candidates[i] == candidates[i-1]) continue;//skip duplicates, this is one difference from Combination Sum I
+
+    void helper(int[] candidates, int target, int start, List<Integer> curr, List<List<Integer>> result) {
+        if (target > 0) {
+            for (int i = start; i < candidates.length && target >= candidates[i]; i++) {
+                if (i > start && candidates[i] == candidates[i - 1])
+                    continue;//skip duplicates, this is one difference from Combination Sum I
                 curr.add(candidates[i]);
-                helper(candidates, target - candidates[i], i+1, curr, result);//i+1 is the other difference from Combination Sum I
-                curr.remove(curr.size()-1);
+                helper(candidates, target - candidates[i], i + 1, curr, result);//i+1 is the other difference from Combination Sum I
+                curr.remove(curr.size() - 1);
             }
-        } else if(target == 0){
+        } else if (target == 0) {
             List<Integer> temp = new ArrayList(curr);
             result.add(temp);
         }
     }
 
-    public static void main(String...args){
+    public static void main(String... args) {
         _40 test = new _40();
-        int[] candidates = new int[]{10,1,2,7,6,1,5};
+        int[] candidates = new int[]{10, 1, 2, 7, 6, 1, 5};
         int target = 8;
         List<List<Integer>> result = test.combinationSum2(candidates, target);
         CommonUtils.printListList(result);

src/main/java/com/fishercoder/solutions/_401.java

@@ -28,7 +28,8 @@ public List<String> readBinaryWatch(int num) {
         List<String> times = new ArrayList<>();
         for (int h = 0; h < 12; h++) {
             for (int m = 0; m < 60; m++) {
-                if (Integer.bitCount(h*60 + m) == num) times.add(String.format("%d:%02d", h, m));//%02 means to pad this two-digit decimal number on the left with zeroes
+                if (Integer.bitCount(h * 60 + m) == num)
+                    times.add(String.format("%d:%02d", h, m));//%02 means to pad this two-digit decimal number on the left with zeroes
             }
         }
         return times;

src/main/java/com/fishercoder/solutions/_402.java

@@ -28,13 +28,13 @@ public class _402 {
 
     /**credit: https://discuss.leetcode.com/topic/59412/a-greedy-method-using-stack-o-n-time-and-o-n-space*/
     public String removeKdigits(String num, int k) {
-        int digits = num.length()-k;
+        int digits = num.length() - k;
         char[] stack = new char[num.length()];
         int top = 0;
 
         for (int i = 0; i < num.length(); i++) {
             char c = num.charAt(i);
-            while (top > 0 && stack[top-1] > c && k > 0) {
+            while (top > 0 && stack[top - 1] > c && k > 0) {
                 top--;
                 k--;
             }
@@ -45,7 +45,7 @@ public String removeKdigits(String num, int k) {
         while (index < digits && stack[index] == '0') {
             index++;
         }
-        return index == digits ? "0" : new String(stack, index, digits-index);
+        return index == digits ? "0" : new String(stack, index, digits - index);
     }
 
 }

src/main/java/com/fishercoder/solutions/_403.java

@@ -65,7 +65,7 @@ public boolean canCross(int[] stones) {
             int stone = stones[i];
             for (int step : map.get(stone)) {
                 int reach = step + stone;
-                if (reach == stones[stones.length-1]) return true;
+                if (reach == stones[stones.length - 1]) return true;
                 Set<Integer> set = map.get(reach);
                 if (set != null) {
                     set.add(step);

src/main/java/com/fishercoder/solutions/_404.java

@@ -15,38 +15,38 @@
 public class _404 {
     public int sumOfLeftLeaves(TreeNode root) {
         int result = 0;
-        if(root == null) return result;
+        if (root == null) return result;
         return dfs(root, result, false);
     }
-    
+
     private int dfs(TreeNode root, int result, boolean left) {
-        if(root.left == null && root.right == null && left) {
+        if (root.left == null && root.right == null && left) {
             result += root.val;
             return result;
         }
         int leftResult = 0;
-        if(root.left != null){
+        if (root.left != null) {
             left = true;
             leftResult = dfs(root.left, result, left);
         }
         int rightResult = 0;
-        if(root.right != null){
+        if (root.right != null) {
             left = false;
             rightResult = dfs(root.right, result, left);
         }
         return leftResult + rightResult;
     }
-    
+
     private class Solution2 {
 
         public int sumOfLeftLeaves(TreeNode root) {
             int sum = 0;
-            if(root == null) return sum;
-            if(root.left != null){
-                if(root.left.left == null && root.left.right == null) sum += root.left.val;
+            if (root == null) return sum;
+            if (root.left != null) {
+                if (root.left.left == null && root.left.right == null) sum += root.left.val;
                 else sum += sumOfLeftLeaves(root.left);
             }
-            if(root.right != null){
+            if (root.right != null) {
                 sum += sumOfLeftLeaves(root.right);
             }
             return sum;

src/main/java/com/fishercoder/solutions/_406.java

@@ -27,15 +27,17 @@
  */
 public class _406 {
 
-    /**Credit: https://discuss.leetcode.com/topic/60437/java-solution-using-priorityqueue-and-linkedlist*/
+    /**
+     * Credit: https://discuss.leetcode.com/topic/60437/java-solution-using-priorityqueue-and-linkedlist
+     */
     public int[][] reconstructQueue(int[][] people) {
-        Arrays.sort(people,new Comparator<int[]>(){
-            public int compare(int[] p1, int[] p2){
-                return p1[0] != p2[0] ? Integer.compare(p2[0],p1[0]) : Integer.compare(p1[1],p2[1]);
+        Arrays.sort(people, new Comparator<int[]>() {
+            public int compare(int[] p1, int[] p2) {
+                return p1[0] != p2[0] ? Integer.compare(p2[0], p1[0]) : Integer.compare(p1[1], p2[1]);
             }
         });
         List<int[]> list = new LinkedList();
-        for (int[] ppl: people) {
+        for (int[] ppl : people) {
             list.add(ppl[1], ppl);
         }
         return list.toArray(new int[people.length][]);

src/main/java/com/fishercoder/solutions/_410.java

@@ -65,7 +65,7 @@ public int splitArray(int[] nums, int m) {
         long l = max;
         long r = sum;
         while (l <= r) {
-            long mid = (l + r)/ 2;
+            long mid = (l + r) / 2;
             if (valid(mid, nums, m)) {
                 r = mid - 1;
             } else {
@@ -78,7 +78,7 @@ public int splitArray(int[] nums, int m) {
     public boolean valid(long target, int[] nums, int m) {
         int count = 1;
         long total = 0;
-        for(int num : nums) {
+        for (int num : nums) {
             total += num;
             if (total > target) {
                 total = num;

src/main/java/com/fishercoder/solutions/_412.java

@@ -37,12 +37,12 @@ public class _412 {
 
     public List<String> fizzBuzz(int n) {
         List<String> result = new ArrayList();
-        for(int i = 1; i <= n; i++){
-            if(i%3 == 0 && i%5 == 0){
+        for (int i = 1; i <= n; i++) {
+            if (i % 3 == 0 && i % 5 == 0) {
                 result.add("_412");
-            } else if(i%3 == 0){
+            } else if (i % 3 == 0) {
                 result.add("Fizz");
-            } else if(i%5 == 0){
+            } else if (i % 5 == 0) {
                 result.add("Buzz");
             } else {
                 result.add(Integer.toString(i));

src/main/java/com/fishercoder/solutions/_413.java

@@ -29,28 +29,28 @@ public class _413 {
     //copied this solution: https://discuss.leetcode.com/topic/62884/2ms-java-o-n-time-o-1-space-solution
     public int numberOfArithmeticSlices(int[] A) {
         int sum = 0, len = 2;
-        for (int i = 2; i < A.length; i++){
-            if (A[i] - A[i-1] == A[i-1] - A[i-2]){
+        for (int i = 2; i < A.length; i++) {
+            if (A[i] - A[i - 1] == A[i - 1] - A[i - 2]) {
                 len++;
             } else {
                 if (len > 2) sum += calculateSlices(len);
                 len = 2;//reset it to 2
             }
         }
-        if(len > 2) sum += calculateSlices(len);
+        if (len > 2) sum += calculateSlices(len);
         return sum;
     }
-    
-    int calculateSlices(int len){
-        return (len-1)*(len-2)/2;
+
+    int calculateSlices(int len) {
+        return (len - 1) * (len - 2) / 2;
     }
-    
-    class Solution2{
+
+    class Solution2 {
         //a more clear solution: https://discuss.leetcode.com/topic/63302/simple-java-solution-9-lines-2ms
         public int numberOfArithmeticSlices(int[] A) {
             int sum = 0, curr = 0;
-            for (int i = 2; i < A.length; i++){
-                if (A[i] - A[i-1] == A[i-1] - A[i-2]){
+            for (int i = 2; i < A.length; i++) {
+                if (A[i] - A[i - 1] == A[i - 1] - A[i - 2]) {
                     curr++;
                     sum += curr;
                 } else {

src/main/java/com/fishercoder/solutions/_416.java

@@ -44,26 +44,26 @@ public boolean canPartition(int[] nums) {
         sum /= 2;
 
         int n = nums.length;
-        boolean[][] dp = new boolean[n+1][sum+1];
+        boolean[][] dp = new boolean[n + 1][sum + 1];
         for (int i = 0; i < dp.length; i++) {
             Arrays.fill(dp[i], false);
         }
 
         dp[0][0] = true;
 
-        for (int i = 1; i < n+1; i++) {
+        for (int i = 1; i < n + 1; i++) {
             dp[i][0] = true;
         }
 
-        for (int j = 1; j < sum+1; j++) {
+        for (int j = 1; j < sum + 1; j++) {
             dp[0][j] = false;
         }
 
-        for (int i = 1; i < n+1; i++) {
-            for (int j = 1; j < sum+1; j++) {
-                dp[i][j] = dp[i-1][j];
-                if (j >= nums[i-1]) {
-                    dp[i][j] = (dp[i][j] || dp[i-1][j-nums[i-1]]);
+        for (int i = 1; i < n + 1; i++) {
+            for (int j = 1; j < sum + 1; j++) {
+                dp[i][j] = dp[i - 1][j];
+                if (j >= nums[i - 1]) {
+                    dp[i][j] = (dp[i][j] || dp[i - 1][j - nums[i - 1]]);
                 }
             }
         }

src/main/java/com/fishercoder/solutions/_417.java

@@ -18,49 +18,51 @@
 
 public class _417 {
     //looked at this post: https://discuss.leetcode.com/topic/62379/java-bfs-dfs-from-ocean
-    
-    /**One typical trick to work on 2d grid problems is to go through the border and put proper ones into a queue if using BFS.*/
+
+    /**
+     * One typical trick to work on 2d grid problems is to go through the border and put proper ones into a queue if using BFS.
+     */
     public List<int[]> pacificAtlantic(int[][] matrix) {
 
         List<int[]> result = new ArrayList();
-        if(matrix == null || matrix.length == 0 || matrix[0].length == 0) return result;
-        
+        if (matrix == null || matrix.length == 0 || matrix[0].length == 0) return result;
+
         int m = matrix.length, n = matrix[0].length;
         boolean[][] pacific = new boolean[m][n];
         boolean[][] atlantic = new boolean[m][n];
-        
-        for(int i = 0; i < m; i++){
+
+        for (int i = 0; i < m; i++) {
             dfs(matrix, pacific, Integer.MIN_VALUE, i, 0);
-            dfs(matrix, atlantic, Integer.MIN_VALUE, i, n-1);
+            dfs(matrix, atlantic, Integer.MIN_VALUE, i, n - 1);
         }
-        
-        for(int i = 0; i < n; i++){
+
+        for (int i = 0; i < n; i++) {
             dfs(matrix, pacific, Integer.MIN_VALUE, 0, i);
-            dfs(matrix, atlantic, Integer.MIN_VALUE, m-1, i);
+            dfs(matrix, atlantic, Integer.MIN_VALUE, m - 1, i);
         }
-        
-        for(int i = 0; i < m; i++){
-            for(int j = 0; j < n; j++){
-                if(pacific[i][j] && atlantic[i][j]){
+
+        for (int i = 0; i < m; i++) {
+            for (int j = 0; j < n; j++) {
+                if (pacific[i][j] && atlantic[i][j]) {
                     result.add(new int[]{i, j});
                 }
             }
         }
-        
+
         return result;
     }
-    
-    void dfs(int[][] matrix, boolean[][] visited, int height, int x, int y){
+
+    void dfs(int[][] matrix, boolean[][] visited, int height, int x, int y) {
         int m = matrix.length, n = matrix[0].length;
-        if(x < 0 || y < 0 || x >= m || y >= n || matrix[x][y] < height || visited[x][y]) return;
+        if (x < 0 || y < 0 || x >= m || y >= n || matrix[x][y] < height || visited[x][y]) return;
         visited[x][y] = true;
-        dfs(matrix, visited, matrix[x][y], x+1, y);
-        dfs(matrix, visited, matrix[x][y], x, y+1);
-        dfs(matrix, visited, matrix[x][y], x-1, y);
-        dfs(matrix, visited, matrix[x][y], x, y-1);
+        dfs(matrix, visited, matrix[x][y], x + 1, y);
+        dfs(matrix, visited, matrix[x][y], x, y + 1);
+        dfs(matrix, visited, matrix[x][y], x - 1, y);
+        dfs(matrix, visited, matrix[x][y], x, y - 1);
     }
-    
-    public static void main(String...args){
+
+    public static void main(String... args) {
         _417 test = new _417();
 //        int[][] matrix = new int[][]{
 //                {1,2,2,3,5},
@@ -69,24 +71,24 @@ public static void main(String...args){
 //                {6,7,1,4,5},
 //                {5,1,1,2,4},
 //        };
-        
+
 //        int[][] matrix = new int[][]{//this one is correct
 //                {3,5},
 //                {4,4},
 //        };
-        
+
 //        int[][] matrix = new int[][]{//this one is correct
 //                {2,3,5},
 //                {3,4,4},
 //        };
-        
+
         int[][] matrix = new int[][]{
-                {2,3,5},
-                {3,4,4},
-                {5,3,1},
+                {2, 3, 5},
+                {3, 4, 4},
+                {5, 3, 1},
         };
         List<int[]> result = test.pacificAtlantic(matrix);
-        for(int[] point : result){
+        for (int[] point : result) {
             System.out.println(point[0] + "\t" + point[1]);
         }
     }

src/main/java/com/fishercoder/solutions/_418.java

@@ -78,7 +78,7 @@ public int wordsTyping(String[] sentence, int rows, int cols) {
             if (s.charAt(start % l) == ' ') {
                 start++;
             } else {
-                while (start > 0 && s.charAt((start-1) % l) != ' ') {
+                while (start > 0 && s.charAt((start - 1) % l) != ' ') {
                     start--;
                 }
             }