FourSum Problem final

Author: shivam-1810

src/main/java/com/thealgorithms/misc/FourSumProblem.java

@@ -18,17 +18,25 @@ public List<List<Integer>> fourSum1(int[] nums, int target) {
         if (nums == null || nums.length < 4) return ans;
         Arrays.sort(nums);
         for(int i = 0; i < nums.length-3; i++) {
-            if(i > 0 && nums[i] == nums[i-1]) continue;
+            if(i > 0 && nums[i] == nums[i-1]) {
+                continue;
+            }
             for(int j = i+1; j < nums.length - 2; j++) {
-                if(j > i+1 && nums[j] == nums[j-1]) continue;
+                if(j > i+1 && nums[j] == nums[j-1]) {
+                    continue;
+                }
                 int left = j+1;
                 int right = nums.length -1;
                 while(left < right)  {
                     long sum = (long)nums[i] + (long)nums[j] + (long)nums[left] + (long)nums[right];
                     if(sum == target) {
                         ans.add(Arrays.asList(nums[i], nums[j], nums[left], nums[right]));
-                        while (left < right && nums[left] == nums[left+1]) left++;
-                        while(left < right && nums[right] == nums[right-1]) right--;
+                        while (left < right && nums[left] == nums[left+1]) {
+                            left++;
+                        }
+                        while(left < right && nums[right] == nums[right-1]) {
+                            right--;
+                        }
                         left++; right--;
                     } else if (sum > target) {
                         right--;
@@ -47,7 +55,9 @@ public List<List<Integer>> fourSum1(int[] nums, int target) {
     //Space Complexity - O(n^2) (Storing the pair of sums)
     public List<List<Integer>> fourSum2(int[] nums, int target) {
         List<List<Integer>> ans = new ArrayList<>();
-        if (nums == null || nums.length < 4) return ans;
+        if (nums == null || nums.length < 4) {
+            return ans;
+        }
         Arrays.sort(nums);
         for (int i = 0; i < nums.length - 3; i++) {
             if (i > 0 && nums[i] == nums[i-1]) continue;

src/test/java/com/thealgorithms/misc/FourSumProblemTest.java

@@ -91,4 +91,49 @@ public void testFourSum2_singleQuadruplet() {
         assertEquals(1, result4.size()); // Expect only one quadruplet
         assertTrue(result4.contains(List.of(2, 2, 2, 2)));
     }
+
+    @Test
+    public void testFourSum1_withDuplicateFirstIndex() {
+        FourSumProblem solver = new FourSumProblem();
+        int[] nums = {1, 1, 0, 0, -1, -1, 2, 2};
+        int target = 0;
+        List<List<Integer>> result = solver.fourSum1(nums, target);
+        assertTrue(!result.isEmpty()); // Expect some quadruplets
+    }
+
+    @Test
+    public void testFourSum1_withDuplicateSecondIndex() {
+        FourSumProblem solver = new FourSumProblem();
+        int[] nums = {2, 2, 2, 2, 2, 2, 0, 0};
+        int target = 4;
+        List<List<Integer>> result = solver.fourSum1(nums, target);
+        assertEquals(1, result.size()); // Expect only one quadruplet
+        assertTrue(result.contains(List.of(0, 0, 2, 2)));
+    }
+
+    @Test
+    public void testFourSum1_withSuccessfulSum() {
+        FourSumProblem solver = new FourSumProblem();
+        int[] nums = {1, 0, -1, 0, -2, 2};
+        int target = 0;
+        List<List<Integer>> result = solver.fourSum1(nums, target);
+        assertEquals(3, result.size()); // Expect 3 quadruplets
+        assertTrue(result.contains(List.of(-2, -1, 1, 2)));
+        assertTrue(result.contains(List.of(-2, 0, 0, 2)));
+        assertTrue(result.contains(List.of(-1, 0, 0, 1)));
+    }
+
+    @Test
+    public void testFourSum2_withDuplicateSecondIndex() {
+        FourSumProblem solver = new FourSumProblem();
+
+        // Case with duplicates affecting the second loop index (j)
+        int[] nums = {2, 2, 2, 2, 2, 0, 0};
+        int target = 4;
+        List<List<Integer>> result = solver.fourSum2(nums, target);
+        
+        assertEquals(1, result.size()); // Expect only one quadruplet
+        assertTrue(result.contains(List.of(0, 0, 2, 2))); // The only valid quadruplet
+    }
+
 }