Python

# 3Sum
nums = [-1, 0, 1, 2, -1, -4]
result = []
nums.sort()
print(nums)
r=len(nums)-1
for i in range(len(nums)-2):
   l = i + 1 # we don't want l and i to be the same value.
   # for each value of i, l starts one greater
   # and increments from there.
   while (l < r):
      sum_ = nums[i] + nums[l] + nums[r]
      if (sum_ < 0):
         l = l + 1
      elif (sum_ > 0):
         r = r - 1
      else: # 0 is False in a boolean context
         result.append([nums[i],nums[l],nums[r]])
         l = l + 1 # increment l when we find a combination that works
print(result)

Java

class Solution {
2    public List<List<Integer>> threeSum(int[] nums) {
3        Arrays.sort(nums);
4        List<List<Integer>> threeSums = new ArrayList<>();
5        for (int i = 0; i < nums.length; i++) {
6            if (i > 0 && nums[i] == nums[i - 1]) {
7                continue;
8            }
9            int target = -nums[i];
10            int l = i + 1, r = nums.length - 1;
11            while (l < r) {
12                if (nums[l] + nums[r] == target) {
13                    threeSums.add(Arrays.asList(nums[i], nums[l], nums[r]));
14                    l++;
15                    while (l < r && nums[l] == nums[l - 1]) {
16                        l++;
17                    }
18                } else if (nums[l] + nums[r] < target) {
19                    l++;
20                } else {
21                    r--;
22                }
23            }
24        }
25        return threeSums;
26    }

Javascript

const threeSum = (nums) => {
2  const sortedNums = nums.sort((a, b) => a - b);
3  const threeSums = [];
4  for (let i = 0; i < nums.length; i++) {
5    // avoid duplicates
6    if (i > 0 && sortedNums[i] === sortedNums[i - 1]) {
7      continue;
8    }
9    const target = -sortedNums[i];
10    let [l, r] = [i + 1, sortedNums.length - 1];
11    while (l < r) {
12      if (sortedNums[l] + sortedNums[r] === target) {
13        threeSums.push([sortedNums[i], sortedNums[l], sortedNums[r]]);
14        l += 1;
15        // avoid duplicates again
16        while (l < r && sortedNums[l] === sortedNums[l - 1]) {
17          l += 1;
18        }
19      } else if (sortedNums[l] + sortedNums[r] < target) {
20        l += 1;
21      } else {
22        r -= 1;
23      }
24    }
25  }
26  return threeSums;
27};

Fontes:

https://interviewing.io/questions/three-sum