3sum

Author: volodimyr

15.3_sum/sum.go

@@ -0,0 +1,73 @@
+// 15. 3Sum
+// Topics: 'Array', 'Sorting', 'Two Pointers'
+// Level: 'Medium'
+
+// Given an integer array nums, return all the triplets [nums[i], nums[j], nums[k]] such that i != j, i != k, and j != k, and nums[i] + nums[j] + nums[k] == 0.
+
+// Notice that the solution set must not contain duplicate triplets.
+
+// Example 1:
+
+// Input: nums = [-1,0,1,2,-1,-4]
+// Output: [[-1,-1,2],[-1,0,1]]
+// Explanation:
+// 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].
+// Notice that the order of the output and the order of the triplets does not matter.
+
+// Example 2:
+
+// Input: nums = [0,1,1]
+// Output: []
+// Explanation: The only possible triplet does not sum up to 0.
+
+// Example 3:
+
+// Input: nums = [0,0,0]
+// Output: [[0,0,0]]
+// Explanation: The only possible triplet sums up to 0.
+
+// Constraints:
+
+//     3 <= nums.length <= 3000
+//     -105 <= nums[i] <= 105
+
+package sum
+
+import "sort"
+
+func threeSum(nums []int) [][]int {
+	sort.Ints(nums)
+	res := [][]int{}
+
+	for i := range len(nums) - 2 {
+		if i > 0 && nums[i-1] == nums[i] {
+			continue
+		}
+
+		L := i + 1
+		R := len(nums) - 1
+
+		for L < R {
+			total := nums[i] + nums[L] + nums[R]
+			if total == 0 {
+				res = append(res, []int{nums[i], nums[L], nums[R]})
+				for L < R && nums[R] == nums[R-1] {
+					R--
+				}
+				for L < R && nums[L] == nums[L+1] {
+					L++
+				}
+				R--
+				L++
+			} else if total > 0 {
+				R--
+			} else {
+				L++
+			}
+		}
+	}
+	return res
+}

15.3_sum/sum_test.go

@@ -0,0 +1,145 @@
+package sum
+
+import (
+	"reflect"
+	"sort"
+	"testing"
+)
+
+// Helper function to sort triplets for comparison
+func sortTriplets(triplets [][]int) {
+	// Sort each individual triplet
+	for _, triplet := range triplets {
+		sort.Ints(triplet)
+	}
+	// Sort the slice of triplets
+	sort.Slice(triplets, func(i, j int) bool {
+		for k := 0; k < 3; k++ {
+			if triplets[i][k] != triplets[j][k] {
+				return triplets[i][k] < triplets[j][k]
+			}
+		}
+		return false
+	})
+}
+
+func TestThreeSum(t *testing.T) {
+	tests := []struct {
+		name     string
+		nums     []int
+		expected [][]int
+	}{
+		{
+			name:     "Example 1 - Multiple triplets",
+			nums:     []int{-1, 0, 1, 2, -1, -4},
+			expected: [][]int{{-1, -1, 2}, {-1, 0, 1}},
+		},
+		{
+			name:     "Example 2 - No valid triplets",
+			nums:     []int{0, 1, 1},
+			expected: [][]int{},
+		},
+		{
+			name:     "Example 3 - All zeros",
+			nums:     []int{0, 0, 0},
+			expected: [][]int{{0, 0, 0}},
+		},
+		{
+			name:     "Minimum length array",
+			nums:     []int{-1, 0, 1},
+			expected: [][]int{{-1, 0, 1}},
+		},
+		{
+			name:     "All negative numbers",
+			nums:     []int{-5, -4, -3, -2, -1},
+			expected: [][]int{},
+		},
+		{
+			name:     "All positive numbers",
+			nums:     []int{1, 2, 3, 4, 5},
+			expected: [][]int{},
+		},
+		{
+			name:     "Multiple duplicates",
+			nums:     []int{-2, 0, 0, 2, 2},
+			expected: [][]int{{-2, 0, 2}},
+		},
+		{
+			name:     "Complex case with duplicates",
+			nums:     []int{-4, -2, -2, -2, 0, 1, 2, 2, 2, 3, 3, 4, 4, 6, 6},
+			expected: [][]int{{-4, -2, 6}, {-4, 0, 4}, {-4, 1, 3}, {-4, 2, 2}, {-2, -2, 4}, {-2, 0, 2}},
+		},
+		{
+			name:     "Two zeros with negatives and positives",
+			nums:     []int{-1, 0, 0, 1},
+			expected: [][]int{{-1, 0, 1}},
+		},
+		{
+			name:     "Single triplet with duplicates",
+			nums:     []int{1, 1, -2},
+			expected: [][]int{{-2, 1, 1}},
+		},
+		{
+			name:     "Multiple zeros",
+			nums:     []int{0, 0, 0, 0},
+			expected: [][]int{{0, 0, 0}},
+		},
+		{
+			name:     "Empty result with exact 3 elements",
+			nums:     []int{1, 2, 3},
+			expected: [][]int{},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			// Make a copy to avoid modifying test data
+			numsCopy := make([]int, len(tt.nums))
+			copy(numsCopy, tt.nums)
+
+			result := threeSum(numsCopy)
+
+			// Sort both result and expected for comparison
+			sortTriplets(result)
+			sortTriplets(tt.expected)
+
+			if !reflect.DeepEqual(result, tt.expected) {
+				t.Errorf("threeSum(%v) = %v, want %v", tt.nums, result, tt.expected)
+			}
+		})
+	}
+}
+
+func TestThreeSumNoDuplicates(t *testing.T) {
+	nums := []int{-1, 0, 1, 2, -1, -4}
+	result := threeSum(nums)
+
+	// Check for duplicate triplets
+	seen := make(map[[3]int]bool)
+	for _, triplet := range result {
+		sort.Ints(triplet)
+		key := [3]int{triplet[0], triplet[1], triplet[2]}
+		if seen[key] {
+			t.Errorf("Found duplicate triplet: %v", triplet)
+		}
+		seen[key] = true
+	}
+}
+
+func TestThreeSumValidSums(t *testing.T) {
+	testCases := [][]int{
+		{-1, 0, 1, 2, -1, -4},
+		{0, 0, 0},
+		{-2, 0, 1, 1, 2},
+	}
+
+	for _, nums := range testCases {
+		result := threeSum(nums)
+		for _, triplet := range result {
+			sum := triplet[0] + triplet[1] + triplet[2]
+			if sum != 0 {
+				t.Errorf("Triplet %v does not sum to 0, got sum = %d", triplet, sum)
+			}
+		}
+	}
+}