refactor 442

Author: fishercoder1534

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

@@ -23,8 +23,20 @@ public List findDuplicates(int[] nums) {
     }
 
     public static class Solution2 {
-        //O(1) space
-        //O(n) time
+        /**
+         * O(1) space
+         * O(n) time
+         * 
+         * This approach makes full use of what the problem states: all the integers of nums are in the range [1, n],
+         * this implies that for any value x in this array, x - 1 must be a valid index in this array
+         * thus, nums[x - 1] is a valid element in this array.
+         * 
+         * So the solution was born:
+         * we could mark one element as seen/visited before by negating it,
+         * so when we encounter this same number again, i.e. the number is negative,
+         * we know it appeared before, so we add it to the result
+         * and then negate this number back.
+         */
         public List<Integer> findDuplicates(int[] nums) {
             List<Integer> result = new ArrayList();
             for (int i = 0; i < nums.length; i++) {

src/test/java/com/fishercoder/_442Test.java

@@ -0,0 +1,27 @@
+package com.fishercoder;
+
+import com.fishercoder.solutions._442;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import java.util.Arrays;
+
+import static org.junit.Assert.assertEquals;
+
+public class _442Test {
+    private static _442.Solution1 solution1;
+    private static _442.Solution2 solution2;
+
+    @BeforeClass
+    public static void setup() {
+        solution1 = new _442.Solution1();
+        solution2 = new _442.Solution2();
+    }
+
+    @Test
+    public void test1() {
+        assertEquals(Arrays.asList(2, 3), solution1.findDuplicates(new int[]{4, 3, 2, 7, 8, 2, 3, 1}));
+        assertEquals(Arrays.asList(2, 3), solution2.findDuplicates(new int[]{4, 3, 2, 7, 8, 2, 3, 1}));
+    }
+
+}