enable LocalVariableName check

fishercoder1534 · fishercoder1534 · commit 1590ef5150a9 · 2017-08-21T19:08:41.000-07:00
diff --git a/fishercoder_checkstyle.xml b/fishercoder_checkstyle.xml
@@ -122,13 +122,13 @@
             <message key="name.invalidPattern"
                      value="Parameter name ''{0}'' must match pattern ''{1}''."/>
         </module>
-        <!--<module name="LocalVariableName">-->
-        <!--<property name="tokens" value="VARIABLE_DEF"/>-->
-        <!--<property name="format" value="^[a-z][a-zA-Z0-9]*$"/>-->
-        <!--<property name="allowOneCharVarInForLoop" value="true"/>-->
-        <!--<message key="name.invalidPattern"-->
-        <!--value="Local variable name ''{0}'' must match pattern ''{1}''."/>-->
-        <!--</module>-->
+        <module name="LocalVariableName">
+            <property name="tokens" value="VARIABLE_DEF"/>
+            <property name="format" value="^[a-zA-Z][a-zA-Z0-9]*$"/>
+            <property name="allowOneCharVarInForLoop" value="true"/>
+            <message key="name.invalidPattern"
+                     value="Local variable name ''{0}'' must match pattern ''{1}''."/>
+        </module>
         <module name="ClassTypeParameterName">
             <property name="format" value="(^[A-Z][0-9]?)$|([A-Z][a-zA-Z0-9]*[T]$)"/>
             <message key="name.invalidPattern"
diff --git a/src/main/java/com/fishercoder/solutions/_126.java b/src/main/java/com/fishercoder/solutions/_126.java
@@ -67,29 +67,29 @@ public List<List<String>> findLadders(String start, String end, List<String> dic
                 StringBuilder builder = new StringBuilder(word);
                 for (char ch = 'a'; ch <= 'z'; ch++) {
                     builder.setCharAt(i, ch);
-                    String new_word = builder.toString();
-                    if (ladder.containsKey(new_word)) {
+                    String newWord = builder.toString();
+                    if (ladder.containsKey(newWord)) {
 
-                        if (step > ladder.get(new_word)) {//Check if it is the shortest path to one word.
+                        if (step > ladder.get(newWord)) {//Check if it is the shortest path to one word.
                             continue;
-                        } else if (step < ladder.get(new_word)) {
-                            queue.add(new_word);
-                            ladder.put(new_word, step);
+                        } else if (step < ladder.get(newWord)) {
+                            queue.add(newWord);
+                            ladder.put(newWord, step);
                         } else ;// It is a KEY line. If one word already appeared in one ladder,
                         // Do not insert the same word inside the queue twice. Otherwise it gets TLE.
 
-                        if (map.containsKey(new_word)) {//Build adjacent Graph
-                            map.get(new_word).add(word);
+                        if (map.containsKey(newWord)) {//Build adjacent Graph
+                            map.get(newWord).add(word);
                         } else {
                             List<String> list = new LinkedList<String>();
                             list.add(word);
-                            map.put(new_word, list);
+                            map.put(newWord, list);
                             //It is possible to write three lines in one:
                             //map.put(new_word,new LinkedList<String>(Arrays.asList(new String[]{word})));
                             //Which one is better?
                         }
 
-                        if (new_word.equals(end)) {
+                        if (newWord.equals(end)) {
                             min = step;
                         }
 
diff --git a/src/main/java/com/fishercoder/solutions/_309.java b/src/main/java/com/fishercoder/solutions/_309.java
@@ -62,12 +62,12 @@ static class solutionFromProblemAuthor {
          * And here we are at our final solution:
          */
         public int maxProfit(int[] prices) {
-            int sell = 0, prev_sell = 0, buy = Integer.MIN_VALUE, prev_buy;
+            int sell = 0, prevSell = 0, buy = Integer.MIN_VALUE, prevBuy;
             for (int price : prices) {
-                prev_buy = buy;
-                buy = Math.max(prev_sell - price, prev_buy);
-                prev_sell = sell;
-                sell = Math.max(prev_buy + price, prev_sell);
+                prevBuy = buy;
+                buy = Math.max(prevSell - price, prevBuy);
+                prevSell = sell;
+                sell = Math.max(prevBuy + price, prevSell);
             }
             return sell;
         }
diff --git a/src/main/java/com/fishercoder/solutions/_326.java b/src/main/java/com/fishercoder/solutions/_326.java
@@ -37,10 +37,10 @@ public static void main(String...strings){
         System.out.println(test.isPowerOfThree(12));
         
         //find the max integer that is power of 3
-        int maxPowerOf3_one_step_further = 3, maxPowerOf3 = 0;
-        while(maxPowerOf3_one_step_further >= 0){
-            maxPowerOf3_one_step_further = (int) maxPowerOf3_one_step_further*3;
-            if(maxPowerOf3_one_step_further > 0) maxPowerOf3 = maxPowerOf3_one_step_further;
+        int maxPowerOf3OneStepFurther = 3, maxPowerOf3 = 0;
+        while(maxPowerOf3OneStepFurther >= 0){
+            maxPowerOf3OneStepFurther = (int) maxPowerOf3OneStepFurther*3;
+            if(maxPowerOf3OneStepFurther > 0) maxPowerOf3 = maxPowerOf3OneStepFurther;
             System.out.println("maxPowerOf3 is: " + maxPowerOf3);
         }
     }
diff --git a/src/main/java/com/fishercoder/solutions/_420.java b/src/main/java/com/fishercoder/solutions/_420.java
@@ -28,33 +28,33 @@ public int strongPasswordChecker(String s) {
             arr[j] = i - j;
         }
 
-        int total_missing = (a + A + d);
+        int totalMissing = (a + A + d);
 
         if (arr.length < 6) {
-            res += total_missing + Math.max(0, 6 - (arr.length + total_missing));
+            res += totalMissing + Math.max(0, 6 - (arr.length + totalMissing));
         } else {
-            int over_len = Math.max(arr.length - 20, 0), left_over = 0;
-            res += over_len;
+            int overLen = Math.max(arr.length - 20, 0), leftOver = 0;
+            res += overLen;
 
             for (int k = 1; k < 3; k++) {
-                for (int i = 0; i < arr.length && over_len > 0; i++) {
+                for (int i = 0; i < arr.length && overLen > 0; i++) {
                     if (arr[i] < 3 || arr[i] % 3 != (k - 1)) continue;
-                    arr[i] -= Math.min(over_len, k);
-                    over_len -= k;
+                    arr[i] -= Math.min(overLen, k);
+                    overLen -= k;
                 }
             }
 
             for (int i = 0; i < arr.length; i++) {
-                if (arr[i] >= 3 && over_len > 0) {
+                if (arr[i] >= 3 && overLen > 0) {
                     int need = arr[i] - 2;
-                    arr[i] -= over_len;
-                    over_len -= need;
+                    arr[i] -= overLen;
+                    overLen -= need;
                 }
 
-                if (arr[i] >= 3) left_over += arr[i] / 3;
+                if (arr[i] >= 3) leftOver += arr[i] / 3;
             }
 
-            res += Math.max(total_missing, left_over);
+            res += Math.max(totalMissing, leftOver);
         }
 
         return res;
diff --git a/src/main/java/com/fishercoder/solutions/_600.java b/src/main/java/com/fishercoder/solutions/_600.java
@@ -31,17 +31,17 @@ 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, prev_bit = 0;
+            int i = 30, sum = 0, prevBit = 0;
             while (i >= 0) {
                 if ((num & (1 << i)) != 0) {
                     sum += f[i];
-                    if (prev_bit == 1) {
+                    if (prevBit == 1) {
                         sum--;
                         break;
                     }
-                    prev_bit = 1;
+                    prevBit = 1;
                 } else {
-                    prev_bit = 0;
+                    prevBit = 0;
                 }
                 i--;
             }
diff --git a/src/main/java/com/fishercoder/solutions/_656.java b/src/main/java/com/fishercoder/solutions/_656.java
@@ -43,17 +43,17 @@ public List<Integer> cheapestJump(int[] A, int B) {
         Arrays.fill(next, -1);
         List<Integer> res = new ArrayList();
         for (int i = A.length - 2; i >= 0; i--) {
-            long min_cost = Integer.MAX_VALUE;
+            long minCost = Integer.MAX_VALUE;
             for (int j = i + 1; j <= i + B && j < A.length; j++) {
                 if (A[j] >= 0) {
                     long cost = A[i] + dp[j];
-                    if (cost < min_cost) {
-                        min_cost = cost;
+                    if (cost < minCost) {
+                        minCost = cost;
                         next[i] = j;
                     }
                 }
             }
-            dp[i] = min_cost;
+            dp[i] = minCost;
         }
         int i;
         for (i = 0; i < A.length && next[i] > 0; i = next[i]) {
diff --git a/src/main/java/com/fishercoder/solutions/_92.java b/src/main/java/com/fishercoder/solutions/_92.java
@@ -62,7 +62,7 @@ public ListNode reverseBetween(ListNode head, int m, int n) {
                 revHead = revHead.next;
             }
         }
-        ListNode node_prior_to_m = newRevHead;
+        ListNode nodePriorToM = newRevHead;
 
         // iteratively
         int nCnt = m;
@@ -89,8 +89,8 @@ public ListNode reverseBetween(ListNode head, int m, int n) {
         }
 
         // append the reversed part head to the node at position m-1
-        if (node_prior_to_m != null) {
-            node_prior_to_m.next = newRevHead;
+        if (nodePriorToM != null) {
+            nodePriorToM.next = newRevHead;
         } else {
             pre.next = newRevHead;
         }
diff --git a/src/test/java/com/fishercoder/_652Test.java b/src/test/java/com/fishercoder/_652Test.java
@@ -40,10 +40,10 @@ public void test1(){
         root.right.left.left = new TreeNode(4);
         root.right.right = new TreeNode(4);
 
-        TreeNode _2 = new TreeNode(2);
-        _2.left = new TreeNode(4);
-        TreeNode _4 = new TreeNode(4);
-        expected = new ArrayList<>(Arrays.asList(_4, _2));
+        TreeNode tree1 = new TreeNode(2);
+        tree1.left = new TreeNode(4);
+        TreeNode tree2 = new TreeNode(4);
+        expected = new ArrayList<>(Arrays.asList(tree2, tree1));
         assertEquals(expected, test.findDuplicateSubtrees(root));
     }
 
@@ -59,8 +59,8 @@ public void test3(){
         root.left = new TreeNode(1);
         root.right = new TreeNode(1);
 
-        TreeNode _1 = new TreeNode(1);
-        expected = new ArrayList<>(Arrays.asList(_1));
+        TreeNode tree1 = new TreeNode(1);
+        expected = new ArrayList<>(Arrays.asList(tree1));
         assertEquals(expected, test.findDuplicateSubtrees(root));
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -37,10 +37,10 @@ public static void main(String...strings){`
`37`	`37`	`System.out.println(test.isPowerOfThree(12));`
`38`	`38`
`39`	`39`	`//find the max integer that is power of 3`
`40`		`- int maxPowerOf3_one_step_further = 3, maxPowerOf3 = 0;`
`41`		`- while(maxPowerOf3_one_step_further >= 0){`
`42`		`- maxPowerOf3_one_step_further = (int) maxPowerOf3_one_step_further*3;`
`43`		`- if(maxPowerOf3_one_step_further > 0) maxPowerOf3 = maxPowerOf3_one_step_further;`
	`40`	`+ int maxPowerOf3OneStepFurther = 3, maxPowerOf3 = 0;`
	`41`	`+ while(maxPowerOf3OneStepFurther >= 0){`
	`42`	`+ maxPowerOf3OneStepFurther = (int) maxPowerOf3OneStepFurther*3;`
	`43`	`+ if(maxPowerOf3OneStepFurther > 0) maxPowerOf3 = maxPowerOf3OneStepFurther;`
`44`	`44`	`System.out.println("maxPowerOf3 is: " + maxPowerOf3);`
`45`	`45`	`}`
`46`	`46`	`}`
Original file line number	Diff line number	Diff line change
`@@ -31,17 +31,17 @@ public int findIntegers(int num) {`
`31`	`31`	`for (int i = 2; i < f.length; i++) {`
`32`	`32`	`f[i] = f[i - 1] + f[i - 2];`
`33`	`33`	`}`
`34`		`- int i = 30, sum = 0, prev_bit = 0;`
	`34`	`+ int i = 30, sum = 0, prevBit = 0;`
`35`	`35`	`while (i >= 0) {`
`36`	`36`	`if ((num & (1 << i)) != 0) {`
`37`	`37`	`sum += f[i];`
`38`		`- if (prev_bit == 1) {`
	`38`	`+ if (prevBit == 1) {`
`39`	`39`	`sum--;`
`40`	`40`	`break;`
`41`	`41`	`}`
`42`		`- prev_bit = 1;`
	`42`	`+ prevBit = 1;`
`43`	`43`	`} else {`
`44`		`- prev_bit = 0;`
	`44`	`+ prevBit = 0;`
`45`	`45`	`}`
`46`	`46`	`i--;`
`47`	`47`	`}`
Original file line number	Diff line number	Diff line change
`@@ -43,17 +43,17 @@ public List<Integer> cheapestJump(int[] A, int B) {`
`43`	`43`	`Arrays.fill(next, -1);`
`44`	`44`	`List<Integer> res = new ArrayList();`
`45`	`45`	`for (int i = A.length - 2; i >= 0; i--) {`
`46`		`- long min_cost = Integer.MAX_VALUE;`
	`46`	`+ long minCost = Integer.MAX_VALUE;`
`47`	`47`	`for (int j = i + 1; j <= i + B && j < A.length; j++) {`
`48`	`48`	`if (A[j] >= 0) {`
`49`	`49`	`long cost = A[i] + dp[j];`
`50`		`- if (cost < min_cost) {`
`51`		`- min_cost = cost;`
	`50`	`+ if (cost < minCost) {`
	`51`	`+ minCost = cost;`
`52`	`52`	`next[i] = j;`
`53`	`53`	`}`
`54`	`54`	`}`
`55`	`55`	`}`
`56`		`- dp[i] = min_cost;`
	`56`	`+ dp[i] = minCost;`
`57`	`57`	`}`
`58`	`58`	`int i;`
`59`	`59`	`for (i = 0; i < A.length && next[i] > 0; i = next[i]) {`
Original file line number	Diff line number	Diff line change
`@@ -62,7 +62,7 @@ public ListNode reverseBetween(ListNode head, int m, int n) {`
`62`	`62`	`revHead = revHead.next;`
`63`	`63`	`}`
`64`	`64`	`}`
`65`		`- ListNode node_prior_to_m = newRevHead;`
	`65`	`+ ListNode nodePriorToM = newRevHead;`
`66`	`66`
`67`	`67`	`// iteratively`
`68`	`68`	`int nCnt = m;`
`@@ -89,8 +89,8 @@ public ListNode reverseBetween(ListNode head, int m, int n) {`
`89`	`89`	`}`
`90`	`90`
`91`	`91`	`// append the reversed part head to the node at position m-1`
`92`		`- if (node_prior_to_m != null) {`
`93`		`- node_prior_to_m.next = newRevHead;`
	`92`	`+ if (nodePriorToM != null) {`
	`93`	`+ nodePriorToM.next = newRevHead;`
`94`	`94`	`} else {`
`95`	`95`	`pre.next = newRevHead;`
`96`	`96`	`}`