# Leetcode 3Sum Closest problem solution

In this Leetcode 3Sum Closest problem solution we have given an array nums of n integers and an integer target, find three integers in nums such that the sum is closest to the target. Return the sum of the three integers. You may assume that each input would have exactly one solution.

## Problem solution in Python.

```class Solution:
def helper(self, nums, left, target, curr, res):
right = len(nums)-1

while left<right:
curr_sum = curr+nums[left]+nums[right]
diff = abs(curr_sum-target)
if diff<res[0]:
res[0] = diff
res[1] = curr_sum

if curr_sum<target:
left+=1
while left<right and nums[left]==nums[left-1]: left+=1
elif curr_sum>target:
right-=1
while left<right and nums[right]==nums[right+1]: right-=1
else:
return

def threeSumClosest(self, nums: List[int], target: int) -> int:
nums.sort()
res = [float('inf'), 0]

for i in range(len(nums)):
if i>0 and nums[i]==nums[i-1]: continue
self.helper(nums, i+1, target, nums[i], res)
if res[1]==target: return res[1]

return res[1]
```

## Problem solution in Java.

```class Solution {
public int threeSumClosest(int[] nums, int target) {
int n=nums.length;
if(n<3)
return 0;
Arrays.sort(nums);
int min = Integer.MAX_VALUE;
int res = 0;
for(int i=0;i<n-2;i++) {
int j=i+1;
int k=n-1;
while(j<k) {
int sum = nums[i]+nums[j]+nums[k];
int diff = Math.abs(sum-target);
if(diff==0)
return sum;
if(diff<min) {
min=diff;
res=sum;
}
if(sum <=target) {
j++;
}else {
k--;
}
}
}
return res;
}
}
```

## Problem solution in C++.

```class Solution {
public:

int threeSumClosest(vector<int>& nums, int target) {
int n = nums.size(), result = INT_MAX, sum = 0;
sort(begin(nums),end(nums));
for(int i=0 ; i<n ; i++)
{
int a1 = i+1;
int a2 = n-1;
while(a1 < a2)
{
int ne_w = nums[i] + nums[a1] + nums[a2];
if(abs(target - ne_w) < abs(result))
{
result = target - ne_w;
sum = ne_w;
}
if(ne_w < target)
a1++;
else
a2--;
}
}
return sum;
}
};
```

## Problem solution in C.

```#include <stdlib.h>

static int cmp (const void *p, const void *q)
{
return *(int*)p < *(int*)q ? -1 : 1;
}

int threeSumClosest (int *a, const int n, const int target)
{
qsort(a, n, sizeof *a, cmp);
int closest = a[0] + a[1] + a[2];
for (int i = 0; i < n; ++i) {
int l = i + 1;
int r = n - 1;
while (l < r) {
const int sum = a[i] + a[l] + a[r];
if (sum < target)
++l;
else if (sum > target)
--r;
else // sum == target
return target;
if (abs(sum - target) < abs(closest - target))
closest = sum;
}
}
return closest;
}
```