Three Sum Problem All Unique Triplets in DSA Python - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of Three Sum Unique Triplets Function

What is the output of the following Python function when called with nums = [-1, 0, 1, 2, -1, -4]?

DSA Python

def three_sum(nums):
    nums.sort()
    result = []
    for i in range(len(nums) - 2):
        if i > 0 and nums[i] == nums[i - 1]:
            continue
        left, right = i + 1, len(nums) - 1
        while left < right:
            total = nums[i] + nums[left] + nums[right]
            if total == 0:
                result.append([nums[i], nums[left], nums[right]])
                while left < right and nums[left] == nums[left + 1]:
                    left += 1
                while left < right and nums[right] == nums[right - 1]:
                    right -= 1
                left += 1
                right -= 1
            elif total < 0:
                left += 1
            else:
                right -= 1
    return result

print(three_sum([-1, 0, 1, 2, -1, -4]))

A [[-4, 2, 2], [-1, 0, 1]]

B [[-1, -1, 2], [-1, 0, 1]]

C [[-1, 0, 1], [0, 1, -1]]

D [[-1, -1, 2], [-4, 0, 4]]

💡 Hint

Sort the list first and use two pointers to find pairs that sum with nums[i] to zero.

The function sorts the list and uses a fixed pointer with two moving pointers to find all unique triplets that sum to zero. It skips duplicates to avoid repeated triplets.

❓ Predict Output

intermediate

Number of Unique Triplets Summing to Zero

How many unique triplets does the function find for the input nums = [3, 0, -2, -1, 1, 2]?

DSA Python

def three_sum(nums):
    nums.sort()
    result = []
    for i in range(len(nums) - 2):
        if i > 0 and nums[i] == nums[i - 1]:
            continue
        left, right = i + 1, len(nums) - 1
        while left < right:
            total = nums[i] + nums[left] + nums[right]
            if total == 0:
                result.append([nums[i], nums[left], nums[right]])
                while left < right and nums[left] == nums[left + 1]:
                    left += 1
                while left < right and nums[right] == nums[right - 1]:
                    right -= 1
                left += 1
                right -= 1
            elif total < 0:
                left += 1
            else:
                right -= 1
    return result

print(len(three_sum([3, 0, -2, -1, 1, 2])))

A 3

B 1

C 4

D 2

💡 Hint

Count the unique triplets after sorting and using two pointers.

The unique triplets are [-2, -1, 3], [-2, 0, 2], [-1, 0, 1], so the count is 3.

🔧 Debug

advanced

Identify the Error in Triplet Finding Code

What best describes the result of running the following code with nums = [0, 0, 0, 0]?

DSA Python

def three_sum(nums):
    nums.sort()
    result = []
    for i in range(len(nums) - 2):
        left, right = i + 1, len(nums) - 1
        while left < right:
            total = nums[i] + nums[left] + nums[right]
            if total == 0:
                result.append([nums[i], nums[left], nums[right]])
                left += 1
                right -= 1
            elif total < 0:
                left += 1
            else:
                right -= 1
    return result

print(three_sum([0, 0, 0, 0]))

A No error, output: [[0, 0, 0], [0, 0, 0]]

B Infinite loop because duplicates are not skipped

C IndexError due to skipping duplicates incorrectly

D TypeError due to wrong data type

💡 Hint

Check how duplicates are handled inside the while loop.

The code does not skip duplicates after finding a triplet nor in the outer loop, resulting in duplicate triplets [[0, 0, 0], [0, 0, 0]] in the output.

❓ Predict Output

advanced

Output of Modified Three Sum with Early Break

What is the output of this modified three_sum function when called with nums = [-2, 0, 1, 1, 2]?

DSA Python

def three_sum(nums):
    nums.sort()
    result = []
    for i in range(len(nums) - 2):
        if nums[i] > 0:
            break
        if i > 0 and nums[i] == nums[i - 1]:
            continue
        left, right = i + 1, len(nums) - 1
        while left < right:
            total = nums[i] + nums[left] + nums[right]
            if total == 0:
                result.append([nums[i], nums[left], nums[right]])
                while left < right and nums[left] == nums[left + 1]:
                    left += 1
                while left < right and nums[right] == nums[right - 1]:
                    right -= 1
                left += 1
                right -= 1
            elif total < 0:
                left += 1
            else:
                right -= 1
    return result

print(three_sum([-2, 0, 1, 1, 2]))

A [[0, 1, -1]]

B [[-2, 1, 1]]

C [[-2, 0, 2], [-2, 1, 1]]

D []

💡 Hint

The early break stops the loop if the current number is positive.

The function finds two unique triplets that sum to zero: [-2, 0, 2] and [-2, 1, 1].

🧠 Conceptual

expert

Time Complexity of Three Sum Algorithm

What is the time complexity of the standard three sum algorithm that sorts the array and uses two pointers to find unique triplets?

A O(n^3)

B O(n log n)

C O(n)

D O(n^2)

💡 Hint

Consider the sorting step and the nested loops with two pointers.

Sorting takes O(n log n). The main loop runs O(n) times, and inside it, the two pointers scan the array in O(n) total, resulting in O(n^2) overall.