refactor for format

Author: fishercoder1534

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

@@ -11,37 +11,37 @@
 
  A = [3,2,1,0,4], return false.*/
 public class _55 {
-    
+
     public static boolean canJump_greedy(int[] nums) {
         int farthest = nums[0];
-        for(int i = 0; i < nums.length; i++){
-            if(i <= farthest && nums[i]+i > farthest) {
+        for (int i = 0; i < nums.length; i++) {
+            if (i <= farthest && nums[i] + i > farthest) {
                 //i <= farthest is to make sure that this current i is within the current range
                 // nums[i]+i > farthest is to make sure that it's necessary to update farthest with current nums[i]+i
-                farthest = nums[i]+i;
+                farthest = nums[i] + i;
             }
         }
-        return farthest >= nums.length-1;
+        return farthest >= nums.length - 1;
     }
 
     //this normal dp ends in TLE for extreme test cases
     public static boolean canJump_dp(int[] nums) {
         boolean[] can = new boolean[nums.length];
         can[0] = true;
-        for(int i = 0; i < nums.length; i++){
+        for (int i = 0; i < nums.length; i++) {
             int reach = nums[i];
-            if(can[i]){
-                for(int j = i+1; j < nums.length && j <= i+reach; j++){
+            if (can[i]) {
+                for (int j = i + 1; j < nums.length && j <= i + reach; j++) {
                     can[j] = true;
                 }
             }
         }
-        return can[nums.length-1];
+        return can[nums.length - 1];
     }
 
-    public static void main(String...strings){
+    public static void main(String... strings) {
 //        int[] nums = new int[]{1,2};
-        int[] nums = new int[]{0,2,3};
+        int[] nums = new int[]{0, 2, 3};
         System.out.println(canJump_greedy(nums));
     }
 }

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

@@ -49,9 +49,10 @@ public int leastBricks(List<List<Integer>> wall) {
         Map<Integer, Integer> map = new HashMap();
         for (List<Integer> row : wall) {
             int sum = 0;
-            for (int i = 0; i < row.size()-1; i++) {//NOTE: i < row.size()-1
+            for (int i = 0; i < row.size() - 1; i++) {
+                //NOTE: i < row.size()-1
                 sum += row.get(i);
-                if (map.containsKey(sum)) map.put(sum, map.get(sum)+1);
+                if (map.containsKey(sum)) map.put(sum, map.get(sum) + 1);
                 else map.put(sum, 1);
             }
         }

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

@@ -43,7 +43,7 @@ public String splitLoopedString(String[] strs) {
             for (String str : new String[]{strs[i], reverse}) {
                 for (int k = 0; k < str.length(); k++) {
                     StringBuilder sb = new StringBuilder(str.substring(k));
-                    for (int j = i+1; j < strs.length; j++) {
+                    for (int j = i + 1; j < strs.length; j++) {
                         sb.append(strs[j]);
                     }
                     for (int j = 0; j < i; j++) {

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

@@ -21,16 +21,16 @@ public int nextGreaterElement(int n) {
         while (i >= 0 && digits[i + 1] <= digits[i]) {
             i--;
         }
-        if(i<0) return -1;
+        if (i < 0) return -1;
         int j = digits.length - 1;
         while (j >= 0 && digits[j] <= digits[i]) {
             j--;
         }
         swap(digits, i, j);
         reverse(digits, i + 1);
-        try{
+        try {
             return Integer.parseInt(new String(digits));
-        } catch(Exception e){
+        } catch (Exception e) {
             return -1;
         }
     }

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

@@ -19,7 +19,7 @@ public String reverseWords(String s) {
             stringBuilder.append(sbUtils.reverse().toString());
             stringBuilder.append(" ");
         }
-        stringBuilder.setLength(stringBuilder.length()-1);
+        stringBuilder.setLength(stringBuilder.length() - 1);
         return stringBuilder.toString();
     }
 

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

@@ -18,7 +18,7 @@
 public class _56 {
 
     public static List<Interval> merge(List<Interval> intervals) {
-        if(intervals.size() <= 1) return intervals;
+        if (intervals.size() <= 1) return intervals;
 
         Collections.sort(intervals, new Comparator<Interval>() {
             @Override
@@ -28,10 +28,10 @@ public int compare(Interval o1, Interval o2) {
         });
 
         List<Interval> result = new ArrayList();
-        for(int i = 0; i < intervals.size(); i++){
+        for (int i = 0; i < intervals.size(); i++) {
             int start = intervals.get(i).start;
             int end = intervals.get(i).end;
-            while(i < intervals.size() && end >= intervals.get(i).start){
+            while (i < intervals.size() && end >= intervals.get(i).start) {
                 end = Math.max(end, intervals.get(i).end);
                 i++;
             }
@@ -41,7 +41,7 @@ public int compare(Interval o1, Interval o2) {
         return result;
     }
 
-    public static void main(String[] args){
+    public static void main(String[] args) {
         List<Interval> list = new ArrayList<Interval>();
 //        //test case 1:
 //    	list.add(new Interval(2,3));
@@ -51,10 +51,10 @@ public static void main(String[] args){
 //    	list.add(new Interval(3,4));
 
         //test case 2:
-        list.add(new Interval(1,3));
-        list.add(new Interval(2,6));
-        list.add(new Interval(8,10));
-        list.add(new Interval(15,18));
+        list.add(new Interval(1, 3));
+        list.add(new Interval(2, 6));
+        list.add(new Interval(8, 10));
+        list.add(new Interval(15, 18));
         CommonUtils.printList(merge(list));
     }
 

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

@@ -33,7 +33,7 @@ public int subarraySum(int[] nums, int k) {
         for (int i = 0; i < nums.length; i++) {
             sum += nums[i];
             if (preSum.containsKey(sum - k)) {
-                result += preSum.get(sum-k);
+                result += preSum.get(sum - k);
             }
             preSum.put(sum, preSum.getOrDefault(sum, 0) + 1);
         }

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

@@ -41,12 +41,12 @@ public int[][] matrixReshape(int[][] nums, int r, int c) {
         if (nums == null || nums.length == 0) return nums;
         int m = nums.length;
         int n = nums[0].length;
-        if (r*c > m*n) return nums;
+        if (r * c > m * n) return nums;
         int k = 0;
         int[][] result = new int[r][c];
         for (int i = 0; i < r; i++) {
             for (int j = 0; j < c; j++, k++) {
-                result[i][j] = nums[k/n][k%n];
+                result[i][j] = nums[k / n][k % n];
             }
         }
         return result;

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

@@ -47,7 +47,7 @@ public boolean isSubtree(TreeNode s, TreeNode t) {
         if (s != null && t != null && s.val == t.val) isSubTree = isSameTree(s, t);
         if (isSubTree) return true;
         boolean isSubTreeLeft = false;
-        if (s.left != null) isSubTreeLeft= isSubtree(s.left, t);
+        if (s.left != null) isSubTreeLeft = isSubtree(s.left, t);
         if (isSubTreeLeft) return true;
         boolean isSubTreeRight = false;
         if (s.right != null) isSubTreeRight = isSubtree(s.right, t);
@@ -56,7 +56,7 @@ public boolean isSubtree(TreeNode s, TreeNode t) {
     }
 
     private boolean isSameTree(TreeNode p, TreeNode q) {
-        if(p == null || q == null) return p == q;
+        if (p == null || q == null) return p == q;
         return p.val == q.val && isSameTree(p.left, q.left) && isSameTree(p.right, q.right);
     }
 }

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

@@ -31,7 +31,7 @@ public int distributeCandies(int[] candies) {
         for (int i = 0; i < candies.length; i++) {
             int val = candies[i];
             sisCount++;
-            if (sisCount >= candies.length/2) return candies.length/2;
+            if (sisCount >= candies.length / 2) return candies.length / 2;
             while (i < candies.length && candies[i] == val) {
                 i++;
             }