Drawback

Given an integer array nums, return all of the triplets [nums[i], nums[j], nums[k]] such that i != j, i != okay, and j != okay, and nums[i] + nums[j] + nums[k] == 0.

Discover that the answer set should not include duplicate triplets.

Instance 1:

Enter: nums = [-1,0,1,2,-1,-4] Output: [[-1,-1,2],[-1,0,1]] Rationalization: nums[0] + nums[1] + nums[2] = (-1) + 0 + 1 = 0. nums[1] + nums[2] + nums[4] = 0 + 1 + (-1) = 0. nums[0] + nums[3] + nums[4] = (-1) + 2 + (-1) = 0. The distinct triplets are [-1,0,1] and [-1,-1,2]. Discover that the order of the output and the order of the triplets doesn’t matter.

Instance 2:

Enter: nums = [0,1,1] Output: [] Rationalization: The one potential triplet doesn’t sum as much as 0.

Instance 3:

Enter: nums = [0,0,0] Output: [[0,0,0]] Rationalization: The one potential triplet sums as much as 0.

Constraints:

• 3 <= nums.size <= 3000
• -105 <= nums[i] <= 105

Answer

We are going to comply with the identical two pointers sample as in Two Sum II. It requires the array to be sorted, so we'll try this first. As our BCR is O(n2)mathcal{O}(n^2)O(n2), sorting the array wouldn’t change the general time complexity.

To ensure the consequence comprises distinctive triplets, we have to skip duplicate values. It’s straightforward to do as a result of repeating values are subsequent to one another in a sorted array.

After sorting the array, we transfer our pivot ingredient nums[i] and analyze components to its proper. We discover all pairs whose sum is equal -nums[i] utilizing the 2 pointers sample, in order that the sum of the pivot ingredient (nums[i]) and the pair (-nums[i]) is the same as zero.

As a fast refresher, the pointers are initially set to the primary and the final ingredient respectively. We examine the sum of those two components to the goal. Whether it is smaller, we increment the decrease pointer lo. In any other case, we decrement the upper pointer hello. Thus, the sum at all times strikes towards the goal, and we "prune" pairs that may transfer it additional away. Once more, this works provided that the array is sorted. Head to the Two Sum II answer for the detailed clarification.

class Answer:
    def threeSum(self, nums: Checklist[int]) -> Checklist[List[int]]:
        res = []
        nums.type()
        for i in vary(len(nums)):
            if nums[i] > 0:
                break
            if i == 0 or nums[i - 1] != nums[i]:
                self.twoSumII(nums, i, res)
        return res

    def twoSumII(self, nums: Checklist[int], i: int, res: Checklist[List[int]]):
        lo, hello = i + 1, len(nums) - 1
        whereas (lo < hello):
            sum = nums[i] + nums[lo] + nums[hi]
            if sum < 0:
                lo += 1
            elif sum > 0:
                hello -= 1
            else:
                res.append([nums[i], nums[lo], nums[hi]])
                lo += 1
                hello -= 1
                whereas lo < hello and nums[lo] == nums[lo - 1]:
                    lo += 1