Given an array nums of $n$ integers, return an array of all the unique quadruplets, [nums[a], nums[b], nums[c], nums[d]] such that:

• $0 \leq$ a, b, c, d $< n$

• a, b, c, and d are distinct.

• nums[a] + nums[b] + nums[c] + nums[d] $=$ target

You may return the answer in any order.

Constraints:

• $1 \leq$ nums.length $\leq 200$

• $-10^9 \leq$ nums[i] $\leq 10^9$

• $-10^9 \leq$ target $\leq 10^9$

The problem involves finding all unique sets of four numbers in an array that sum up to a specified target. The solution combines sorting and two pointer techniques to find these quadruplets. By sorting the array and strategically moving pointers, the solution ensures that only valid and unique quadruplets are considered, optimizing it.

Now, let’s walk through the steps of the solution.

1. Check if the length of nums is less than $4$, and return an empty result since it’s impossible to form a quadruplet.

2. Sort nums to make finding and managing combinations that add to the target easier.

3. Create a list result to store all the valid quadruplets that sum up to the target.

4. Iterate over the sorted array using index i to pick the first number of the quadruplet.

5. Skip duplicate values for i to prevent considering the same quadruplet multiple times.

6. For each selected i, iterate over the array using index j (starting from i + 1) to pick the second number of the quadruplet.

7. Skip duplicate values for j to prevent considering the same quadruplet multiple times.

8. Set two pointers: left (just after j) and right (at the end of the array).

9. Calculate the sum of the four numbers: nums[i], nums[j], nums[left], and nums[right].

10. If the sum is less than the target, move the left pointer to the right to increase the sum.

11. If the sum exceeds the target, move the right pointer to the left to decrease the sum.

12. If the sum matches the target, add the quadruplet to the result.

13. After finding a valid quadruplet, move both left and right pointers inward.

14. Skip duplicate values at left and right to avoid adding the same quadruplet again.

15. Continue adjusting pointers and checking sums until the left pointer is less than the right pointer.

16. After all possible combinations have been checked, return the result, containing all unique quadruplets that sum up to the target.

Let’s look at the following illustration to get a better understanding.