FourSum Problem

Author: shivam-1810

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

@@ -13,7 +13,7 @@ public class FourSumProblem {
     //Best approach - Sorting and two-pointers
     //Time Complexity - O(n^3)
     //Space Complexity - O(n)
-    public static List<List<Integer>> fourSum1(int[] nums, int target) {
+    public List<List<Integer>> fourSum1(int[] nums, int target) {
         List<List<Integer>> ans = new ArrayList<>();
         if (nums == null || nums.length < 4) return ans;
         Arrays.sort(nums);
@@ -45,7 +45,7 @@ public static List<List<Integer>> fourSum1(int[] nums, int target) {
     //Another approach - Using HashMap
     //Time Complexity - O(n^3)
     //Space Complexity - O(n^2) (Storing the pair of sums)
-    public static List<List<Integer>> fourSum2(int[] nums, int target) {
+    public List<List<Integer>> fourSum2(int[] nums, int target) {
         List<List<Integer>> ans = new ArrayList<>();
         if (nums == null || nums.length < 4) return ans;
         Arrays.sort(nums);
@@ -66,16 +66,4 @@ public static List<List<Integer>> fourSum2(int[] nums, int target) {
         }
         return ans;
     }
-
-    public static void main(String[] args) {
-        int[] arr1 = {1, 0, -1, 0, -2, 2};
-        int target1 = 0;
-        System.out.println(fourSum1(arr1, target1));
-        System.out.println(fourSum2(arr1, target1));
-
-        int[] arr2 = {4, 3, 3, 4, 4, 2, 1, 2, 1, 1};
-        int target2 = 9;
-        System.out.println(fourSum2(arr2, target2));
-        System.out.println(fourSum2(arr2, target2));
-    }
 }

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

@@ -0,0 +1,94 @@
+package com.thealgorithms.misc;
+
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import org.junit.jupiter.api.Test;
+
+public class FourSumProblemTest {
+
+    @Test
+    public void testFourSum1_basicCase() {
+        FourSumProblem solver = new FourSumProblem();
+
+        // Case 1: Standard case with multiple quadruplets
+        int[] nums1 = {1, 0, -1, 0, -2, 2};
+        int target1 = 0;
+        List<List<Integer>> result1 = solver.fourSum1(nums1, target1);
+        assertEquals(3, result1.size()); // Expect 3 quadruplets
+        assertTrue(result1.contains(List.of(-2, -1, 1, 2)));
+        assertTrue(result1.contains(List.of(-2, 0, 0, 2)));
+        assertTrue(result1.contains(List.of(-1, 0, 0, 1)));
+    }
+
+    @Test
+    public void testFourSum1_edgeCase_emptyArray() {
+        FourSumProblem solver = new FourSumProblem();
+
+        // Case 2: Empty array
+        int[] nums2 = {};
+        int target2 = 0;
+        List<List<Integer>> result2 = solver.fourSum1(nums2, target2);
+        assertEquals(0, result2.size()); // Expect no quadruplets
+    }
+
+    @Test
+    public void testFourSum1_edgeCase_noQuadruplet() {
+        FourSumProblem solver = new FourSumProblem();
+
+        // Case 3: No valid quadruplets
+        int[] nums3 = {1, 2, 3, 4, 5};
+        int target3 = 100;
+        List<List<Integer>> result3 = solver.fourSum1(nums3, target3);
+        assertEquals(0, result3.size()); // Expect no quadruplets
+    }
+
+    @Test
+    public void testFourSum2_basicCase() {
+        FourSumProblem solver = new FourSumProblem();
+
+        // Case 4: Standard case with multiple quadruplets using HashMap approach
+        int[] nums1 = {1, 0, -1, 0, -2, 2};
+        int target1 = 0;
+        List<List<Integer>> result1 = solver.fourSum2(nums1, target1);
+        assertEquals(3, result1.size()); // Expect 3 quadruplets
+        assertTrue(result1.contains(List.of(-2, -1, 1, 2)));
+        assertTrue(result1.contains(List.of(-2, 0, 0, 2)));
+        assertTrue(result1.contains(List.of(-1, 0, 0, 1)));
+    }
+
+    @Test
+    public void testFourSum2_edgeCase_emptyArray() {
+        FourSumProblem solver = new FourSumProblem();
+
+        // Case 5: Empty array
+        int[] nums2 = {};
+        int target2 = 0;
+        List<List<Integer>> result2 = solver.fourSum2(nums2, target2);
+        assertEquals(0, result2.size()); // Expect no quadruplets
+    }
+
+    @Test
+    public void testFourSum2_edgeCase_noQuadruplet() {
+        FourSumProblem solver = new FourSumProblem();
+
+        // Case 6: No valid quadruplets
+        int[] nums3 = {1, 2, 3, 4, 5};
+        int target3 = 100;
+        List<List<Integer>> result3 = solver.fourSum2(nums3, target3);
+        assertEquals(0, result3.size()); // Expect no quadruplets
+    }
+
+    @Test
+    public void testFourSum2_singleQuadruplet() {
+        FourSumProblem solver = new FourSumProblem();
+
+        // Case 7: Single quadruplet in the array
+        int[] nums4 = {2, 2, 2, 2, 2};
+        int target4 = 8;
+        List<List<Integer>> result4 = solver.fourSum2(nums4, target4);
+        assertEquals(1, result4.size()); // Expect only one quadruplet
+        assertTrue(result4.contains(List.of(2, 2, 2, 2)));
+    }
+}