Scribd
Upload
6 views2 pages

LeetCode Solution

Uploaded by

saxena.akarsh5
Copyright
© © All Rights Reserved
Available Formats
Download as PDF, TXT or read online on Scribd
Download as pdf or txt
6 views2 pages

LeetCode Solution

Uploaded by

saxena.akarsh5
Copyright
© © All Rights Reserved
Available Formats
Download as PDF, TXT or read online on Scribd
Download as pdf or txt
Download as pdf or txt
You are on page 1/ 2

Sure, I'd be delighted to walk you through solving this problem step-by-step in Python.

The
problem is to find all unique triplets in an array of integers that sum up to zero. Here's how
you can approach it:

1. **Sort the Array**: Sorting helps in efficiently finding triplets using a two-pointer
technique.
2. **Iterate with a Loop**: Use a loop to fix the first element of the triplet.
3. **Two-Pointer Technique**: For the remaining two elements, use two pointers to find pairs
that sum up to the negative value of the fixed element.
4. **Skip Duplicates**: Ensure that you don't include duplicate triplets in the output.

Here's the detailed and commented solution:

```python
def threeSum(nums):
# Step 1: Sort the array to simplify finding triplets and handling duplicates
nums.sort()
result = [] # This will store the list of triplets
n = len(nums)

# Step 2: Loop through each number considering it as the first element of the triplet
for i in range(n):
# Skip the same element to avoid duplicate triplets in the result
if i > 0 and nums[i] == nums[i - 1]:
continue

# Now use two pointers to find the other two elements


left = i + 1 # The pointer for the second element
right = n - 1 # The pointer for the third element

while left < right:


current_sum = nums[i] + nums[left] + nums[right]

if current_sum == 0:
# Found a triplet that sums to zero, add it to the result
result.append([nums[i], nums[left], nums[right]])

# Move the left pointer to the right, skip duplicates


while left < right and nums[left] == nums[left + 1]:
left += 1
# Move the right pointer to the left, skip duplicates
while left < right and nums[right] == nums[right - 1]:
right -= 1

# Move both pointers to continue searching for other pairs


left += 1
right -= 1

elif current_sum < 0:


# If current_sum is less than 0, we need a larger number
left += 1
else:
# If current_sum is more than 0, we need a smaller number
right -= 1

return result

# Example usage:
nums = [-1, 0, 1, 2, -1, -4]
print(threeSum(nums)) # Output: [[-1, -1, 2], [-1, 0, 1]]
```

### Explanation:

1. **Sorting**: The array is sorted to facilitate the two-pointer technique and handle
duplicates easily.
2. **Main Loop**: We iterate through the array, treating each element as the first item of the
triplet. The index `i` represents the current element.
3. **Two Pointers**: The `left` pointer starts just after `i` and the `right` pointer starts at
the end of the array.
4. **Sum Check**:
- If the sum of array elements at indices `i`, `left`, and `right` equals zero, a valid triplet
is found. Then, duplicates are skipped by moving the left and right pointers.
- If the sum is less than zero, we need a larger value, so `left` is incremented.
- If the sum is more than zero, we need a smaller value, so `right` is decremented.

By following these steps, our approach efficiently finds all unique triplets summing to zero in
the given array. I hope this detailed solution and explanation help you understand how to solve
the problem!

You might also like