Understanding the 4Sum Problem

The 4Sum problem is a classic challenge in computer science and coding interviews, where we must find four elements in an array that sum up to a given target value. In this article, we will dive into techniques to efficiently find the sum in the 4Sum problem, including “Efficient 4sum algorithm for large arrays,” to tackle the 4Sum problem, and we’ll also discuss “Unique solutions for the 4sum problem” and how to handle “4sum problem with non-repeating elements.” Additionally, we will provide practical examples and tips for “4sum problem for coding interviews,” equipping you to master this intriguing problem with Java solutions.


Example 1:
Input Format: arr[] = [1,0,-1,0,-2,2], target = 0
Result: [[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]
Explanation: We have to find unique quadruplets from the array such that the sum of those elements is equal to the target sum given that is 0. The result obtained is such that the sum of the quadruplets yields 0.

Example 2:
Input Format: arr[] = [4,3,3,4,4,2,1,2,1,1], target = 9
Result: [[1,1,3,4],[1,2,2,4],[1,2,3,3]]
Explanation: The sum of all the quadruplets is equal to the target i.e. 9.

Brute-Force Approach

The brute-force algorithm serves as a basic solution to the 4Sum problem. We’ll provide a Java implementation of this approach and analyze its time complexity, which is O(n^4) for large arrays, and discuss the space complexity, which is O(1). However, we’ll emphasize the need for more efficiently Solving the 4 Sum Problem.

import java.util.*;

public class EngineerVoice {

  // Java implementation of the Brute-Force Approach
  public static List<List<Integer>> fourSum(int[] nums, int target) {
  Set<List<Integer>> quadruplets = new HashSet<>();
  int n = nums.length;
  for (int i = 0; i < n - 3; i++) {
    for (int j = i + 1; j < n - 2; j++) {
        for (int k = j + 1; k < n - 1; k++) {
            for (int l = k + 1; l < n; l++) {
                if (nums[i] + nums[j] + nums[k] + nums[l] == target) {
       List<Integer> quadruplet = Arrays.asList(nums[i], nums[j], nums[k], nums[l]);
                    if (!quadruplets.contains(quadruplet)) {
  List<List<Integer>> ans = new ArrayList<>(quadruplets);
  return ans;


  public static void main(String[] args) {
    int[] nums = {4, 3, 3, 4, 4, 2, 1, 2, 1, 1};
    int target = 9;
    List<List<Integer>> ans = fourSum(nums, target);
    System.out.println("The quadruplets are: ");
    for (List<Integer> it : ans) {
        for (int ele : it) {
            System.out.print(ele + " ");
        System.out.print("] ");


4Sum Problem

Two-Pointer Technique to Find the Sum in 4Sum

The Optimized Two-Pointer Technique is a highly efficient approach to solve the 4Sum problem. It reduces the time complexity from O(n^4) in the brute-force approach to O(n^3) for large arrays, significantly improving the performance.

Algorithm: The Optimized Two-Pointer Technique involves sorting the input array and using two pointers, usually called “left” and “right,” to traverse the array from both ends towards the center. By cleverly moving these pointers based on the sum of the elements, we can efficiently find quadruplets that sum up to the target value.

Step-by-Step Explanation:

  • Sort the Array: Begin by sorting the input array in ascending order. Sorting is essential for efficiently identifying quadruplets and avoiding duplicates in the final result.
  • Initialize Pointers: Initialize two pointers, “left” and “right,” pointing to the second and last elements of the sorted array, respectively. The “left” pointer will start at index 1, while the “right” pointer will start at the last index.
  • Outer Loop: Start an outer loop that iterates from the first element to the third-to-last element of the array. The outer loop ensures that we cover all possible elements as the first element of the quadruplet.
  • Inner Loop: Within the outer loop, begin an inner loop that traverses the array using the two-pointer technique. The inner loop is responsible for finding the remaining three elements of the quadruplet.
  • Calculate the Remaining Target: Calculate the remaining target value required to complete the quadruplet by subtracting the current element at the outer loop index from the original target.
  • Two-Pointer Approach: In the inner loop, while the “left” pointer is less than the “right” pointer, calculate the sum of the elements at the “left” and “right” pointers.
  • Compare with Remaining Target: Compare the sum with the remaining target calculated in Step 5. Three cases can occur:
    • If the sum is equal to the remaining target, we found a valid quadruplet. Add it to the result list.
    • If the sum is less than the remaining target, move the “left” pointer to the right to increase the sum.
    • If the sum is greater than the remaining target, move the “right” pointer to the left to decrease the sum.
  • Avoid Duplicates: To avoid duplicate quadruplets, ensure that you skip elements that are the same as their previous ones in both the outer and inner loops.
  • Update Pointers: Continue the inner loop until the “left” pointer becomes greater than or equal to the “right” pointer.
  • Update Outer Loop Pointer: After finishing the inner loop, move the outer loop pointer to the next unique element.
  • Avoid Duplicate Starting Elements: Continue the outer loop until you reach the third-to-last element, and avoid duplicate starting elements.
  • Return Result: Return the list of quadruplets found during the process.
 public static List<List<Integer>> fourSum(int[] nums, int target) {
    List<List<Integer>> quadruplets = new ArrayList<>();
    int n = nums.length;
    for (int i = 0; i < n - 3; i++) {
        if (i > 0 && nums[i] == nums[i - 1])

        for (int j = i + 1; j < n - 2; j++) {
            if (j > i + 1 && nums[j] == nums[j - 1])

            int left = j + 1;
            int right = n - 1;
            int remainingTarget = target - nums[i] - nums[j];

            while (left < right) {
                int sum = nums[left] + nums[right];

                if (sum == remainingTarget) {
          quadruplets.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--;
                } else if (sum < remainingTarget) {
                } else {

    return quadruplets;

Time Complexity: The time complexity of the Optimized Two-Pointer Technique for the 4Sum problem is O(n^3), where n is the size of the input array.

Space Complexity: The space complexity of this algorithm is O(1) as it uses only a constant amount of additional space for variables

4sum Problem for Coding Interviews

The 4sum problem is a popular problem in coding interviews. It is a good way to test a candidate’s knowledge of algorithms and data structures.

In a coding interview, the interviewer may ask the candidate to solve the 4sum problem for a specific set of input values. The interviewer may also ask the candidate to discuss the different approaches to solving the problem and their time and space complexities.

Conclusion: In this article, we explored two approaches to solve the 4Sum problem in Java. The brute-force approach is simple to implement but inefficient for large arrays. In contrast, the optimized two-pointer technique, including the “Efficient 4sum algorithm for large arrays,” offers a significant reduction in time complexity, making it the preferred choice for handling large datasets. By understanding the time and space complexities of these algorithms developers can make informed decisions to optimize their solutions effectively.


  1. GeeksforGeeks: “Four Sum Problem” – https://www.geeksforgeeks.org/find-four-numbers-with-sum-equal-to-given-sum/

One thought on “Efficiently Finding Quadruplets with Target Sum: Exploring the 4Sum Problem”

Leave a Reply

Your email address will not be published. Required fields are marked *