A solution to LeetCode Problem 15. 3 Sum in JavaScript 

If you're preparing for technical interviews or want to improve your coding skills, solving practice problems on LeetCode is a great way. 

In this post, we'll discuss a solution to the "3 sum" problem on LeetCode.

Problem Statement:

Given an integer array nums, return an array answer such that answer[i] is equal to the product of all the elements of nums except nums[i].

The product of any prefix or suffix of nums is guaranteed to fit in a 32-bit integer.

You must write an algorithm that runs in O(n) time and without using the division operation.

 

Example 1:

Input: nums = [1,2,3,4]
Output: [24,12,8,6]

Example 2:

Input: nums = [-1,1,0,-3,3]
Output: [0,0,9,0,0]

 

Constraints:

• 2 <= nums.length <= 105
• -30 <= nums[i] <= 30
• The product of any prefix or suffix of nums is guaranteed to fit in a 32-bit integer.

 

Solution

One solution to this problem is to use a brute force approach, where we consider every possible combination of three elements and check if their sum is zero. However, this solution has a time complexity of O(n^3), which is not efficient for large inputs.

A better solution is to use a two-pointer approach. We can sort the array first, and then for each element a in the array, we can use two pointers b and c to find the other two elements that sum to -a. We can move the pointers b and c towards each other to find the other two elements.

Here is the solution :

function threeSum(nums) {
  const result = [];
  const n = nums.length;
  nums.sort((a, b) => a - b);

  for (let i = 0; i < n - 2; i++) {
    if (i > 0 && nums[i] === nums[i - 1]) continue;

    let b = i + 1;
    let c = n - 1;
    while (b < c) {
      if (nums[i] + nums[b] + nums[c] === 0) {
        result.push([nums[i], nums[b], nums[c]]);
        b++;
        c--;
        while (b < c && nums[b] === nums[b - 1]) b++;
        while (b < c && nums[c] === nums[c + 1]) c--;
      } else if (nums[i] + nums[b] + nums[c] > 0) {
        c--;
      } else {
        b++;
      }
    }
  }

  return result;
}

This solution has a time complexity of O(n^2) and a space complexity of O(1), which is much more efficient than the brute force approach.

I hope this helps! Let me know if you have any questions or suggestions for improvement.