Four Sum Problem All Unique Quadruplets in DSA Java - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to sort the input array before processing.

DSA Java

Arrays.[1](nums);

Drag options to blanks, or click blank then click option'

Areverse

BcopyOf

Cfill

Dsort

Attempts:

3 left

💡 Hint

Common Mistakes

Using reverse instead of sort.

Trying to sort manually instead of using built-in method.

Sorting the array helps to use two pointers efficiently and avoid duplicates.

2fill in blank

medium

Complete the code to skip duplicate values for the first pointer i.

DSA Java

if (i > 0 && nums[i] == nums[[1]]) continue;

Drag options to blanks, or click blank then click option'

Ai - 1

Bi + 1

C0

Dnums.length - 1

Attempts:

3 left

💡 Hint

Common Mistakes

Using i + 1 which looks ahead instead of behind.

Comparing with 0 index always.

To avoid duplicates, skip when current element equals previous element at i-1.

3fill in blank

hard

Fix the error in the while loop condition to move the left pointer correctly.

DSA Java

while (left < right && nums[left] == nums[[1]]) left++;

Drag options to blanks, or click blank then click option'

Aright - 1

Bleft + 1

Cleft - 1

Dright

Attempts:

3 left

💡 Hint

Common Mistakes

Using left + 1 which is the next element, causing index errors.

Comparing with right pointer instead of left.

We compare current left element with the previous left element at left-1 to skip duplicates.

4fill in blank

hard

Fill both blanks to correctly move the right pointer and skip duplicates.

DSA Java

while (left < right && nums[right] == nums[[1]]) [2]--;

Drag options to blanks, or click blank then click option'

Aright + 1

Bright - 1

Cright

Dleft + 1

Attempts:

3 left

💡 Hint

Common Mistakes

Using right + 1 instead of right - 1.

Comparing with left pointer instead of right.

To skip duplicates on the right side, compare with previous right element at right-1 and decrement right.

5fill in blank

hard

Fill all three blanks to add the quadruplet to the result list correctly.

DSA Java

result.add(Arrays.asList(nums[[1]], nums[[2]], nums[[3]], nums[right]));

Drag options to blanks, or click blank then click option'

Ai

Bj

Cleft

Dright

Attempts:

3 left

💡 Hint

Common Mistakes

Using right twice or missing left pointer.

Mixing indices order.

The quadruplet consists of elements at indices i, j, left, and right.

Practice

1. What is the main goal of the Four Sum Problem in data structures and algorithms?

easy

A. Find all unique quadruplets in an array that sum up to a target value

B. Sort the array in ascending order

C. Find the maximum element in the array

D. Count the number of pairs that sum to a target

Solution

1. Step 1: Understand the problem statement

   The Four Sum Problem asks to find sets of four numbers in an array that add up to a given target.

2. Step 2: Identify the expected output

   We want all unique quadruplets, meaning no repeated sets, that sum exactly to the target.

3. Final Answer:

   Find all unique quadruplets in an array that sum up to a target value -> Option A

4. Quick Check:

   Four Sum = unique quadruplets summing to target [OK]

Hint: Look for four numbers adding to target without duplicates [OK]

Common Mistakes:

• Confusing Four Sum with Two Sum or Three Sum problems
• Ignoring uniqueness of quadruplets
• Trying to find maximum or minimum instead of sum

2. Which of the following Java code snippets correctly initializes an empty list to store quadruplets for the Four Sum problem?

easy

A. List quadruplets = new List<>();

B. List quadruplets = new ArrayList<>();

C. ArrayList<int> quadruplets = new ArrayList<>();

D. List<List> quadruplets = new ArrayList();

Solution

1. Step 1: Check Java syntax for list initialization

   Correct generic syntax for a list of lists of integers is List quadruplets = new ArrayList<>();

2. Step 2: Identify errors in other options

   List quadruplets = new List<>(); uses raw List without generics and wrong constructor; ArrayList<int> quadruplets = new ArrayList<>(); uses primitive int which is invalid; List<List> quadruplets = new ArrayList(); mixes generics incorrectly.

3. Final Answer:

   List quadruplets = new ArrayList<>(); -> Option B

4. Quick Check:

   Correct generic list initialization = List quadruplets = new ArrayList<>(); [OK]

Hint: Use List with ArrayList constructor [OK]

Common Mistakes:

• Using raw types without generics
• Trying to use primitive types in generics
• Incorrect constructor calls for List

3. What will be the output of the following Java code snippet for the Four Sum problem?

int[] nums = {1, 0, -1, 0, -2, 2};
int target = 0;
List result = fourSum(nums, target);
System.out.println(result);

Assuming fourSum correctly finds all unique quadruplets summing to target.

medium

A. [[-2, -1, 0, 1], [0, 0, 0, 0]]

B. [[1, 0, -1, 0]]

C. [[-2, -1, 1, 2], [-2, 0, 0, 2], [-1, 0, 0, 1]]

D. []

Solution

1. Step 1: Sort and find quadruplets summing to zero

   Sorted array: [-2, -1, 0, 0, 1, 2]. Quadruplets summing to 0 are [-2,-1,1,2], [-2,0,0,2], and [-1,0,0,1].

2. Step 2: Verify uniqueness and completeness

   All quadruplets are unique and sum exactly to target 0. No other quadruplets exist.

3. Final Answer:

   [[-2, -1, 1, 2], [-2, 0, 0, 2], [-1, 0, 0, 1]] -> Option C

4. Quick Check:

   Unique quadruplets sum to 0 = [[-2, -1, 1, 2], [-2, 0, 0, 2], [-1, 0, 0, 1]] [OK]

Hint: Sort array first, then find quadruplets with two pointers [OK]

Common Mistakes:

• Not sorting array before processing
• Including duplicate quadruplets
• Missing some valid quadruplets

4. Identify the bug in this Java snippet for the Four Sum problem:

for (int i = 0; i < nums.length - 3; i++) {
  for (int j = i + 1; j < nums.length - 2; j++) {
    int left = j + 1, right = nums.length - 1;
    while (left < right) {
      int sum = nums[i] + nums[j] + nums[left] + nums[right];
      if (sum == target) {
        result.add(Arrays.asList(nums[i], nums[j], nums[left], nums[right]));
        left++;
        right--;
      } else if (sum < target) {
        left++;
      } else {
        right--;
      }
    }
  }
}

medium

A. Sum calculation uses wrong indices

B. Incorrect initialization of left and right pointers

C. Wrong loop conditions for i and j

D. Missing checks to skip duplicate elements for i, j, left, and right

Solution

1. Step 1: Analyze loop and pointer usage

   Loops and pointers are correctly set to find quadruplets, and sum calculation is correct.

2. Step 2: Identify missing duplicate skipping

   Code lacks checks to skip duplicate values for i, j, left, and right after finding a quadruplet, which can cause duplicate quadruplets in result.

3. Final Answer:

   Missing checks to skip duplicate elements for i, j, left, and right -> Option D

4. Quick Check:

   Duplicate skipping missing = Missing checks to skip duplicate elements for i, j, left, and right [OK]

Hint: Always skip duplicates after adding quadruplet to avoid repeats [OK]

Common Mistakes:

• Not skipping duplicates causing repeated quadruplets
• Changing pointers incorrectly inside loops
• Incorrect loop boundaries causing index errors

5. Given the array nums = {2, 2, 2, 2, 2} and target 8, what is the correct output of the Four Sum problem solution that finds all unique quadruplets?

hard

A. [[2, 2, 2, 2]]

B. [[2, 2, 2, 2], [2, 2, 2, 2]]

C. []

D. [[2, 2, 2]]

Solution

1. Step 1: Check if quadruplets sum to target

   All elements are 2, so quadruplet [2, 2, 2, 2] sums to 8.

2. Step 2: Ensure uniqueness of quadruplets

   Even though elements repeat, only one unique quadruplet exists. Duplicates must be avoided.

3. Final Answer:

   [[2, 2, 2, 2]] -> Option A

4. Quick Check:

   Unique quadruplet summing to 8 = [[2, 2, 2, 2]] [OK]

Hint: Same numbers can form one unique quadruplet if sum matches target [OK]

Common Mistakes:

• Returning duplicate quadruplets multiple times
• Returning empty list when quadruplet exists
• Confusing triple with quadruplet