# 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.

buy doxycycline 100mg canada

thx

thx

thx

thx

thx

thx

thx

thx

thx

thx

thx

thx

thx

thx

thx

thx

thx

thx

thx

thx

thx

thx