Refactor - Implement Sliding Window

A new approach - Sliding Window technique was applied to find more optimum solution but unfortunately both failed when the data is of large volume.

Author: anitsh

src/leetcode/datastructure/containsduplicate/two/README.MD

@@ -34,7 +34,7 @@ So we cannot sort as index needs to be preserved.
 ### Pseudocode
 
 for (i=0; i < nums.len; i++) // loop all nums
-for (j=i+1; j < nums.len; j++) // loop all numbs except i  
+for (j=i+1; j < nums.len; j++) // loop all nums except i  
 
 if nums[i]=nums[j] and abs(i-j)<=k, return true
 
@@ -52,7 +52,7 @@ Stores whole numbers from -2,147,483,648 to 2,147,483,647.
 ```
 
 ### Understanding Case 1
-Initial logic below was failing case 1
+Initial logic below was failing test case 1
 ```
 for (int i = 0; i < nums.length - 1; i++) {
     for ( int j = i+1; j < nums.length-1; j++ ) {
@@ -76,9 +76,9 @@ for ( int j = i+1; j < nums.length; j++ )
 
 ## Failed To Run 
 The given test case failed to run with exception:
-Time Limit Exceeded
+**Time Limit Exceeded**
 
-Data stored in failed-testcase.txt
+Data stored in testcase-48.txt
 
 The first O(n^2) solution does not work for 
 large input size.
@@ -121,9 +121,40 @@ If current == next,
     Find the index of next.
     Check condition.
 
-Let's say we have 3 same numbers at different indexes. When we sort the array, 3 of them will appear one after another. And the value of k might be just less than the first index and the last. So we might have to check the current and the last.
+Let's say we have 3 same numbers at different indexes. 
+When we sort the array, 3 of them will appear one after 
+another. And the value of k might be just less than the 
+first index and the last. So we might have to check the 
+current and the last.
 
 ## Solution Accepted
-Runtime: 30 ms, faster than 37.52% of Java online submissions for Contains Duplicate II.
-Memory Usage: 49.3 MB, less than 54.65% of Java online submissions for Contains Duplicate II.
+Runtime: 30 ms, faster than 37.52% of Java online 
+submissions for Contains Duplicate II.
+
+Memory Usage: 49.3 MB, less than 54.65% of Java 
+online submissions for Contains Duplicate II.
+
+## Refactor
+The current solution is not efficient - time 
+and space constraints are high.
+
+Another solution would be using `Sliding Window`
+technique.
+
+The constraint k defines the difference and 
+this also means the distance between the two 
+equal numbers.
+
+### Pseudocode
+Iterate through array
+Create a new array of size of the window.
+Sort it.
+Check if two numbers are equal.
+
+Two implementations are applied based on the technique.
+And both of them fails when large volume of data is 
+processed.
+
+
+
 

src/leetcode/datastructure/containsduplicate/two/Solution.java

@@ -1,12 +1,76 @@
-package leetcode.datastructure.duplicate.two;
+package leetcode.datastructure.containsduplicate.two;
 
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.stream.IntStream;
 import static java.lang.Math.abs;
 
 class Solution {
-    public boolean containsNearbyDuplicate(int[] nums, int k) {
+
+    // Fails with Time Limit Exceeded for test case 47
+    public boolean containsNearbyDuplicateSlidingWindowFAILS(int[] nums, int k) {
+        if ( nums.length == 1 )
+            return false;
+
+        if ( nums.length <= k && nums[0] == nums[nums.length-1]) {
+            return true;
+        }
+
+        int initialRange =  nums.length-k == 1 ? k+1 : k;
+
+        if ( k == 1 || k == 2 ||  k % 2 > 0 ) initialRange = k+1;
+
+        int loops = nums.length-k;
+
+        int count = 0;
+        for (; count < loops; count++) {
+            int[] window = Arrays.copyOfRange(nums, count, initialRange + count);
+            Arrays.sort(window);
+
+            for (int i = 0; i < window.length-1; i++) {
+                    if (window[i] == window[i+1])
+                        return true;
+            }
+        }
+
+        // Last few values would not have been compared
+        // beacuase of the size of sliding window above.
+        for (; count < nums.length-1 && k > 2; count++, k--) {
+            for (int l = count; l < nums.length-1; l++) {
+
+                if (nums[count] == nums[l + 1])
+                    return true;
+            }
+        }
+
+        return false;
+    }
+
+    // Fails with Time Limit Exceeded for test case 47
+    public boolean containsNearbyDuplicateFails(int[] nums, int k) {
+        int i = 0;
+        int window =  nums.length - k == 1 ? 2 : nums.length - k;
+
+        for (; i < window; i++) {
+            for (int j = i; j < i + k; j++) {
+
+                if (nums[i] == nums[j+1])
+                        return true;
+            }
+        }
+
+        for (; i < nums.length-1 && window > 2; i++, k--) {
+            for (int l = i; l < nums.length-1; l++) {
+
+                if (nums[i] == nums[l + 1])
+                    return true;
+            }
+        }
+
+        return false;
+    }
+
+    public boolean containsNearbyDuplicateSUCCESS(int[] nums, int k) {
         int[] numsClone = nums.clone();
         Arrays.sort(numsClone);
         int duplicateCount = 0;
@@ -39,7 +103,7 @@ public boolean isLessThanK(int num, int duplicateCount, int k, int[] nums){
         ArrayList<Integer> indexes = new ArrayList<Integer>();
         int index = 0;
 
-        for (int j=0; j <= duplicateCount ;j++) {
+        for (int j = 0; j <= duplicateCount; j++) {
 
             index = IntStream.range(index, nums.length).
                     filter(a -> num == nums[a]).

src/leetcode/datastructure/containsduplicate/two/SolutionTest.java

@@ -1,13 +1,8 @@
-package leetcode.datastructure.duplicate.two;
+package leetcode.datastructure.containsduplicate.two;
 
 import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.Test;
 
-import java.util.Arrays;
-import java.util.List;
-import java.util.stream.Collectors;
-import java.util.stream.IntStream;
-
 
 class SolutionTest {
     @Test
@@ -33,4 +28,58 @@ void shouldAssertTrueWithTestCase48() {
         Solution solution = new Solution();
         Assertions.assertTrue(solution.containsNearbyDuplicate(new int[]{313,64,612,515,412,661,244,164,492,744,233,579,62,786,342,817,838,396,230,79,570,702,124,727,586,542,919,372,187,626,869,923,103,932,368,891,411,125,724,287,575,326,88,125,746,117,363,8,881,441,542,653,211,180,620,175,747,276,832,772,165,733,574,186,778,586,601,165,422,956,357,134,857,114,450,64,494,679,495,205,859,136,477,879,940,139,903,689,954,335,859,78,20}, 22));
     }
+
+    @Test
+    void shouldAssertTrueWithTestCase21() {
+        Solution solution = new Solution();
+        Assertions.assertTrue(solution.containsNearbyDuplicate(new int[]{1,2,1}, 2));
+    }
+
+    @Test
+    void shouldAssertFalseWithTestCase22() {
+        Solution solution = new Solution();
+        Assertions.assertFalse(solution.containsNearbyDuplicate(new int[]{13,23,1,2,3}, 5));
+    }
+
+    @Test
+    void shouldAssertFalseWithTestCase28() {
+        Solution solution = new Solution();
+        Assertions.assertFalse(solution.containsNearbyDuplicate(new int[]{0,1,2,3,4,5,0}, 5));
+    }
+
+    @Test
+    void shouldAssertFalseWithTestCase47() {
+        Solution solution = new Solution();
+        Assertions.assertTrue(solution.containsNearbyDuplicate(new int[]{99,99}, 2));
+    }
+
+    @Test
+    void shouldAssertFalseWithTestCase48() {
+        Solution solution = new Solution();
+        Assertions.assertFalse(solution.containsNearbyDuplicate(new int[]{1}, 1));
+    }
+
+    @Test
+    void shouldAssertTrueWithTestCase49() {
+        Solution solution = new Solution();
+        Assertions.assertTrue(solution.containsNearbyDuplicate(new int[]{1,2,3,4,5,6,7,8,9,9}, 3));
+    }
+
+    @Test
+    void shouldAssertTrueWithTestCase50() {
+        Solution solution = new Solution();
+        Assertions.assertTrue(solution.containsNearbyDuplicate(new int[]{1,2,2,3}, 3));
+    }
+
+    @Test
+    void shouldAssertTrueWithTestCase18() {
+        Solution solution = new Solution();
+        Assertions.assertTrue(solution.containsNearbyDuplicate(new int[]{2,2}, 3));
+    }
+
+    @Test
+    void shouldAssertTrueWithTestCase19() {
+        Solution solution = new Solution();
+        Assertions.assertTrue(solution.containsNearbyDuplicate(new int[]{0,1,2,3,4,5,0}, 6));
+    }
 }