refactor format

Author: fishercoder1534

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

@@ -27,23 +27,23 @@ public boolean searchMatrix(int[][] matrix, int target) {
         if (matrix == null || matrix.length == 0
                 || matrix[0].length == 0
                 || matrix[0][0] > target
-                || matrix[matrix.length-1][matrix[0].length-1] < target) {
+                || matrix[matrix.length - 1][matrix[0].length - 1] < target) {
             return false;
         }
         int m = matrix.length;
         int n = matrix[0].length;
         int left = 0;
-        int right = m * n - 1 ;
+        int right = m * n - 1;
         while (left <= right) {
-            int mid = left + (right-left)/2;
-            int row = mid/n;
-            int col = mid%n;
+            int mid = left + (right - left) / 2;
+            int row = mid / n;
+            int col = mid % n;
             if (matrix[row][col] == target) {
                 return true;
             } else if (matrix[row][col] > target) {
-                right = mid-1;
+                right = mid - 1;
             } else {
-                left = mid+1;
+                left = mid + 1;
             }
         }
         return false;

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

@@ -17,30 +17,30 @@
 public class _75 {
 
     public void sortColors(int[] nums) {
-        int zero = 0, two = nums.length-1;
-        for(int i = 0; i <= two;){
-            if(nums[i] == 0 && i > zero) {
+        int zero = 0, two = nums.length - 1;
+        for (int i = 0; i <= two; ) {
+            if (nums[i] == 0 && i > zero) {
                 swap(nums, i, zero++);
-            } else if(nums[i] == 2 && i < two) {
+            } else if (nums[i] == 2 && i < two) {
                 swap(nums, i, two--);
             } else {
                 i++;
             }
         }
     }
-    
-    void swap(int[] nums, int m, int n){
+
+    void swap(int[] nums, int m, int n) {
         int temp = nums[m];
         nums[m] = nums[n];
         nums[n] = temp;
     }
 
 
-    public static void main(String...args){
+    public static void main(String... args) {
 //        int[] nums = new int[]{0,1,2,0,2,1};
 //        int[] nums = new int[]{0};
 //        int[] nums = new int[]{2};
-        int[] nums = new int[]{2,2,1};
+        int[] nums = new int[]{2, 2, 1};
 //        int[] nums = new int[]{1,0};
     }
 }

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

@@ -17,36 +17,36 @@ public class _76 {
 
     public String minWindow(String s, String t) {
         int[] counts = new int[256];
-        for(char c : t.toCharArray()){
+        for (char c : t.toCharArray()) {
             counts[c]++;
         }
 
         int start = 0, end = 0, minStart = 0, minLen = Integer.MAX_VALUE, counter = t.length();
-        while(end < s.length()){
-            if(counts[s.charAt(end)] > 0) {
+        while (end < s.length()) {
+            if (counts[s.charAt(end)] > 0) {
                 counter--;
             }
 
             counts[s.charAt(end)]--;
             end++;
 
-            while(counter == 0){
-                if(end-start < minLen){
+            while (counter == 0) {
+                if (end - start < minLen) {
                     minStart = start;
-                    minLen = end-start;
+                    minLen = end - start;
                 }
                 counts[s.charAt(start)]++;
-                if(counts[s.charAt(start)] > 0) {
+                if (counts[s.charAt(start)] > 0) {
                     counter++;
                 }
                 start++;
             }
         }
 
-        if(minLen == Integer.MAX_VALUE) {
+        if (minLen == Integer.MAX_VALUE) {
             return "";
         }
-        return s.substring(minStart, minStart+minLen);
+        return s.substring(minStart, minStart + minLen);
     }
 
 }

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

@@ -21,22 +21,22 @@ public class _77 {
     public List<List<Integer>> combine(int n, int k) {
         List<List<Integer>> result = new ArrayList();
         int[] nums = new int[n];
-        for(int i = 0; i < n; i++){
-            nums[i] = i+1;
+        for (int i = 0; i < n; i++) {
+            nums[i] = i + 1;
         }
         backtracking(k, 0, nums, new ArrayList(), result);
         return result;
     }
-    
-    void backtracking(int k, int start, int[] nums, List<Integer> temp, List<List<Integer>> result){
-        if(temp.size() == k){
+
+    void backtracking(int k, int start, int[] nums, List<Integer> temp, List<List<Integer>> result) {
+        if (temp.size() == k) {
             List<Integer> newTemp = new ArrayList(temp);
             result.add(newTemp);
-        } else if(temp.size() < k){
-            for(int i = start; i < nums.length; i++){
+        } else if (temp.size() < k) {
+            for (int i = start; i < nums.length; i++) {
                 temp.add(nums[i]);
-                backtracking(k, i+1, nums, temp, result);
-                temp.remove(temp.size()-1);
+                backtracking(k, i + 1, nums, temp, result);
+                temp.remove(temp.size() - 1);
             }
         }
     }

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

@@ -45,10 +45,10 @@ boolean search(char[][] board, String word, int i, int j, int pos) {
                 return false;
             }
             visited[i][j] = true;
-            if (search(board, word, i+1, j, pos+1)
-                    || search(board, word, i-1, j, pos+1)
-                    || search(board, word, i, j+1, pos+1)
-                    || search(board, word, i, j-1, pos+1)) {
+            if (search(board, word, i + 1, j, pos + 1)
+                    || search(board, word, i - 1, j, pos + 1)
+                    || search(board, word, i, j + 1, pos + 1)
+                    || search(board, word, i, j - 1, pos + 1)) {
                 return true;
             }
 
@@ -58,39 +58,39 @@ boolean search(char[][] board, String word, int i, int j, int pos) {
 
     }
 
-//I made it this time, completely by myself! Cheers! This let me completely understand backtracking!
+    //I made it this time, completely by myself! Cheers! This let me completely understand backtracking!
     public boolean exist(char[][] board, String word) {
         int m = board.length, n = board[0].length;
-        for(int i = 0; i < m; i++){
-            for(int j = 0; j < n; j++){
+        for (int i = 0; i < m; i++) {
+            for (int j = 0; j < n; j++) {
                 boolean[][] visited = new boolean[m][n];
-                if(dfs(board, visited, i, j, word, 0)) {
+                if (dfs(board, visited, i, j, word, 0)) {
                     return true;
                 }
             }
         }
         return false;
     }
-    
-    final int[] dirs = new int[]{0,1,0,-1,0};
-    
-    boolean dfs(char[][] board, boolean[][] visited, int row, int col, String word, int index){
-        if(index >= word.length() || word.charAt(index) != board[row][col]) {
+
+    final int[] dirs = new int[]{0, 1, 0, -1, 0};
+
+    boolean dfs(char[][] board, boolean[][] visited, int row, int col, String word, int index) {
+        if (index >= word.length() || word.charAt(index) != board[row][col]) {
             return false;
-        } else if(index == word.length()-1 && word.charAt(index) == board[row][col]) {
+        } else if (index == word.length() - 1 && word.charAt(index) == board[row][col]) {
             visited[row][col] = true;
             return true;
         }
         visited[row][col] = true;//set it to true for this case
         boolean result = false;
-        for(int i = 0; i < 4; i++){
-            int nextRow = row+dirs[i];
-            int nextCol = col+dirs[i+1];
-            if(nextRow < 0 || nextRow >= board.length || nextCol < 0 || nextCol >= board[0].length || visited[nextRow][nextCol]) {
+        for (int i = 0; i < 4; i++) {
+            int nextRow = row + dirs[i];
+            int nextCol = col + dirs[i + 1];
+            if (nextRow < 0 || nextRow >= board.length || nextCol < 0 || nextCol >= board[0].length || visited[nextRow][nextCol]) {
                 continue;
             }
-            result = dfs(board, visited, nextRow, nextCol, word, index+1);
-            if(result) {
+            result = dfs(board, visited, nextRow, nextCol, word, index + 1);
+            if (result) {
                 return result;
             } else {
                 visited[nextRow][nextCol] = false;//set it back to false if this road doesn't work to allow it for other paths, this is backtracking!!!
@@ -99,7 +99,7 @@ boolean dfs(char[][] board, boolean[][] visited, int row, int col, String word,
         return result;
     }
 
-    public static void main(String...strings){
+    public static void main(String... strings) {
         _79 test = new _79();
 //        char[][] board = new char[][]{
 //                {'A','B','C','E'},
@@ -109,16 +109,16 @@ public static void main(String...strings){
 //        String word = "ABCCED";
 //        String word = "SEE";
 //        String word = "ABCD";
-        
+
 //        char[][] board = new char[][]{
 //                {'a','a'},
 //        };
 //        String word = "aaa";
-        
+
         char[][] board = new char[][]{
-                {'A','B','C','E'},
-                {'S','F','E','S'},
-                {'A','D','E','E'},
+                {'A', 'B', 'C', 'E'},
+                {'S', 'F', 'E', 'S'},
+                {'A', 'D', 'E', 'E'},
         };
         String word = "ABCEFSADEESE";
         System.out.println(test.exist(board, word));