refactor for format

Author: fishercoder1534

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

@@ -33,17 +33,23 @@ public boolean canPlaceFlowers_more_concise_version(int[] flowerbed, int n) {
                 count++;
                 flowerbed[i] = 1;
             }
-            if (count >= n) return true;
+            if (count >= n) {
+                return true;
+            }
             i++;
         }
-        if (count >= n) return true;
+        if (count >= n) {
+            return true;
+        }
         return false;
     }
 
     public boolean canPlaceFlowers(int[] flowerbed, int n) {
         int len = flowerbed.length;
         if (len == 1) {
-            if ((flowerbed[0] == 0 && n <= 1) || n == 0) return true;
+            if ((flowerbed[0] == 0 && n <= 1) || n == 0) {
+                return true;
+            }
             return false;
         }
         if (flowerbed[0] == 0 && flowerbed[1] == 0) {
@@ -55,10 +61,16 @@ public boolean canPlaceFlowers(int[] flowerbed, int n) {
                 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 (n <= 0) {
+                return true;
+            }
+        }
+        if (len >= 2 && flowerbed[len-2] == 0 && flowerbed[len-1] == 0) {
+            n--;
+        }
+        if (n <= 0) {
+            return true;
         }
-        if (len >= 2 && flowerbed[len-2] == 0 && flowerbed[len-1] == 0) n--;
-        if (n <= 0) return true;
         return false;
     }
 

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

@@ -40,13 +40,21 @@
 public class _606 {
 
     public String tree2str(TreeNode t) {
-        if (t == null) return "";
+        if (t == null) {
+            return "";
+        }
         String result = "" + t.val;
         String left = tree2str(t.left);
         String right = tree2str(t.right);
-        if (left.equals("") && right.equals("")) return result;
-        if (left.equals("")) return result + "()(" + right + ")";
-        if (right.equals("")) return result + "(" + left + ")";
+        if (left.equals("") && right.equals("")) {
+            return result;
+        }
+        if (left.equals("")) {
+            return result + "()(" + right + ")";
+        }
+        if (right.equals("")) {
+            return result + "(" + left + ")";
+        }
         return result + "(" + left + ")(" + right + ")";
     }
 

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

@@ -16,7 +16,9 @@ public class _61 {
     //credit: https://discuss.leetcode.com/topic/26364/clean-java-solution-with-brief-explanation
     //link the tail of the linked list to the head to form a circle, then count to find the pint and cut it
     public ListNode rotateRight(ListNode head, int k) {
-        if (head == null) return head;
+        if (head == null) {
+            return head;
+        }
         ListNode copyHead = head;
         int len = 1;
         while (copyHead.next != null) {

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

@@ -27,7 +27,9 @@ public class _611 {
      * If so, then these three could form a valid triangle.*/
 
     public int triangleNumber(int[] nums) {
-        if (nums == null || nums.length == 0) return 0;
+        if (nums == null || nums.length == 0) {
+            return 0;
+        }
         Arrays.sort(nums);
         int triplets = 0;
         for (int i = 2; i < nums.length; i++) {

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

@@ -47,7 +47,9 @@ public String addBoldTag(String s, String[] dict) {
                 continue;
             }
             int j = i;
-            while (j < s.length() && shouldBold[j]) j++;
+            while (j < s.length() && shouldBold[j]) {
+                j++;
+            }
             stringBuilder.append("<b>" + s.substring(i, j) + "</b>");
             i = j-1;
         }

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

@@ -32,8 +32,12 @@
 public class _617 {
 
     public TreeNode mergeTrees(TreeNode t1, TreeNode t2) {
-        if (t1 == null) return t2;
-        if (t2 == null) return t1;
+        if (t1 == null) {
+            return t2;
+        }
+        if (t2 == null) {
+            return t1;
+        }
         TreeNode mergedNode = null;
         if (t1 != null && t2 != null) {
             mergedNode = new TreeNode(t1.val + t2.val);

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

@@ -16,14 +16,22 @@ 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++) dp[i][0] = 1;
-        for(int i = 0; i < n; i++) dp[0][i] = 1;
+        for(int i = 0; i < m; i++) {
+            dp[i][0] = 1;
+        }
+        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++){
                 int ways = 0;
-                if(i-1 >= 0) ways += dp[i-1][j];
-                if(j-1 >= 0) ways += dp[i][j-1];
+                if(i-1 >= 0) {
+                    ways += dp[i-1][j];
+                }
+                if(j-1 >= 0) {
+                    ways += dp[i][j-1];
+                }
                 dp[i][j] = ways;
             }
         }
@@ -36,8 +44,11 @@ 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) dp[i][j] = 1;
-                else dp[i][j] = dp[i-1][j] + dp[i][j-1];
+                if(i == 0 || j == 0) {
+                    dp[i][j] = 1;
+                } else {
+                    dp[i][j] = dp[i-1][j] + dp[i][j-1];
+                }
             }
         }
         return dp[m-1][n-1];

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

@@ -49,7 +49,9 @@ public int leastInterval(char[] tasks, int n) {
                     }
                 }
                 times++;
-                if (maxHeap.isEmpty() && temp.size() == 0) break;
+                if (maxHeap.isEmpty() && temp.size() == 0) {
+                    break;
+                }
                 i++;
             }
             for (Task task : temp) {

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

@@ -82,7 +82,9 @@ public TreeNode addOneRow(TreeNode root, int v, int d) {
     }
 
     private void dfs(TreeNode root, int v, int d) {
-        if (root == null) return;;
+        if (root == null) {
+            return;
+        }
         if (d == 2) {
             TreeNode newLeft = new TreeNode(v);
             TreeNode newRight = new TreeNode(v);

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

@@ -28,7 +28,9 @@ public class _625 {
      * and https://leetcode.com/articles/minimum-factorization/#approach-3-using-factorizationaccepted*/
     public int smallestFactorization(int a) {
         //case 1: a < 10
-        if (a < 10) return a;
+        if (a < 10) {
+            return a;
+        }
 
         //case 2: start with 9 and try every possible digit
         List<Integer> resultArray = new ArrayList<>();
@@ -41,13 +43,17 @@ public int smallestFactorization(int a) {
         }
 
         //if a could not be broken in form of digits, return 0
-        if (a != 0) return 0;
+        if (a != 0) {
+            return 0;
+        }
 
         //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);
-            if (result > Integer.MAX_VALUE) return 0;
+            if (result > Integer.MAX_VALUE) {
+                return 0;
+            }
         }
         return (int) result;
     }

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

@@ -30,16 +30,22 @@ public class _629 {
      * https://discuss.leetcode.com/topic/93815/java-dp-o-nk-solution*/
     public int kInversePairs(int n, int k) {
         int mod = 1000000007;
-        if (k > n*(n-1)/2 || k < 0) return 0;
-        if (k == 0 || k == n*(n-1)/2) return 1;
+        if (k > n*(n-1)/2 || k < 0) {
+            return 0;
+        }
+        if (k == 0 || k == n*(n-1)/2) {
+            return 1;
+        }
         long[][] dp = new long[n+1][k+1];
         dp[2][0] = 1;
         dp[2][1] = 1;
         for (int i = 3; i <= n; i++) {
             dp[i][0] = 1;
             for (int j = 1; j <= Math.min(k, i*(i-1)/2); j++) {
                 dp[i][j] = dp[i][j-1] + dp[i-1][j];
-                if (j >= i) dp[i][j] -= dp[i-1][j-i];
+                if (j >= i) {
+                    dp[i][j] -= dp[i-1][j-i];
+                }
                 dp[i][j] = (dp[i][j]+mod) % mod;
             }
         }