Solving the 3Sum Problem

The "3Sum" problem is a classic algorithmic challenge that requires finding all unique triplets in an array that add up to zero. This problem steps up from the simpler "Two Sum" problem and tests your ability to manipulate arrays and apply the two-pointer technique.

The Problem

Given an array nums of integers, the task is to find all unique triplets in the array that sum up to zero.

The Solution

Here's a JavaScript function that effectively solves the 3Sum problem:

The Explanation

• Sort the Array: The array is sorted to use the two-pointer technique effectively.
• Iterate and Find Triplets: Loop through the array, for each element, use a left and right pointer to find triplets.
• Skip Duplicates: Skip over duplicate elements to avoid repeating triplets.
• Two-Pointer Technique: Adjust the left and right pointers to find different combinations that sum up to zero.

Conclusion

This problem is a perfect example of the application of sorting and two-pointer techniques in solving complex array problems. It's often used in coding interviews to assess a candidate's problem-solving and array manipulation skills.

Rust Solution

three_sum takes mut nums: Vec<i32> by value, so nums.sort() mutates the moved-in vector in place with no defensive copy. The if n < 3 { return triplets; } guard is load-bearing in a way the JS version never needs: because n comes from nums.len() it is unsigned, so the 0..n - 2 range would panic on subtraction overflow the instant the array held fewer than two elements. Rows are built with the vec! macro and the return type Vec<Vec<i32>> is spelled out on the signature rather than inferred. The main demo formats each row via .iter().map(|x| x.to_string()) and a turbofish collect::<Vec<_>>() before .join(","), since collect needs to be told which collection to produce.

Go Solution

sort.Ints(nums) from the sort package sorts the slice in place, and var triplets [][]int declares a nil slice, so return triplets on a no-match input hands back nil rather than JS's empty [] — though append and range both treat a nil slice as empty. Because n := len(nums) is an int, the n-2 loop bound needs no underflow guard, unlike Rust's unsigned slice indices. New rows are added with append(triplets, []int{...}), and Go reuses for for the while-style for left < right loops since it has no while keyword. The main demo runs for _, t := range r, discarding the index through the blank identifier _ and printing with fmt.Printf.