refactor format

Author: fishercoder1534

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

@@ -17,24 +17,25 @@ public class _6 {
 
     public String convert(String s, int numRows) {
         StringBuilder[] sb = new StringBuilder[numRows];
-        char[] c= s.toCharArray();
+        char[] c = s.toCharArray();
         int len = s.length();
-        for(int i = 0; i < numRows; i++){
+        for (int i = 0; i < numRows; i++) {
             sb[i] = new StringBuilder();//this is an important step to initialize it
         }
         int i = 0;
-        while(i < len){
-            for(int index = 0; index < numRows && i < len; index++){
+        while (i < len) {
+            for (int index = 0; index < numRows && i < len; index++) {
                 sb[index].append(c[i++]);// vertically down
             }
-            
-            for(int index = numRows - 2; index >= 1 && i < len; index--){/**Why it should start from numRows - 2? Think of the example when numRows = 3
-            the starting point of obliquely going up is 1, which is numRows-2.*/
+
+            for (int index = numRows - 2; index >= 1 && i < len; index--) {
+                /**Why it should start from numRows - 2? Think of the example when numRows = 3
+             the starting point of obliquely going up is 1, which is numRows-2.*/
                 sb[index].append(c[i++]);// obliquely up
             }
         }
-        
-        for(i = 1; i < numRows; i++){
+
+        for (i = 1; i < numRows; i++) {
             sb[0].append(sb[i]);
         }
         return sb[0].toString();

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

@@ -23,7 +23,9 @@
 public class _600 {
 
     public static class DPSolution {
-        /**Credit: https://leetcode.com/articles/non-negative-integers-without-consecutive-ones/#approach-3-using-bit-manipulation-accepted*/
+        /**
+         * Credit: https://leetcode.com/articles/non-negative-integers-without-consecutive-ones/#approach-3-using-bit-manipulation-accepted
+         */
         public int findIntegers(int num) {
             int[] f = new int[32];
             f[0] = 1;
@@ -49,7 +51,9 @@ public int findIntegers(int num) {
         }
     }
 
-    /**Brute force is definitely correct, but too time consuming and resulted in TLE.*/
+    /**
+     * Brute force is definitely correct, but too time consuming and resulted in TLE.
+     */
     public int findIntegers(int num) {
         int answer = 0;
         for (int i = 0; i <= num; i++) {
@@ -62,8 +66,8 @@ public int findIntegers(int num) {
 
     private boolean hasConsecutiveOnes(int num) {
         String bin = Integer.toBinaryString(num);
-        for (int i = 0; i < bin.length()-1; i++) {
-            if (bin.charAt(i) == '1' && bin.charAt(i+1) == '1') {
+        for (int i = 0; i < bin.length() - 1; i++) {
+            if (bin.charAt(i) == '1' && bin.charAt(i + 1) == '1') {
                 return false;
             }
         }

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

@@ -48,7 +48,7 @@ public StringIterator(String compressedString) {
                 while (j < len && Character.isDigit(compressedString.charAt(j))) {
                     j++;
                 }
-                deque.addLast(new int[]{compressedString.charAt(i) - 'A', Integer.parseInt(compressedString.substring(i+1, j))});
+                deque.addLast(new int[]{compressedString.charAt(i) - 'A', Integer.parseInt(compressedString.substring(i + 1, j))});
                 i = j;
             }
         }

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

@@ -28,8 +28,8 @@ public class _605 {
     public boolean canPlaceFlowers_more_concise_version(int[] flowerbed, int n) {
         int count = 0;
         int i = 0;
-        while ( i < flowerbed.length) {
-            if (flowerbed[i] == 0 && (i == 0 || flowerbed[i-1] == 0) && (i == flowerbed.length-1 || flowerbed[i+1] == 0)) {
+        while (i < flowerbed.length) {
+            if (flowerbed[i] == 0 && (i == 0 || flowerbed[i - 1] == 0) && (i == flowerbed.length - 1 || flowerbed[i + 1] == 0)) {
                 count++;
                 flowerbed[i] = 1;
             }
@@ -56,16 +56,16 @@ public boolean canPlaceFlowers(int[] flowerbed, int n) {
             flowerbed[0] = 1;
             n--;
         }
-        for (int i = 1; i < len-1; i++) {
-            if (flowerbed[i] == 0 && flowerbed[i-1] == 0 && flowerbed[i+1] == 0) {
+        for (int i = 1; i < len - 1; i++) {
+            if (flowerbed[i] == 0 && flowerbed[i - 1] == 0 && flowerbed[i + 1] == 0) {
                 n--;
                 flowerbed[i] = 1;//modify the input, discuss this with interviwer, if not allowed, then have a copy of this input and modify copy
             }
             if (n <= 0) {
                 return true;
             }
         }
-        if (len >= 2 && flowerbed[len-2] == 0 && flowerbed[len-1] == 0) {
+        if (len >= 2 && flowerbed[len - 2] == 0 && flowerbed[len - 1] == 0) {
             n--;
         }
         if (n <= 0) {

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

@@ -57,7 +57,7 @@ public List<List<String>> findDuplicate(String[] paths) {
         for (String path : paths) {
             String[] dirAndFiles = path.split(" ");
             for (int i = 1; i < dirAndFiles.length; i++) {
-                String content = dirAndFiles[i].substring(dirAndFiles[i].indexOf("(")+1,dirAndFiles[i].indexOf(")"));
+                String content = dirAndFiles[i].substring(dirAndFiles[i].indexOf("(") + 1, dirAndFiles[i].indexOf(")"));
                 if (!map.containsKey(content)) {
                     map.put(content, new ArrayList<>());
                 }

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

@@ -26,7 +26,7 @@ public ListNode rotateRight(ListNode head, int k) {
             len++;
         }
         copyHead.next = head;//link the tail and head to make it a circle
-        for (int i = len - k%len; i > 1; i--) {
+        for (int i = len - k % len; i > 1; i--) {
             head = head.next;
         }
         copyHead = head.next;

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

@@ -33,7 +33,7 @@ public int triangleNumber(int[] nums) {
         Arrays.sort(nums);
         int triplets = 0;
         for (int i = 2; i < nums.length; i++) {
-            int left = 0, right = i-1;
+            int left = 0, right = i - 1;
             while (left < right) {
                 if (nums[i] < nums[left] + nums[right]) {
                     triplets += (right - left);

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

@@ -51,7 +51,7 @@ public String addBoldTag(String s, String[] dict) {
                 j++;
             }
             stringBuilder.append("<b>" + s.substring(i, j) + "</b>");
-            i = j-1;
+            i = j - 1;
         }
         return stringBuilder.toString();
     }

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

@@ -16,45 +16,45 @@ public class _62 {
      * position in the first row and the first column: either from left or top.*/
     public int uniquePaths(int m, int n) {
         int[][] dp = new int[m][n];
-        for(int i = 0; i < m; i++) {
+        for (int i = 0; i < m; i++) {
             dp[i][0] = 1;
         }
-        for(int i = 0; i < n; i++) {
+        for (int i = 0; i < n; i++) {
             dp[0][i] = 1;
         }
-        
-        for(int i = 1; i < m; i++){
-            for(int j = 1; j < n; j++){
+
+        for (int i = 1; i < m; i++) {
+            for (int j = 1; j < n; j++) {
                 int ways = 0;
-                if(i-1 >= 0) {
-                    ways += dp[i-1][j];
+                if (i - 1 >= 0) {
+                    ways += dp[i - 1][j];
                 }
-                if(j-1 >= 0) {
-                    ways += dp[i][j-1];
+                if (j - 1 >= 0) {
+                    ways += dp[i][j - 1];
                 }
                 dp[i][j] = ways;
             }
         }
         CommonUtils.printMatrix(dp);
-        return dp[m-1][n-1];
+        return dp[m - 1][n - 1];
     }
-    
+
     //and we can actually put the two initialization for loop into the one
     public int uniquePaths_merged_for_loop(int m, int n) {
         int[][] dp = new int[m][n];
-        for(int i = 0; i < m; i++){
-            for(int j = 0; j < n; j++){
-                if(i == 0 || j == 0) {
+        for (int i = 0; i < m; i++) {
+            for (int j = 0; j < n; j++) {
+                if (i == 0 || j == 0) {
                     dp[i][j] = 1;
                 } else {
-                    dp[i][j] = dp[i-1][j] + dp[i][j-1];
+                    dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
                 }
             }
         }
-        return dp[m-1][n-1];
+        return dp[m - 1][n - 1];
     }
-    
-    public static void main(String...strings){
+
+    public static void main(String... strings) {
         _62 test = new _62();
         int m = 1;
         int n = 2;

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

@@ -47,7 +47,7 @@ public int leastInterval(char[] tasks, int n) {
                 if (!maxHeap.isEmpty()) {
                     if (maxHeap.peek().total > 1) {
                         Task curr = maxHeap.poll();
-                        temp.add(new Task(curr.total-1, curr.character));
+                        temp.add(new Task(curr.total - 1, curr.character));
                     } else {
                         maxHeap.poll();
                     }

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

@@ -93,8 +93,8 @@ private void dfs(TreeNode root, int v, int d) {
             root.left = newLeft;
             root.right = newRight;
         } else {
-            dfs(root.left, v, d-1);
-            dfs(root.right, v, d-1);
+            dfs(root.left, v, d - 1);
+            dfs(root.right, v, d - 1);
         }
     }
 

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

@@ -34,12 +34,12 @@ public class _624 {
     public int maxDistance(int[][] arrays) {
         List<Integer> max = new ArrayList<>();
         for (int[] array : arrays) {
-            max.add(array[array.length-1]);
+            max.add(array[array.length - 1]);
         }
         Collections.sort(max);
         int ans = Integer.MIN_VALUE;
         for (int[] array : arrays) {
-            int big = array[array.length-1] == max.get(max.size()-1) ? max.get(max.size()-2) : max.get(max.size()-1);
+            int big = array[array.length - 1] == max.get(max.size() - 1) ? max.get(max.size() - 2) : max.get(max.size() - 1);
             ans = Math.max(ans, big - array[0]);
         }
         return ans;

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

@@ -37,7 +37,7 @@ public int smallestFactorization(int a) {
         for (int i = 9; i > 1; i--) {
             //if current digit divides a, then store all occurences of current digit in res
             while (a % i == 0) {
-                a = a/i;
+                a = a / i;
                 resultArray.add(i);
             }
         }
@@ -49,8 +49,8 @@ public int smallestFactorization(int a) {
 
         //get the result from the result array in reverse order
         long result = 0;
-        for (int i = resultArray.size()-1; i >=0; i--) {
-            result = result*10 + resultArray.get(i);
+        for (int i = resultArray.size() - 1; i >= 0; i--) {
+            result = result * 10 + resultArray.get(i);
             if (result > Integer.MAX_VALUE) {
                 return 0;
             }

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

@@ -41,7 +41,7 @@ private String replaceWords(String[] tokens, TrieNode root) {
             stringBuilder.append(getShortestReplacement(token, root));
             stringBuilder.append(" ");
         }
-        return stringBuilder.substring(0, stringBuilder.length()-1);
+        return stringBuilder.substring(0, stringBuilder.length() - 1);
     }
 
     private String getShortestReplacement(String token, final TrieNode root) {

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

@@ -28,7 +28,8 @@ public int minSteps(int n) {
         int[] dp = new int[n + 1];
         for (int i = 2; i <= n; i++) {
             dp[i] = i;//we assign i to dp[i] first, because for a lot of cases, e.g. for most cases when i is odd, its min steps is i itself, if it's not, we can overwrite it later
-            for (int j = i - 1; j > 1; j--) {//traverse backwards, whenever it's divisible by j, we'll update dp[i] because it's guaranteed to be smaller when j is smaller.
+            for (int j = i - 1; j > 1; j--) {
+                //traverse backwards, whenever it's divisible by j, we'll update dp[i] because it's guaranteed to be smaller when j is smaller.
                 if (i % j == 0) {
                     dp[i] = dp[j] + (i / j);
                     break;