[N-0] refactor 9

Author: fishercoder1534

README.md

@@ -658,7 +658,7 @@ Your ideas/fixes/algorithms are more than welcome!
 |12|[Integer to Roman](https://leetcode.com/problems/integer-to-roman/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_12.java)|O(1)|O(1)|Medium|
 |11|[Container With Most Water](https://leetcode.com/problems/container-with-most-water/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_11.java)|O(n)|O(1)|Medium|
 |10|[Regular Expression Matching](https://leetcode.com/problems/regular-expression-matching/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_10.java)|O(m*n)|O(m*n)|Hard|DP
-|9|[Palindrome Number](https://leetcode.com/problems/palindrome-number/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_9.java)| O(logn)/(n) | O(1) | Easy
+|9|[Palindrome Number](https://leetcode.com/problems/palindrome-number/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_9.java)| O(n) | O(1) | Easy
 |8|[String to Integer (atoi)](https://leetcode.com/problems/string-to-integer-atoi/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_8.java)| O(n) | O(1) | Medium
 |7|[Reverse Integer](https://leetcode.com/problems/reverse-integer/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_7.java) | O(1) | O(1) | Easy | 
 |6|[ZigZag Conversion](https://leetcode.com/problems/zigzag-conversion/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_6.java) | O(n) | O(n) | Easy | 

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

@@ -1,37 +1,61 @@
 package com.fishercoder.solutions;
 
 /**
+ * 9. Palindrome Number
+ *
  * Determine whether an integer is a palindrome. Do this without extra space.
- * <p>
+ *
  * Some hints:
+ *
  * Could negative integers be palindromes? (ie, -1)
- * <p>
+ *
  * If you are thinking of converting the integer to string, note the restriction of using extra space.
- * <p>
+ *
  * You could also try reversing an integer. However, if you have solved the problem "Reverse Integer", you know that the reversed integer might overflow. How would you handle such case?
- * <p>
+ *
  * There is a more generic way of solving this problem.
  */
 public class _9 {
-    
-    /**Purely my original solution: just reverse the entire number and compare with itself, return if they two are equal or not.*/
-    public boolean isPalindrome(int x) {
-        if (x == 0) {
-            return true;
-        }
-        if (x < 0) {
-            return false;
-        }
-        int rev = 0;
-        int tmp = x;
-        while (tmp != 0) {
-            rev *= 10;
-            rev += tmp % 10;
-            tmp /= 10;
+
+    public static class Solution1 {
+        public boolean isPalindrome(int x) {
+            if (x == 0) {
+                return true;
+            }
+            if (x < 0) {
+                return false;
+            }
+            int rev = 0;
+            int tmp = x;
+            while (tmp != 0) {
+                rev *= 10;
+                rev += tmp % 10;
+                tmp /= 10;
+            }
+            return rev == x;
         }
-        return rev == x;
     }
 
-    /**Then I turned to Discuss and found a more efficient way: reversing only half and then compare if they're equal.*/
+    /**credit: https://discuss.leetcode.com/topic/8090/9-line-accepted-java-code-without-the-need-of-handling-overflow
+     * reversing only half and then compare if they're equal.*/
+    public static class Solution2 {
+        public boolean isPalindrome(int x) {
+            if (x < 0) {
+                return false;
+            } else if (x == 0) {
+                return true;
+            } else if (x % 10 == 0) {
+                return false;
+            }
+            int reversed = 0;
+            while (x > reversed) {
+                int digit = x % 10;
+                reversed *= 10;
+                reversed += digit;
+                x /= 10;
+            }
+            return (x == reversed || x == reversed / 10);
+        }
+    }
 
 }

src/test/java/com/fishercoder/_9Test.java

@@ -0,0 +1,43 @@
+package com.fishercoder;
+
+import com.fishercoder.solutions._9;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+public class _9Test {
+    private static _9.Solution1 solution1;
+    private static _9.Solution2 solution2;
+
+    @BeforeClass
+    public static void setup() {
+        solution1 = new _9.Solution1();
+        solution2 = new _9.Solution2();
+    }
+
+    @Test
+    public void test1() {
+        assertEquals(false, solution1.isPalindrome(2147483647));
+        assertEquals(false, solution2.isPalindrome(2147483647));
+    }
+
+    @Test
+    public void test2() {
+        assertEquals(true, solution1.isPalindrome(0));
+        assertEquals(true, solution2.isPalindrome(0));
+    }
+
+    @Test
+    public void test3() {
+        assertEquals(true, solution1.isPalindrome(1));
+        assertEquals(true, solution2.isPalindrome(1));
+    }
+
+    @Test
+    public void test4() {
+        assertEquals(false, solution1.isPalindrome(10));
+        assertEquals(false, solution2.isPalindrome(10));
+    }
+
+}