refactor for format

fishercoder1534 · fishercoder1534 · commit 9bb4255c4610 · 2017-08-22T20:08:23.000-07:00
diff --git a/src/main/java/com/fishercoder/solutions/_55.java b/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));
     }
 }
diff --git a/src/main/java/com/fishercoder/solutions/_554.java b/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);
             }
         }
diff --git a/src/main/java/com/fishercoder/solutions/_555.java b/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++) {
diff --git a/src/main/java/com/fishercoder/solutions/_556.java b/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;
         }
     }
diff --git a/src/main/java/com/fishercoder/solutions/_557.java b/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();
     }
 
diff --git a/src/main/java/com/fishercoder/solutions/_56.java b/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));
     }
 
diff --git a/src/main/java/com/fishercoder/solutions/_560.java b/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);
         }
diff --git a/src/main/java/com/fishercoder/solutions/_566.java b/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;
diff --git a/src/main/java/com/fishercoder/solutions/_572.java b/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);
     }
 }
diff --git a/src/main/java/com/fishercoder/solutions/_575.java b/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++;
             }
diff --git a/src/main/java/com/fishercoder/solutions/_58.java b/src/main/java/com/fishercoder/solutions/_58.java
@@ -11,10 +11,10 @@
 public class _58 {
 
     public int lengthOfLastWord(String s) {
-        if(s == null || s.length() == 0) return 0;
+        if (s == null || s.length() == 0) return 0;
         s = s.trim();
-        int n = s.length()-1;
-        while(n >= 0 && s.charAt(n) != ' '){
+        int n = s.length() - 1;
+        while (n >= 0 && s.charAt(n) != ' ') {
             n--;
         }
         return s.length() - n - 1;
diff --git a/src/main/java/com/fishercoder/solutions/_581.java b/src/main/java/com/fishercoder/solutions/_581.java
@@ -28,18 +28,20 @@ public class _581 {
      * Time: O(n)
      * Space: O(1)*/
     public int findUnsortedSubarray(int[] nums) {
-        int n = nums.length, start = -1, end = -2, min = nums[n-1], max = nums[0];
-        for (int i=1;i<n;i++) {
+        int n = nums.length, start = -1, end = -2, min = nums[n - 1], max = nums[0];
+        for (int i = 1; i < n; i++) {
             max = Math.max(max, nums[i]);
-            min = Math.min(min, nums[n-1-i]);
+            min = Math.min(min, nums[n - 1 - i]);
             if (nums[i] < max) end = i;
-            if (nums[n-1-i] > min) start = n-1-i;
+            if (nums[n - 1 - i] > min) start = n - 1 - i;
         }
         return end - start + 1;
     }
 
-    /**Time: O(nlogn)
-     * Space: O(n)*/
+    /**
+     * Time: O(nlogn)
+     * Space: O(n)
+     */
     public int findUnsortedSubarray_sorting(int[] nums) {
         int[] clones = nums.clone();
         Arrays.sort(clones);
@@ -51,7 +53,7 @@ public int findUnsortedSubarray_sorting(int[] nums) {
                 end = Math.max(end, i);
             }
         }
-        return (end - start > 0) ? end-start+1 : 0;
+        return (end - start > 0) ? end - start + 1 : 0;
     }
 
 }
diff --git a/src/main/java/com/fishercoder/solutions/_583.java b/src/main/java/com/fishercoder/solutions/_583.java
@@ -20,13 +20,13 @@ public class _583 {
     public int minDistance(String word1, String word2) {
         int m = word1.length();
         int n = word2.length();
-        int[][] dp = new int[m+1][n+1];
+        int[][] dp = new int[m + 1][n + 1];
         for (int i = 1; i <= m; i++) {
             for (int j = 1; j <= n; j++) {
-                dp[i][j] = word1.charAt(i-1) == word2.charAt(j-1) ? dp[i-1][j-1]+1 : Math.max(dp[i-1][j], dp[i][j-1]);
+                dp[i][j] = word1.charAt(i - 1) == word2.charAt(j - 1) ? dp[i - 1][j - 1] + 1 : Math.max(dp[i - 1][j], dp[i][j - 1]);
             }
         }
-        return m + n - 2*dp[m][n];
+        return m + n - 2 * dp[m][n];
     }
 
 }
diff --git a/src/main/java/com/fishercoder/solutions/_59.java b/src/main/java/com/fishercoder/solutions/_59.java
@@ -18,28 +18,29 @@ public class _59 {
     public int[][] generateMatrix(int num) {
         int temp = num;
         int[][] fourEdges = new int[num][num];
-        int  value = 1;
+        int value = 1;
         int i = 0, j = 0;
-        if(num%2 == 0) {//when num is even
-            while(i < num/2 && j < num/2 && temp >= 0) {
-				/* Assign the top row */
-                while(j < temp) {
+        if (num % 2 == 0) {
+            //when num is even
+            while (i < num / 2 && j < num / 2 && temp >= 0) {
+                /* Assign the top row */
+                while (j < temp) {
                     fourEdges[i][j] = value;
                     j++;
                     value++;
 
                 }
 
 				/* Assign the right column */
-                while(i < temp - 1) {
+                while (i < temp - 1) {
                     i++;
                     fourEdges[i][j - 1] = value;
                     value++;
                 }
                 j = j - 2;
 
 				/* Assign the bottom row */
-                while(j >= num - temp) {
+                while (j >= num - temp) {
                     fourEdges[i][j] = value;
                     j--;
                     value++;
@@ -48,7 +49,7 @@ public int[][] generateMatrix(int num) {
                 j++;
 
 				/* Assign the left column */
-                while(i > num - temp) {
+                while (i > num - temp) {
                     fourEdges[i][j] = value;
                     i--;
                     value++;
@@ -59,26 +60,27 @@ public int[][] generateMatrix(int num) {
                 temp--;
             }
 
-        } else {//when num is odd
-            while(i < num/2 && j < num/2 && temp >= 0) {
-				/* Assign the top row */
-                while(j < temp) {
+        } else {
+            //when num is odd
+            while (i < num / 2 && j < num / 2 && temp >= 0) {
+                /* Assign the top row */
+                while (j < temp) {
                     fourEdges[i][j] = value;
                     j++;
                     value++;
 
                 }
 
 				/* Assign the right column */
-                while(i < temp - 1){
+                while (i < temp - 1) {
                     i++;
                     fourEdges[i][j - 1] = value;
                     value++;
                 }
                 j = j - 2;
 
 				/* Assign the bottom row */
-                while(j >= num - temp){
+                while (j >= num - temp) {
                     fourEdges[i][j] = value;
                     j--;
                     value++;
@@ -87,7 +89,7 @@ public int[][] generateMatrix(int num) {
                 j++;
 
 				/* Assign the left column */
-                while(i > num - temp){
+                while (i > num - temp) {
                     fourEdges[i][j] = value;
                     i--;
                     value++;
@@ -97,13 +99,13 @@ public int[][] generateMatrix(int num) {
                 j++;
                 temp--;
             }
-            fourEdges[num/2][num/2] = num*num;
+            fourEdges[num / 2][num / 2] = num * num;
         }
 
-        for(int m = 0; m < num; m++){
-            for(int n = 0; n < num; n++){
+        for (int m = 0; m < num; m++) {
+            for (int n = 0; n < num; n++) {
                 System.out.print(fourEdges[m][n] + "\t");
-                if((n+1) % num == 0) {
+                if ((n + 1) % num == 0) {
                     System.out.println();
                 }
             }
diff --git a/src/main/java/com/fishercoder/solutions/_591.java b/src/main/java/com/fishercoder/solutions/_591.java
diff --git a/src/main/java/com/fishercoder/solutions/_592.java b/src/main/java/com/fishercoder/solutions/_592.java
diff --git a/src/main/java/com/fishercoder/solutions/_593.java b/src/main/java/com/fishercoder/solutions/_593.java
diff --git a/src/main/java/com/fishercoder/solutions/_594.java b/src/main/java/com/fishercoder/solutions/_594.java
diff --git a/src/main/java/com/fishercoder/solutions/_598.java b/src/main/java/com/fishercoder/solutions/_598.java

Original file line number	Diff line number	Diff line change
`@@ -11,37 +11,37 @@`
`11`	`11`
`12`	`12`	`A = [3,2,1,0,4], return false.*/`
`13`	`13`	`public class _55 {`
`14`		`-`
	`14`	`+`
`15`	`15`	`public static boolean canJump_greedy(int[] nums) {`
`16`	`16`	`int farthest = nums[0];`
`17`		`- for(int i = 0; i < nums.length; i++){`
`18`		`- if(i <= farthest && nums[i]+i > farthest) {`
	`17`	`+ for (int i = 0; i < nums.length; i++) {`
	`18`	`+ if (i <= farthest && nums[i] + i > farthest) {`
`19`	`19`	`//i <= farthest is to make sure that this current i is within the current range`
`20`	`20`	`// nums[i]+i > farthest is to make sure that it's necessary to update farthest with current nums[i]+i`
`21`		`- farthest = nums[i]+i;`
	`21`	`+ farthest = nums[i] + i;`
`22`	`22`	`}`
`23`	`23`	`}`
`24`		`- return farthest >= nums.length-1;`
	`24`	`+ return farthest >= nums.length - 1;`
`25`	`25`	`}`
`26`	`26`
`27`	`27`	`//this normal dp ends in TLE for extreme test cases`
`28`	`28`	`public static boolean canJump_dp(int[] nums) {`
`29`	`29`	`boolean[] can = new boolean[nums.length];`
`30`	`30`	`can[0] = true;`
`31`		`- for(int i = 0; i < nums.length; i++){`
	`31`	`+ for (int i = 0; i < nums.length; i++) {`
`32`	`32`	`int reach = nums[i];`
`33`		`- if(can[i]){`
`34`		`- for(int j = i+1; j < nums.length && j <= i+reach; j++){`
	`33`	`+ if (can[i]) {`
	`34`	`+ for (int j = i + 1; j < nums.length && j <= i + reach; j++) {`
`35`	`35`	`can[j] = true;`
`36`	`36`	`}`
`37`	`37`	`}`
`38`	`38`	`}`
`39`		`- return can[nums.length-1];`
	`39`	`+ return can[nums.length - 1];`
`40`	`40`	`}`
`41`	`41`
`42`		`- public static void main(String...strings){`
	`42`	`+ public static void main(String... strings) {`
`43`	`43`	`// int[] nums = new int[]{1,2};`
`44`		`- int[] nums = new int[]{0,2,3};`
	`44`	`+ int[] nums = new int[]{0, 2, 3};`
`45`	`45`	`System.out.println(canJump_greedy(nums));`
`46`	`46`	`}`
`47`	`47`	`}`
Original file line number	Diff line number	Diff line change
`@@ -49,9 +49,10 @@ public int leastBricks(List> wall) {`
`49`	`49`	`Map<Integer, Integer> map = new HashMap();`
`50`	`50`	`for (List<Integer> row : wall) {`
`51`	`51`	`int sum = 0;`
`52`		`- for (int i = 0; i < row.size()-1; i++) {//NOTE: i < row.size()-1`
	`52`	`+ for (int i = 0; i < row.size() - 1; i++) {`
	`53`	`+ //NOTE: i < row.size()-1`
`53`	`54`	`sum += row.get(i);`
`54`		`- if (map.containsKey(sum)) map.put(sum, map.get(sum)+1);`
	`55`	`+ if (map.containsKey(sum)) map.put(sum, map.get(sum) + 1);`
`55`	`56`	`else map.put(sum, 1);`
`56`	`57`	`}`
`57`	`58`	`}`
Original file line number	Diff line number	Diff line change
`@@ -43,7 +43,7 @@ public String splitLoopedString(String[] strs) {`
`43`	`43`	`for (String str : new String[]{strs[i], reverse}) {`
`44`	`44`	`for (int k = 0; k < str.length(); k++) {`
`45`	`45`	`StringBuilder sb = new StringBuilder(str.substring(k));`
`46`		`- for (int j = i+1; j < strs.length; j++) {`
	`46`	`+ for (int j = i + 1; j < strs.length; j++) {`
`47`	`47`	`sb.append(strs[j]);`
`48`	`48`	`}`
`49`	`49`	`for (int j = 0; j < i; j++) {`
Original file line number	Diff line number	Diff line change
`@@ -21,16 +21,16 @@ public int nextGreaterElement(int n) {`
`21`	`21`	`while (i >= 0 && digits[i + 1] <= digits[i]) {`
`22`	`22`	`i--;`
`23`	`23`	`}`
`24`		`- if(i<0) return -1;`
	`24`	`+ if (i < 0) return -1;`
`25`	`25`	`int j = digits.length - 1;`
`26`	`26`	`while (j >= 0 && digits[j] <= digits[i]) {`
`27`	`27`	`j--;`
`28`	`28`	`}`
`29`	`29`	`swap(digits, i, j);`
`30`	`30`	`reverse(digits, i + 1);`
`31`		`- try{`
	`31`	`+ try {`
`32`	`32`	`return Integer.parseInt(new String(digits));`
`33`		`- } catch(Exception e){`
	`33`	`+ } catch (Exception e) {`
`34`	`34`	`return -1;`
`35`	`35`	`}`
`36`	`36`	`}`
Original file line number	Diff line number	Diff line change
`@@ -19,7 +19,7 @@ public String reverseWords(String s) {`
`19`	`19`	`stringBuilder.append(sbUtils.reverse().toString());`
`20`	`20`	`stringBuilder.append(" ");`
`21`	`21`	`}`
`22`		`- stringBuilder.setLength(stringBuilder.length()-1);`
	`22`	`+ stringBuilder.setLength(stringBuilder.length() - 1);`
`23`	`23`	`return stringBuilder.toString();`
`24`	`24`	`}`
`25`	`25`
Original file line number	Diff line number	Diff line change
`@@ -33,7 +33,7 @@ public int subarraySum(int[] nums, int k) {`
`33`	`33`	`for (int i = 0; i < nums.length; i++) {`
`34`	`34`	`sum += nums[i];`
`35`	`35`	`if (preSum.containsKey(sum - k)) {`
`36`		`- result += preSum.get(sum-k);`
	`36`	`+ result += preSum.get(sum - k);`
`37`	`37`	`}`
`38`	`38`	`preSum.put(sum, preSum.getOrDefault(sum, 0) + 1);`
`39`	`39`	`}`
Original file line number	Diff line number	Diff line change
`@@ -47,7 +47,7 @@ public boolean isSubtree(TreeNode s, TreeNode t) {`
`47`	`47`	`if (s != null && t != null && s.val == t.val) isSubTree = isSameTree(s, t);`
`48`	`48`	`if (isSubTree) return true;`
`49`	`49`	`boolean isSubTreeLeft = false;`
`50`		`- if (s.left != null) isSubTreeLeft= isSubtree(s.left, t);`
	`50`	`+ if (s.left != null) isSubTreeLeft = isSubtree(s.left, t);`
`51`	`51`	`if (isSubTreeLeft) return true;`
`52`	`52`	`boolean isSubTreeRight = false;`
`53`	`53`	`if (s.right != null) isSubTreeRight = isSubtree(s.right, t);`
`@@ -56,7 +56,7 @@ public boolean isSubtree(TreeNode s, TreeNode t) {`
`56`	`56`	`}`
`57`	`57`
`58`	`58`	`private boolean isSameTree(TreeNode p, TreeNode q) {`
`59`		`- if(p == null \|\| q == null) return p == q;`
	`59`	`+ if (p == null \|\| q == null) return p == q;`
`60`	`60`	`return p.val == q.val && isSameTree(p.left, q.left) && isSameTree(p.right, q.right);`
`61`	`61`	`}`
`62`	`62`	`}`
Original file line number	Diff line number	Diff line change
`@@ -31,7 +31,7 @@ public int distributeCandies(int[] candies) {`
`31`	`31`	`for (int i = 0; i < candies.length; i++) {`
`32`	`32`	`int val = candies[i];`
`33`	`33`	`sisCount++;`
`34`		`- if (sisCount >= candies.length/2) return candies.length/2;`
	`34`	`+ if (sisCount >= candies.length / 2) return candies.length / 2;`
`35`	`35`	`while (i < candies.length && candies[i] == val) {`
`36`	`36`	`i++;`
`37`	`37`	`}`