refactor for format

fishercoder1534 · fishercoder1534 · commit 431dad471b34 · 2017-08-23T21:30:36.000-07:00
diff --git a/src/main/java/com/fishercoder/solutions/_125.java b/src/main/java/com/fishercoder/solutions/_125.java
@@ -13,7 +13,8 @@
 public class _125 {
 
     public boolean isPalindrome(String s) {
-        int i = 0, j = s.length() - 1;
+        int i = 0;
+        int j = s.length() - 1;
         char[] chars = s.toCharArray();
         while (i < j) {
             while (i < j && !Character.isLetterOrDigit(chars[i])) {
diff --git a/src/main/java/com/fishercoder/solutions/_130.java b/src/main/java/com/fishercoder/solutions/_130.java
@@ -38,7 +38,8 @@ public class _130 {
 
     public void solve(char[][] board) {
         if (board == null || board.length == 0 || board[0].length == 0) return;
-        int m = board.length, n = board[0].length;
+        int m = board.length;
+        int n = board[0].length;
         Queue<int[]> queue = new LinkedList();
         //check first row and last row and mark all those '0' on these two rows to be '+' to let them be different from other 'O',
         //at the same time, we put them into the queue to get ready for a BFS to mark all those adjacent 'O' nodes to '+' as well
diff --git a/src/main/java/com/fishercoder/solutions/_142.java b/src/main/java/com/fishercoder/solutions/_142.java
@@ -11,7 +11,8 @@
 public class _142 {
 
     public ListNode detectCycle(ListNode head) {
-        ListNode slow = head, fast = head;
+        ListNode slow = head;
+        ListNode fast = head;
         while (fast != null && fast.next != null) {
             slow = slow.next;
             fast = fast.next.next;
diff --git a/src/main/java/com/fishercoder/solutions/_143.java b/src/main/java/com/fishercoder/solutions/_143.java
@@ -20,7 +20,8 @@ public void reorderList(ListNode head) {
             return;
         }
 		/* first we use two pointers to separate this list into two parts */
-        ListNode slowNode = head, fastNode = head;
+        ListNode slowNode = head;
+        ListNode fastNode = head;
         while (fastNode.next != null) {
             fastNode = fastNode.next;
             if (fastNode.next != null) {
@@ -31,12 +32,14 @@ public void reorderList(ListNode head) {
             slowNode = slowNode.next;
         }
         // two sublist heads
-        ListNode head1 = head, head2 = slowNode.next;
+        ListNode head1 = head;
+        ListNode head2 = slowNode.next;
         // detach the two sublists;
         slowNode.next = null;
 
         // reverse the second sublist
-        ListNode cur = head2, post = cur.next;
+        ListNode cur = head2;
+        ListNode post = cur.next;
         cur.next = null;
         while (post != null) {
             ListNode temp = post.next;
@@ -47,7 +50,8 @@ public void reorderList(ListNode head) {
         head2 = cur;// the new head of the reversed sublist
 
         // merge the two sublists as required
-        ListNode p = head1, q = head2;
+        ListNode p = head1;
+        ListNode q = head2;
         while (q != null) {
             ListNode temp1 = p.next;
             ListNode temp2 = q.next;
diff --git a/src/main/java/com/fishercoder/solutions/_152.java b/src/main/java/com/fishercoder/solutions/_152.java
@@ -9,7 +9,8 @@
 public class _152 {
 
     public int maxProduct(int[] nums) {
-        int pos = nums[0], neg = nums[0];
+        int pos = nums[0];
+        int neg = nums[0];
         int max = nums[0];
         for (int i = 1; i < nums.length; i++) {
             int temp = pos;
diff --git a/src/main/java/com/fishercoder/solutions/_157.java b/src/main/java/com/fishercoder/solutions/_157.java
@@ -18,7 +18,8 @@
  */
 public class _157 {
     public int read(char[] buf, int n) {
-        int index = 0, next = 0;
+        int index = 0;
+        int next = 0;
         char[] buffer = new char[4];
         while (index < n && (next = read4(buffer)) != 0) {
             for (int i = 0; i < next && index < n; index++, i++) {
diff --git a/src/main/java/com/fishercoder/solutions/_16.java b/src/main/java/com/fishercoder/solutions/_16.java
@@ -23,7 +23,8 @@ public int threeSumClosest(int[] nums, int target) {
         }
         int sum = nums[0] + nums[1] + nums[2];
         for (int i = 0; i < nums.length - 2; i++) {
-            int left = i + 1, right = nums.length - 1;
+            int left = i + 1;
+            int right = nums.length - 1;
             while (left < right) {
                 int thisSum = nums[i] + nums[left] + nums[right];
                 if (Math.abs(target - thisSum) < Math.abs(target - sum)) {
diff --git a/src/main/java/com/fishercoder/solutions/_160.java b/src/main/java/com/fishercoder/solutions/_160.java
@@ -32,7 +32,8 @@ public class _160 {
     public static class Solution1 {
 
         public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
-            int lenA = findLen(headA), lenB = findLen(headB);
+            int lenA = findLen(headA);
+            int lenB = findLen(headB);
             /**align headA and headB to the same starting point and then move together until we find the intersection point*/
             while (lenA < lenB) {
                 headB = headB.next;
diff --git a/src/main/java/com/fishercoder/solutions/_161.java b/src/main/java/com/fishercoder/solutions/_161.java
@@ -11,7 +11,9 @@ public static boolean isOneEditDistance(String s, String t) {
             char[] longer = (s.length() > t.length()) ? schar : tchar;
             char[] shorter = (longer == schar) ? tchar : schar;
 
-            int diffCnt = 0, i = 0, j = 0;
+            int diffCnt = 0;
+            int i = 0;
+            int j = 0;
             for (; i < shorter.length && j < longer.length; ) {
                 if (longer[j] != shorter[i]) {
                     diffCnt++;
diff --git a/src/main/java/com/fishercoder/solutions/_162.java b/src/main/java/com/fishercoder/solutions/_162.java
@@ -22,7 +22,8 @@ public class _162 {
     public static int findPeakElement_Ologn(int[] nums) {
 
         if (nums == null || nums.length == 0) return 0;
-        int left = 0, right = nums.length - 1;
+        int left = 0;
+        int right = nums.length - 1;
         while (left + 1 < right) {
             int mid = left + (right - left) / 2;
             if (nums[mid] < nums[mid + 1]) {
@@ -48,7 +49,8 @@ public static void main(String... strings) {
      */
     public static int findPeakElement(int[] nums) {
         if (nums == null || nums.length == 0) return 0;
-        int n = nums.length, result = 0;
+        int n = nums.length;
+        int result = 0;
         for (int i = 0; i < n; i++) {
             if (i == 0 && n > 1 && nums[i] > nums[i + 1]) {
                 result = i;
diff --git a/src/main/java/com/fishercoder/solutions/_167.java b/src/main/java/com/fishercoder/solutions/_167.java
@@ -17,7 +17,8 @@
 public class _167 {
 
     public int[] twoSum(int[] numbers, int target) {
-        int left = 0, right = numbers.length - 1;
+        int left = 0;
+        int right = numbers.length - 1;
         int[] result = new int[2];
         while (numbers[right] > target) {
             right--;
diff --git a/src/main/java/com/fishercoder/solutions/_169.java b/src/main/java/com/fishercoder/solutions/_169.java
@@ -32,7 +32,8 @@ public int majorityElement_bit_manipulation(int[] nums) {
     //saw a really clever solution on Discuss, though it didn't use bit manipulatoin
     //this is actually applying a famous algorithm called Moore Voting algorithm: http://www.cs.utexas.edu/~moore/best-ideas/mjrty/example.html
     public int majorityElement_moore_voting_algorithm(int[] nums) {
-        int count = 1, majority = nums[0];
+        int count = 1;
+        int majority = nums[0];
         for (int i = 1; i < nums.length; i++) {
             if (count == 0) {
                 count++;
diff --git a/src/main/java/com/fishercoder/solutions/_174.java b/src/main/java/com/fishercoder/solutions/_174.java
@@ -30,7 +30,8 @@ public class _174 {
     public int calculateMinimumHP(int[][] dungeon) {
         if (dungeon == null || dungeon.length == 0) return 0;
 
-        int height = dungeon.length, width = dungeon[0].length;
+        int height = dungeon.length;
+        int width = dungeon[0].length;
         int[][] dp = new int[height][width];
         dp[height - 1][width - 1] = (dungeon[height - 1][width - 1] > 0) ? 1 : 1 - dungeon[height - 1][width - 1];
 
@@ -122,7 +123,8 @@ public static void main(String... strings) {
     public int calculateMinimumHP_attemp2_failed(int[][] dungeon) {
         if (dungeon == null || dungeon.length == 0) return 0;
 
-        int height = dungeon.length, width = dungeon[0].length;
+        int height = dungeon.length;
+        int width = dungeon[0].length;
         int[][] dp = new int[height][width];
         dp[0][0] = dungeon[0][0] > 0 ? 1 : 1 - dungeon[0][0];
 
diff --git a/src/main/java/com/fishercoder/solutions/_18.java b/src/main/java/com/fishercoder/solutions/_18.java
@@ -27,7 +27,8 @@ public List<List<Integer>> fourSum(int[] nums, int target) {
             if (i > 0 && nums[i - 1] == nums[i]) continue;
             for (int j = i + 1; j < nums.length - 2; j++) {
                 if (j > i + 1 && nums[j - 1] == nums[j]) continue;
-                int left = j + 1, right = nums.length - 1;
+                int left = j + 1;
+                int right = nums.length - 1;
                 while (left < right) {
                     int sum = nums[i] + nums[j] + nums[left] + nums[right];
                     if (sum == target) {
diff --git a/src/main/java/com/fishercoder/solutions/_459.java b/src/main/java/com/fishercoder/solutions/_459.java
@@ -22,7 +22,9 @@ public class _459 {
     /**credit: https://discuss.leetcode.com/topic/68089/repeated-substring-pattern-simple-java-solution-using-kmp*/
     public static boolean repeatedSubstringPattern(String str) {
         //build the KMP pattern.
-        int n = str.length(), cur = 0, j = 1;
+        int n = str.length();
+        int cur = 0;
+        int j = 1;
         int[] pattern = new int[n];
         pattern[0] = 0;
 
diff --git a/src/main/java/com/fishercoder/solutions/_490.java b/src/main/java/com/fishercoder/solutions/_490.java
@@ -62,13 +62,15 @@ public boolean hasPath(int[][] maze, int[] start, int[] destination) {
         final int[] directions = new int[]{-1, 0, 1, 0, -1};
         Queue<Point> queue = new LinkedList<>();
         queue.offer(new Point(start[0], start[1]));
-        int m = maze.length, n = maze[0].length;
+        int m = maze.length;
+        int n = maze[0].length;
         boolean[][] visited = new boolean[m][n];
         visited[start[0]][start[1]] = true;
 
         while (!queue.isEmpty()) {
             Point curr = queue.poll();
-            int x = curr.x, y = curr.y;//keep the original value
+            int x = curr.x;
+            int y = curr.y;//keep the original value
             for (int i = 0; i < directions.length - 1; i++) {
                 int xx = x, yy = y;//use temp variables to move
                 while (xx >= 0 && yy >= 0 && xx < m && yy < n && maze[xx][yy] == 0) {
diff --git a/src/main/java/com/fishercoder/solutions/_492.java b/src/main/java/com/fishercoder/solutions/_492.java
@@ -24,7 +24,8 @@
 public class _492 {
 
     public int[] constructRectangle(int area) {
-        int i = 0, j = area;
+        int i = 0;
+        int j = area;
         int[] result = new int[2];
         while (i <= j) {
             long product = i * j;
diff --git a/src/main/java/com/fishercoder/solutions/_499.java b/src/main/java/com/fishercoder/solutions/_499.java
@@ -56,7 +56,8 @@ public String findShortestWay(int[][] maze, int[] ball, int[] hole) {
         final int[] directions = new int[]{-1, 0, 1, 0, -1};
         Queue<Point> heap = new PriorityQueue<>();
         heap.offer(new Point(ball[0], ball[1], 0, ""));
-        int m = maze.length, n = maze[0].length;
+        int m = maze.length;
+        int n = maze[0].length;
         Point[][] points = new Point[m][n];
         for (int i = 0; i < m * n; i++) {
             points[i / n][i % n] = new Point(i / n, i % n);//initialize the length array
@@ -67,7 +68,9 @@ public String findShortestWay(int[][] maze, int[] ball, int[] hole) {
             if (points[curr.x][curr.y].compareTo(curr) <= 0) continue;//if we have already found a shorter route
             points[curr.x][curr.y] = curr;
             for (int i = 0; i < directions.length - 1; i++) {
-                int x = curr.x, y = curr.y, distance = curr.distance;//use temp variables to move
+                int x = curr.x;
+                int y = curr.y;
+                int distance = curr.distance;//use temp variables to move
                 //we need below while loop to find only "stop" points that could be put into the queue
                 while (x >= 0 && y >= 0 && x < m && y < n && maze[x][y] == 0 && (x != hole[0] || y != hole[1])) {
                     x += directions[i];
diff --git a/src/main/java/com/fishercoder/solutions/_505.java b/src/main/java/com/fishercoder/solutions/_505.java
@@ -58,7 +58,8 @@ public int shortestDistance(int[][] maze, int[] start, int[] destination) {
         final int[] directions = new int[]{-1, 0, 1, 0, -1};
         Queue<Point> queue = new LinkedList<>();
         queue.offer(new Point(start[0], start[1], 0));
-        int m = maze.length, n = maze[0].length;
+        int m = maze.length;
+        int n = maze[0].length;
         int[][] length = new int[m][n];
         for (int i = 0; i < m * n; i++) {
             length[i / n][i % n] = Integer.MAX_VALUE;//initialize the length array
@@ -69,7 +70,9 @@ public int shortestDistance(int[][] maze, int[] start, int[] destination) {
             if (length[curr.x][curr.y] <= curr.distance) continue;
             length[curr.x][curr.y] = curr.distance;
             for (int i = 0; i < directions.length - 1; i++) {
-                int x = curr.x, y = curr.y, distance = curr.distance;//use temp variables to move
+                int x = curr.x;
+                int y = curr.y;
+                int distance = curr.distance;//use temp variables to move
                 //we need below while loop to find only "stop" points that could be put into the queue
                 while (x >= 0 && y >= 0 && x < m && y < n && maze[x][y] == 0) {
                     x += directions[i];
diff --git a/src/main/java/com/fishercoder/solutions/_517.java b/src/main/java/com/fishercoder/solutions/_517.java
@@ -51,7 +51,9 @@ public int findMinMoves(int[] machines) {
         if (total % machines.length != 0) {
             return -1;
         }
-        int avg = total / machines.length, cnt = 0, max = 0;
+        int avg = total / machines.length;
+        int cnt = 0;
+        int max = 0;
         for (int load : machines) {
             cnt += load - avg; //load-avg is "gain/lose"
             max = Math.max(Math.max(max, Math.abs(cnt)), load - avg);
diff --git a/src/main/java/com/fishercoder/solutions/_53.java b/src/main/java/com/fishercoder/solutions/_53.java
@@ -8,7 +8,8 @@
  */
 public class _53 {
     public int maxSubArray(int[] nums) {
-        int maxSum = nums[0], currentSum = nums[0];
+        int maxSum = nums[0];
+        int currentSum = nums[0];
         for (int i = 1; i < nums.length; i++) {
             currentSum = Math.max(nums[i], currentSum + nums[i]);
             maxSum = Math.max(currentSum, maxSum);
diff --git a/src/main/java/com/fishercoder/solutions/_549.java b/src/main/java/com/fishercoder/solutions/_549.java
@@ -35,7 +35,8 @@ public int longestConsecutive(TreeNode root) {
 
     private int[] longestPath(TreeNode root) {
         if (root == null) return new int[]{0, 0};
-        int increasing = 1, decreasing = 1;
+        int increasing = 1;
+        int decreasing = 1;
         if (root.left != null) {
             int[] left = longestPath(root.left);
             if (root.val == root.left.val + 1) decreasing = left[1] + 1;
diff --git a/src/main/java/com/fishercoder/solutions/_556.java b/src/main/java/com/fishercoder/solutions/_556.java
@@ -36,7 +36,8 @@ public int nextGreaterElement(int n) {
     }
 
     private void reverse(char[] a, int start) {
-        int i = start, j = a.length - 1;
+        int i = start;
+        int j = a.length - 1;
         while (i < j) {
             swap(a, i, j);
             i++;
diff --git a/src/main/java/com/fishercoder/solutions/_581.java b/src/main/java/com/fishercoder/solutions/_581.java
@@ -28,7 +28,11 @@ 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];
+        int n = nums.length;
+        int start = -1;
+        int end = -2;
+        int min = nums[n - 1];
+        int max = nums[0];
         for (int i = 1; i < n; i++) {
             max = Math.max(max, nums[i]);
             min = Math.min(min, nums[n - 1 - i]);
diff --git a/src/main/java/com/fishercoder/solutions/_59.java b/src/main/java/com/fishercoder/solutions/_59.java
@@ -19,7 +19,8 @@ public int[][] generateMatrix(int num) {
         int temp = num;
         int[][] fourEdges = new int[num][num];
         int value = 1;
-        int i = 0, j = 0;
+        int i = 0;
+        int j = 0;
         if (num % 2 == 0) {
             //when num is even
             while (i < num / 2 && j < num / 2 && temp >= 0) {
diff --git a/src/main/java/com/fishercoder/solutions/_600.java b/src/main/java/com/fishercoder/solutions/_600.java
@@ -33,7 +33,9 @@ public int findIntegers(int num) {
             for (int i = 2; i < f.length; i++) {
                 f[i] = f[i - 1] + f[i - 2];
             }
-            int i = 30, sum = 0, prevBit = 0;
+            int i = 30;
+            int sum = 0;
+            int prevBit = 0;
             while (i >= 0) {
                 if ((num & (1 << i)) != 0) {
                     sum += f[i];
diff --git a/src/main/java/com/fishercoder/solutions/_611.java b/src/main/java/com/fishercoder/solutions/_611.java
@@ -33,7 +33,8 @@ 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;
+            int right = i - 1;
             while (left < right) {
                 if (nums[i] < nums[left] + nums[right]) {
                     triplets += (right - left);
diff --git a/src/main/java/com/fishercoder/solutions/_63.java b/src/main/java/com/fishercoder/solutions/_63.java
@@ -31,7 +31,8 @@ public int uniquePathsWithObstacles(int[][] obstacleGrid) {
             return 0;
         }
 
-        int height = obstacleGrid.length, width = obstacleGrid[0].length;
+        int height = obstacleGrid.length;
+        int width = obstacleGrid[0].length;
         int[][] dp = new int[height][width];
         dp[0][0] = obstacleGrid[0][0] == 1 ? 0 : 1;
         for (int i = 1; i < height; i++) {
diff --git a/src/main/java/com/fishercoder/solutions/_631.java b/src/main/java/com/fishercoder/solutions/_631.java
@@ -149,8 +149,10 @@ public HashMap<String, Integer> convert(String[] strs) {
                     res.put(st, res.getOrDefault(st, 0) + 1);
                 } else {
                     String[] cells = st.split(":");
-                    int si = Integer.parseInt(cells[0].substring(1)), ei = Integer.parseInt(cells[1].substring(1));
-                    char sj = cells[0].charAt(0), ej = cells[1].charAt(0);
+                    int si = Integer.parseInt(cells[0].substring(1));
+                    int ei = Integer.parseInt(cells[1].substring(1));
+                    char sj = cells[0].charAt(0);
+                    char ej = cells[1].charAt(0);
                     for (int i = si; i <= ei; i++) {
                         for (char j = sj; j <= ej; j++) {
                             res.put("" + j + i, res.getOrDefault("" + j + i, 0) + 1);
@@ -164,7 +166,8 @@ public HashMap<String, Integer> convert(String[] strs) {
         public int calculate_sum(int r, int c, HashMap<String, Integer> cells) {
             int sum = 0;
             for (String s : cells.keySet()) {
-                int x = Integer.parseInt(s.substring(1)) - 1, y = s.charAt(0) - 'A';
+                int x = Integer.parseInt(s.substring(1)) - 1;
+                int y = s.charAt(0) - 'A';
                 sum += (formulas[x][y] != null ? formulas[x][y].val : 0) * cells.get(s);
             }
             formulas[r][c] = new Formula(cells, sum);
diff --git a/src/main/java/com/fishercoder/solutions/_64.java b/src/main/java/com/fishercoder/solutions/_64.java
@@ -18,7 +18,8 @@ public int minPathSum(int[][] grid) {
             return 0;
         }
 
-        int height = grid.length, width = grid[0].length;
+        int height = grid.length;
+        int width = grid[0].length;
         int[][] dp = new int[height][width];
         dp[0][0] = grid[0][0];
         for (int i = 1; i < height; i++) {
diff --git a/src/main/java/com/fishercoder/solutions/_644.java b/src/main/java/com/fishercoder/solutions/_644.java
diff --git a/src/main/java/com/fishercoder/solutions/_67.java b/src/main/java/com/fishercoder/solutions/_67.java
diff --git a/src/main/java/com/fishercoder/solutions/_69.java b/src/main/java/com/fishercoder/solutions/_69.java
diff --git a/src/main/java/com/fishercoder/solutions/_72.java b/src/main/java/com/fishercoder/solutions/_72.java
diff --git a/src/main/java/com/fishercoder/solutions/_73.java b/src/main/java/com/fishercoder/solutions/_73.java
diff --git a/src/main/java/com/fishercoder/solutions/_75.java b/src/main/java/com/fishercoder/solutions/_75.java
diff --git a/src/main/java/com/fishercoder/solutions/_76.java b/src/main/java/com/fishercoder/solutions/_76.java
diff --git a/src/main/java/com/fishercoder/solutions/_79.java b/src/main/java/com/fishercoder/solutions/_79.java
diff --git a/src/main/java/com/fishercoder/solutions/_8.java b/src/main/java/com/fishercoder/solutions/_8.java
diff --git a/src/main/java/com/fishercoder/solutions/_85.java b/src/main/java/com/fishercoder/solutions/_85.java
diff --git a/src/main/java/com/fishercoder/solutions/_9.java b/src/main/java/com/fishercoder/solutions/_9.java
