[N-0] refactor 136

Author: fishercoder1534

README.md

@@ -510,7 +510,7 @@ Your ideas/fixes/algorithms are more than welcome!
 |139|[Word Break](https://leetcode.com/problems/word-break/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_139.java)| O(n^2)|O(n) | Medium| DP, Pruning
 |138|[Copy List with Random Pointer](https://leetcode.com/problems/copy-list-with-random-pointer/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_138.java)| O(n)|O(n) | Medium| LinkedList, HashMap 
 |137|[Single Number II](https://leetcode.com/problems/single-number-ii/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_137.java)| O(n)|O(n) | Medium|
-|136|[Single Number](https://leetcode.com/problems/single-number/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_136.java)| O(n)|O(n) | Medium|
+|136|[Single Number](https://leetcode.com/problems/single-number/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_136.java)| O(n)|O(1) | Easy | Bit Manipulation
 |135|[Candy](https://leetcode.com/problems/candy/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_135.java)| O(n)|O(1) | Hard| Greedy
 |134|[Gas Station](https://leetcode.com/problems/gas-station/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_134.java)| O(n)|O(1) | Medium| Greedy
 |133|[Clone Graph](https://leetcode.com/problems/clone-graph/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_133.java)| O(n)|O(n) | Medium| HashMap, BFS, Graph 

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

@@ -9,34 +9,38 @@
 
 Note:
 Your algorithm should have a linear runtime complexity. Could you implement it without using extra memory?
-
 */
 
 public class _136 {
-    //approach 1: use set, since this problem explicitly states that every element appears twice and only one appears once
-    //so, we could safely remove the ones that are already in the set, O(n) time and O(n) space.
-    //HashTable approach works similarly like this one, but it could be more easily extend to follow-up questions.
-    public int singleNumber_using_set(int[] nums) {
-        Set<Integer> set = new HashSet();
-        for (int i : nums) {
-            if (!set.add(i)) {
-                set.remove(i);
+
+    public static class Solution1 {
+        /**approach 1: use set, since this problem explicitly states that every element appears twice and only one appears once
+        so, we could safely remove the ones that are already in the set, O(n) time and O(n) space.
+        HashTable approach works similarly like this one, but it could be more easily extend to follow-up questions.*/
+        public int singleNumber(int[] nums) {
+            Set<Integer> set = new HashSet();
+            for (int i : nums) {
+                if (!set.add(i)) {
+                    set.remove(i);
+                }
             }
+            Iterator<Integer> it = set.iterator();
+            return it.next();
         }
-        Iterator<Integer> it = set.iterator();
-        return it.next();
     }
 
 
-    //approach 2: bit manipulation, use exclusive or ^ to solve this problem:
-    //we're using the trick here: every number ^ itself will become zero, so, the only remaining element will be the one that
-    //appeared only once.
-    public int singleNumber_using_bit(int[] nums) {
-        int res = 0;
-        for (int i : nums) {
-            res ^= i;
+    public static class Solution2 {
+        /**approach 2: bit manipulation, use exclusive or ^ to solve this problem:
+        we're using the trick here: every number ^ itself will become zero, so, the only remaining element will be the one that
+        appeared only once.*/
+        public int singleNumber(int[] nums) {
+            int res = 0;
+            for (int i : nums) {
+                res ^= i;
+            }
+            return res;
         }
-        return res;
     }
 
 }