enable EmptyLineSeparator check

fishercoder1534 · fishercoder1534 · commit ff24b3a71a26 · 2017-08-21T19:43:59.000-07:00
diff --git a/fishercoder_checkstyle.xml b/fishercoder_checkstyle.xml
@@ -92,9 +92,9 @@
         <module name="FallThrough"/>
         <module name="UpperEll"/>
         <module name="ModifierOrder"/>
-        <!--<module name="EmptyLineSeparator">-->
-            <!--<property name="allowNoEmptyLineBetweenFields" value="true"/>-->
-        <!--</module>-->
+        <module name="EmptyLineSeparator">
+            <property name="allowNoEmptyLineBetweenFields" value="true"/>
+        </module>
         <!--<module name="SeparatorWrap">-->
             <!--<property name="tokens" value="DOT"/>-->
             <!--<property name="option" value="nl"/>-->
diff --git a/src/main/java/com/fishercoder/common/utils/BTreePrinter.java b/src/main/java/com/fishercoder/common/utils/BTreePrinter.java
@@ -173,7 +173,8 @@ private static Node<Integer> test2() {
 
 
     public static class Node<T extends Comparable<?>> {
-        Node<T> left, right;
+        Node<T> left;
+        Node<T> right;
         T data;
 
         public Node(T data) {
diff --git a/src/main/java/com/fishercoder/common/utils/TreeUtils.java b/src/main/java/com/fishercoder/common/utils/TreeUtils.java
@@ -1,6 +1,3 @@
-/**
- * 
- */
 package com.fishercoder.common.utils;
 
 import com.fishercoder.common.classes.TreeNode;
diff --git a/src/main/java/com/fishercoder/solutions/_118.java b/src/main/java/com/fishercoder/solutions/_118.java
@@ -1,4 +1,5 @@
 package com.fishercoder.solutions;
+
 import java.util.*;
 
 /**
diff --git a/src/main/java/com/fishercoder/solutions/_119.java b/src/main/java/com/fishercoder/solutions/_119.java
@@ -1,4 +1,5 @@
 package com.fishercoder.solutions;
+
 import java.util.*;
 
 /**
diff --git a/src/main/java/com/fishercoder/solutions/_124.java b/src/main/java/com/fishercoder/solutions/_124.java
@@ -22,6 +22,7 @@
 public class _124 {
 
     int max = Integer.MIN_VALUE;
+
     public int maxPathSum(TreeNode root) {
         dfs(root);
         return max;
diff --git a/src/main/java/com/fishercoder/solutions/_138.java b/src/main/java/com/fishercoder/solutions/_138.java
@@ -35,7 +35,9 @@ public RandomListNode copyRandomList(RandomListNode head) {
     // Definition for singly-linked list with a random pointer.
     class RandomListNode {
         int label;
-        RandomListNode next, random;
+
+        RandomListNode next;
+        RandomListNode random;
 
         RandomListNode(int x) {
             this.label = x;
diff --git a/src/main/java/com/fishercoder/solutions/_140.java b/src/main/java/com/fishercoder/solutions/_140.java
@@ -1,4 +1,5 @@
 package com.fishercoder.solutions;
+
 import java.util.*;
 /**
  * Given a string s and a dictionary of words dict, add spaces in s to construct a sentence where each word is a valid dictionary word.
diff --git a/src/main/java/com/fishercoder/solutions/_141.java b/src/main/java/com/fishercoder/solutions/_141.java
@@ -1,6 +1,3 @@
-/**
- * 
- */
 package com.fishercoder.solutions;
 
 import com.fishercoder.common.classes.ListNode;
diff --git a/src/main/java/com/fishercoder/solutions/_146.java b/src/main/java/com/fishercoder/solutions/_146.java
@@ -67,8 +67,11 @@ public void set(int key, int value) {
 
     public class DoublyLinkedListPlusHashMapSolution {
         private class Node {
-            int key, value;
-            DoublyLinkedListPlusHashMapSolution.Node prev, next;
+            int key;
+            int value;
+
+            DoublyLinkedListPlusHashMapSolution.Node prev;
+            DoublyLinkedListPlusHashMapSolution.Node next;
 
             Node(int k, int v) {
                 this.key = k;
@@ -83,7 +86,8 @@ private class Node {
 
         private int capacity;
         private int count;
-        private DoublyLinkedListPlusHashMapSolution.Node head, tail;
+        private DoublyLinkedListPlusHashMapSolution.Node head;
+        private DoublyLinkedListPlusHashMapSolution.Node tail;
         private Map<Integer, DoublyLinkedListPlusHashMapSolution.Node> map;
         // ATTN: the value should be Node type! This is the whole point of having a class called Node!
 
diff --git a/src/main/java/com/fishercoder/solutions/_158.java b/src/main/java/com/fishercoder/solutions/_158.java
@@ -20,6 +20,7 @@ public class _158 {
 	private int buffPtr = 0;
 	private int buffCnt = 0;
 	private char[] buff = new char[4];
+
 	public int read(char[] buf, int n) {
 		int ptr = 0;
 		while(ptr < n){
diff --git a/src/main/java/com/fishercoder/solutions/_179.java b/src/main/java/com/fishercoder/solutions/_179.java
@@ -28,6 +28,7 @@ public String largestNumber(int[] num) {
             return "0";
         return sb.toString();
     }
+
     class StringComparator implements Comparator<String> {
         public int compare(String s1, String s2) {
             if (s1.length() == 0 && s2.length() == 0)
diff --git a/src/main/java/com/fishercoder/solutions/_189.java b/src/main/java/com/fishercoder/solutions/_189.java
@@ -1,4 +1,5 @@
 package com.fishercoder.solutions;
+
 import java.util.*;
 
 /**Rotate an array of n elements to the right by k steps.
diff --git a/src/main/java/com/fishercoder/solutions/_200.java b/src/main/java/com/fishercoder/solutions/_200.java
@@ -57,7 +57,8 @@ public static class UnionFindSolution {
 
         class UnionFind{
             int count;
-            int m, n;
+            int m;
+            int n;
             int[] ids;
 
             public UnionFind(char[][] grid){
diff --git a/src/main/java/com/fishercoder/solutions/_230.java b/src/main/java/com/fishercoder/solutions/_230.java
@@ -38,6 +38,7 @@ private void inorder(TreeNode root, List<Integer> inorderList) {
     public static class BetterWay {
         int count = 0;
         int result = Integer.MIN_VALUE;
+
         public int kthSmallest(TreeNode root, int k) {
             inorder(root, k);
             return result;
diff --git a/src/main/java/com/fishercoder/solutions/_244.java b/src/main/java/com/fishercoder/solutions/_244.java
@@ -22,6 +22,7 @@
 public class _244 {
 
     private Map<String, List<Integer>> map;
+
     public _244(String[] words) {
         map = new HashMap<String, List<Integer>>();
         for(int i = 0; i < words.length; i++) {
diff --git a/src/main/java/com/fishercoder/solutions/_248.java b/src/main/java/com/fishercoder/solutions/_248.java
@@ -71,7 +71,8 @@ class Solution1 {
             map.put('0', '0');
         }
 
-        String low = "", high = "";
+        String low = "";
+        String high = "";
 
         public int strobogrammaticInRange(String low, String high) {
             this.low = low;
diff --git a/src/main/java/com/fishercoder/solutions/_279.java b/src/main/java/com/fishercoder/solutions/_279.java
@@ -1,4 +1,5 @@
 package com.fishercoder.solutions;
+
 import java.util.*;
 /**
  * Given a positive integer n, find the least number of perfect square numbers (for example, 1, 4, 9, 16, ...) which sum to n.
diff --git a/src/main/java/com/fishercoder/solutions/_281.java b/src/main/java/com/fishercoder/solutions/_281.java
@@ -24,7 +24,9 @@
  */
 public class _281 {
 
-    private Iterator<Integer> i, j, tmp;
+    private Iterator<Integer> i;
+    private Iterator<Integer> j;
+    private Iterator<Integer> tmp;
 
     public _281(List<Integer> v1, List<Integer> v2) {
         i = v2.iterator();
diff --git a/src/main/java/com/fishercoder/solutions/_284.java b/src/main/java/com/fishercoder/solutions/_284.java
@@ -23,6 +23,7 @@ public class _284 {
     public static class PeekingIterator implements Iterator<Integer> {
 
         private Queue<Integer> queue;
+
         public PeekingIterator(Iterator<Integer> iterator) {
             // initialize any member here.
             queue = new LinkedList<>();
diff --git a/src/main/java/com/fishercoder/solutions/_286.java b/src/main/java/com/fishercoder/solutions/_286.java
@@ -27,6 +27,7 @@ public class _286 {
     class BFSSolutionWithoutQueue {
 
         int[] dirs = new int[]{0,1,0,-1,0};
+
         public void wallsAndGates(int[][] rooms) {
             if(rooms == null || rooms.length == 0 || rooms[0].length == 0) return;
             int m = rooms.length, n = rooms[0].length;
@@ -54,6 +55,7 @@ class BFSSolutionWithAQueue {
 
         //push all gates into the queue first, and then put all its neighbours into the queue with one distance to the gate, then continue to push the rest of the nodes into the queue, and put all their neighbours into the queue with the nodes' value plus one until the queue is empty
         int[] dirs = new int[]{0,1,0,-1,0};
+
         public void wallsAndGates(int[][] rooms) {
             if(rooms == null || rooms.length == 0 || rooms[0].length == 0) return;
             int m = rooms.length, n = rooms[0].length;
diff --git a/src/main/java/com/fishercoder/solutions/_298.java b/src/main/java/com/fishercoder/solutions/_298.java
@@ -30,6 +30,7 @@ The longest consecutive path need to be from parent to child (cannot be the reve
 public class _298 {
 
     private int max = 1;
+
     public int longestConsecutive(TreeNode root) {
         if (root == null) return 0;
         dfs(root, 0, root.val);
diff --git a/src/main/java/com/fishercoder/solutions/_302.java b/src/main/java/com/fishercoder/solutions/_302.java
@@ -16,6 +16,7 @@
 public class _302 {
     class Solution {
         private char[][] image;
+
         public int minArea(char[][] iImage, int x, int y) {
             image = iImage;
             int m = image.length, n = image[0].length;
@@ -25,6 +26,7 @@ public int minArea(char[][] iImage, int x, int y) {
             int bottom = searchRows(x + 1, m, left, right, false);
             return (right - left) * (bottom - top);
         }
+
         private int searchColumns(int i, int j, int top, int bottom, boolean opt) {
             while (i != j) {
                 int k = top, mid = (i + j) / 2;
@@ -36,6 +38,7 @@ private int searchColumns(int i, int j, int top, int bottom, boolean opt) {
             }
             return i;
         }
+
         private int searchRows(int i, int j, int left, int right, boolean opt) {
             while (i != j) {
                 int k = left, mid = (i + j) / 2;
diff --git a/src/main/java/com/fishercoder/solutions/_315.java b/src/main/java/com/fishercoder/solutions/_315.java
@@ -28,6 +28,7 @@ class Node{
         int dup = 1;
         Node left;
         Node right;
+
         public Node(int v, int s){
             this.val = v;
             this.sum = s;
diff --git a/src/main/java/com/fishercoder/solutions/_322.java b/src/main/java/com/fishercoder/solutions/_322.java
@@ -1,4 +1,5 @@
 package com.fishercoder.solutions;
+
 import java.util.*;
 /**
  * You are given coins of different denominations and a total amount of money amount. Write a function to compute the fewest number of coins that you need to make up that amount. If that amount of money cannot be made up by any combination of the coins, return -1.
diff --git a/src/main/java/com/fishercoder/solutions/_33.java b/src/main/java/com/fishercoder/solutions/_33.java
@@ -29,7 +29,9 @@ public int search(int[] nums, int target) {
     }
 
     public int findMinIdx(int[] nums) {
-        int start = 0, end = nums.length - 1;
+        int start = 0;
+        int end = nums.length - 1;
+
         while (start < end) {
             int mid = start + (end -  start) / 2;
             if (nums[mid] > nums[end]) start = mid + 1;
diff --git a/src/main/java/com/fishercoder/solutions/_341.java b/src/main/java/com/fishercoder/solutions/_341.java
@@ -30,6 +30,7 @@ public static class NestedIterator implements Iterator<Integer> {
 
         private Queue<Integer> flattenedList;
         private Iterator<Integer> iterator;
+
         public NestedIterator(List<NestedInteger> nestedList) {
             flattenedList = new LinkedList<>();
             constructList(nestedList);
diff --git a/src/main/java/com/fishercoder/solutions/_364.java b/src/main/java/com/fishercoder/solutions/_364.java
@@ -1,4 +1,5 @@
 package com.fishercoder.solutions;
+
 import com.fishercoder.common.classes.NestedInteger;
 
 import java.util.LinkedList;
diff --git a/src/main/java/com/fishercoder/solutions/_366.java b/src/main/java/com/fishercoder/solutions/_366.java
@@ -35,6 +35,7 @@
 public class _366 {
 
     List<List<Integer>> result = new ArrayList<List<Integer>>();
+
     public List<List<Integer>> findLeaves(TreeNode root) {
         dfs(root);
         return result;
diff --git a/src/main/java/com/fishercoder/solutions/_373.java b/src/main/java/com/fishercoder/solutions/_373.java
@@ -43,6 +43,7 @@ Find the k pairs (u1,v1),(u2,v2) ...(uk,vk) with the smallest sums.
 public class _373 {
 
     final int[][] neighbors = new int[][]{{0,1}, {1,0}};
+
     public List<int[]> kSmallestPairs(int[] nums1, int[] nums2, int k) {
         List<int[]> result = new ArrayList<int[]>();
         if(nums1 == null || nums2 == null || k == 0 || nums1.length == 0 || nums2.length == 0) return result;
diff --git a/src/main/java/com/fishercoder/solutions/_410.java b/src/main/java/com/fishercoder/solutions/_410.java
@@ -70,6 +70,7 @@ public int splitArray(int[] nums, int m) {
         }
         return (int) l;
     }
+
     public boolean valid(long target, int[] nums, int m) {
         int count = 1;
         long total = 0;
diff --git a/src/main/java/com/fishercoder/solutions/_412.java b/src/main/java/com/fishercoder/solutions/_412.java
@@ -1,4 +1,5 @@
 package com.fishercoder.solutions;
+
 import java.util.*;
 /**
  * 412. Fizz Buzz
diff --git a/src/main/java/com/fishercoder/solutions/_46.java b/src/main/java/com/fishercoder/solutions/_46.java
@@ -1,4 +1,5 @@
 package com.fishercoder.solutions;
+
 import java.util.ArrayList;
 import java.util.List;
 
diff --git a/src/main/java/com/fishercoder/solutions/_464.java b/src/main/java/com/fishercoder/solutions/_464.java
@@ -34,6 +34,7 @@ public class _464 {
 
     Map<Integer, Boolean> map;
     boolean[] used;
+
     public boolean canIWin(int maxChoosableInteger, int desiredTotal) {
         int sum = (1+maxChoosableInteger)*maxChoosableInteger/2;
         if(sum < desiredTotal) return false;
diff --git a/src/main/java/com/fishercoder/solutions/_468.java b/src/main/java/com/fishercoder/solutions/_468.java
@@ -56,6 +56,7 @@ group using two consecutive colons (::) to pursue simplicity.
 public class _468 {
 
     static final String NEITHER = "Neither";
+
     public String validIPAddress(String IP) {
         if (IP.contains(".")) {
             return isValidIPv4(IP);
diff --git a/src/main/java/com/fishercoder/solutions/_480.java b/src/main/java/com/fishercoder/solutions/_480.java
@@ -40,6 +40,7 @@ public class _480 {
      * so we'll have to use the original numbers themselves to store in the heaps.*/
     private PriorityQueue<Integer> minHeap = new PriorityQueue<>();
     private PriorityQueue<Integer> maxHeap = new PriorityQueue<>(Collections.reverseOrder());
+
     public double[] medianSlidingWindow(int[] nums, int k) {
         int n = nums.length - k + 1;
         if (n <= 0) return new double[0];
diff --git a/src/main/java/com/fishercoder/solutions/_488.java b/src/main/java/com/fishercoder/solutions/_488.java
@@ -51,6 +51,7 @@ public int findMinStep(String board, String hand) {
         int result = dfs(board + "#", handCount);  // append a "#" to avoid special process while j==board.length, make the code shorter.
         return result == maxcount ? -1 : result;
     }
+
     private int dfs(String s, int[] handCount) {
         s = removeConsecutive(s);
         if (s.equals("#")) return 0;
diff --git a/src/main/java/com/fishercoder/solutions/_5.java b/src/main/java/com/fishercoder/solutions/_5.java
@@ -16,7 +16,8 @@
  */
 public class _5 {
 
-    private int low, maxLen;
+    private int low;
+    private int maxLen;
 
     public String longestPalindrome(String s) {
         int len = s.length();
diff --git a/src/main/java/com/fishercoder/solutions/_526.java b/src/main/java/com/fishercoder/solutions/_526.java
@@ -33,6 +33,7 @@ public class _526 {
     //A good post to look at: https://discuss.leetcode.com/topic/79916/java-solution-backtracking and it's generic template afterwards for backtracking problems
 
     int count = 0;
+
     public int countArrangement(int N) {
         backtracking(N, new int[N+1], 1);
         return count;
diff --git a/src/main/java/com/fishercoder/solutions/_543.java b/src/main/java/com/fishercoder/solutions/_543.java
@@ -19,6 +19,7 @@
 public class _543 {
 
     int diameter = 0;
+
     public int diameterOfBinaryTree(TreeNode root) {
         dfs(root);
         return diameter;
diff --git a/src/main/java/com/fishercoder/solutions/_549.java b/src/main/java/com/fishercoder/solutions/_549.java
@@ -27,6 +27,7 @@
 public class _549 {
 
     int max = 0;
+
     public int longestConsecutive(TreeNode root) {
         longestPath(root);
         return max;
diff --git a/src/main/java/com/fishercoder/solutions/_556.java b/src/main/java/com/fishercoder/solutions/_556.java
@@ -34,6 +34,7 @@ public int nextGreaterElement(int n) {
             return -1;
         }
     }
+
     private void reverse(char[] a, int start) {
         int i = start, j = a.length - 1;
         while (i < j) {
@@ -42,6 +43,7 @@ private void reverse(char[] a, int start) {
             j--;
         }
     }
+
     private void swap(char[] a, int i, int j) {
         char temp = a[i];
         a[i] = a[j];
diff --git a/src/main/java/com/fishercoder/solutions/_563.java b/src/main/java/com/fishercoder/solutions/_563.java
@@ -34,6 +34,7 @@
 public class _563 {
 
     int tilt = 0;
+
     public int findTilt(TreeNode root) {
         findTiltDfs(root);
         return tilt;
diff --git a/src/main/java/com/fishercoder/solutions/_588.java b/src/main/java/com/fishercoder/solutions/_588.java
diff --git a/src/main/java/com/fishercoder/solutions/_604.java b/src/main/java/com/fishercoder/solutions/_604.java
diff --git a/src/main/java/com/fishercoder/solutions/_621.java b/src/main/java/com/fishercoder/solutions/_621.java
diff --git a/src/main/java/com/fishercoder/solutions/_634.java b/src/main/java/com/fishercoder/solutions/_634.java
diff --git a/src/main/java/com/fishercoder/solutions/_639.java b/src/main/java/com/fishercoder/solutions/_639.java
diff --git a/src/main/java/com/fishercoder/solutions/_68.java b/src/main/java/com/fishercoder/solutions/_68.java
diff --git a/src/main/java/com/fishercoder/solutions/_77.java b/src/main/java/com/fishercoder/solutions/_77.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/_91.java b/src/main/java/com/fishercoder/solutions/_91.java
diff --git a/src/test/java/com/fishercoder/_67Test.java b/src/test/java/com/fishercoder/_67Test.java

-Original file line number
+Diff line change
@@ @@ -1,6 +1,3 @@ @@
 -/**
 - *
 - */
 package com.fishercoder.common.utils;
 import com.fishercoder.common.classes.TreeNode;
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,5 @@`
`1`	`1`	`package com.fishercoder.solutions;`
	`2`	`+`
`2`	`3`	`import java.util.*;`
`3`	`4`
`4`	`5`	`/**`