4sum

Author: volodimyr

18.4sum/sum.go

@@ -0,0 +1,68 @@
+// 18. 4Sum
+// Topics: 'Array', 'Two Pointers', 'Sorting'
+// Level: 'Medium'
+
+// Given an array nums of n integers, return an array of all the unique quadruplets [nums[a], nums[b], nums[c], nums[d]] such that:
+
+//     0 <= a, b, c, d < n
+//     a, b, c, and d are distinct.
+//     nums[a] + nums[b] + nums[c] + nums[d] == target
+
+// You may return the answer in any order.
+
+// Example 1:
+
+// Input: nums = [1,0,-1,0,-2,2], target = 0
+// Output: [[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]
+
+// Example 2:
+
+// Input: nums = [2,2,2,2,2], target = 8
+// Output: [[2,2,2,2]]
+
+// Constraints:
+
+//     1 <= nums.length <= 200
+//     -109 <= nums[i] <= 109
+//     -109 <= target <= 109
+
+package sum
+
+import "sort"
+
+func fourSum(nums []int, target int) [][]int {
+	sort.Ints(nums)
+	res := [][]int{}
+
+	for i := range len(nums) - 3 {
+		if i > 0 && nums[i-1] == nums[i] {
+			continue
+		}
+		for L := i + 1; L < len(nums)-2; L++ {
+			if L > i+1 && nums[L] == nums[L-1] {
+				continue
+			}
+			L1 := L + 1
+			R := len(nums) - 1
+			for L1 < R {
+				total := nums[i] + nums[L] + nums[L1] + nums[R]
+				if total == target {
+					res = append(res, []int{nums[i], nums[L], nums[L1], nums[R]})
+					for L1 < R && nums[L1] == nums[L1+1] {
+						L1++
+					}
+					for L1 < R && nums[R] == nums[R-1] {
+						R--
+					}
+					L1++
+					R--
+				} else if total > target {
+					R--
+				} else {
+					L1++
+				}
+			}
+		}
+	}
+	return res
+}

18.4sum/sum_test.go

@@ -0,0 +1,161 @@
+package sum
+
+import (
+	"reflect"
+	"sort"
+	"testing"
+)
+
+func TestFourSum(t *testing.T) {
+	tests := []struct {
+		name   string
+		nums   []int
+		target int
+		want   [][]int
+	}{
+		{
+			name:   "basic case",
+			nums:   []int{1, 0, -1, 0, -2, 2},
+			target: 0,
+			want:   [][]int{{-2, -1, 1, 2}, {-2, 0, 0, 2}, {-1, 0, 0, 1}},
+		},
+		{
+			name:   "no solution",
+			nums:   []int{2, 2, 2, 2, 2},
+			target: 9,
+			want:   [][]int{},
+		},
+		{
+			name:   "single solution",
+			nums:   []int{1, 2, 3, 4},
+			target: 10,
+			want:   [][]int{{1, 2, 3, 4}},
+		},
+		{
+			name:   "empty array",
+			nums:   []int{},
+			target: 0,
+			want:   [][]int{},
+		},
+		{
+			name:   "array too small",
+			nums:   []int{1, 2, 3},
+			target: 6,
+			want:   [][]int{},
+		},
+		{
+			name:   "all same values with solution",
+			nums:   []int{2, 2, 2, 2, 2},
+			target: 8,
+			want:   [][]int{{2, 2, 2, 2}},
+		},
+		{
+			name:   "duplicates test",
+			nums:   []int{0, 0, 0, 0},
+			target: 0,
+			want:   [][]int{{0, 0, 0, 0}},
+		},
+		{
+			name:   "negative target",
+			nums:   []int{-3, -2, -1, 0, 1, 2, 3},
+			target: -6,
+			want:   [][]int{{-3, -2, -1, 0}},
+		},
+		{
+			name:   "positive target",
+			nums:   []int{-3, -2, -1, 0, 1, 2, 3},
+			target: 6,
+			want:   [][]int{{0, 1, 2, 3}},
+		},
+		{
+			name:   "large target",
+			nums:   []int{1, 2, 3, 4, 5, 6},
+			target: 18,
+			want:   [][]int{{3, 4, 5, 6}},
+		},
+		{
+			name:   "multiple duplicates",
+			nums:   []int{-1, -1, -1, 0, 0, 0, 1, 1, 1},
+			target: 0,
+			want:   [][]int{{-1, -1, 1, 1}, {-1, 0, 0, 1}},
+		},
+		{
+			name:   "complex duplicates",
+			nums:   []int{2, 2, 2, 2, 2, 2, 2, 2},
+			target: 8,
+			want:   [][]int{{2, 2, 2, 2}},
+		},
+		{
+			name:   "exactly 4 elements",
+			nums:   []int{1, 2, 3, 4},
+			target: 100,
+			want:   [][]int{},
+		},
+		{
+			name:   "exactly 4 elements with solution",
+			nums:   []int{1, 2, 3, 4},
+			target: 10,
+			want:   [][]int{{1, 2, 3, 4}},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := fourSum(tt.nums, tt.target)
+
+			// Sort both slices for comparison
+			sortQuadruplets(got)
+			sortQuadruplets(tt.want)
+
+			if !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("fourSum() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+// Helper function to sort quadruplets for consistent comparison
+func sortQuadruplets(quads [][]int) {
+	// Sort each individual quadruplet
+	for _, quad := range quads {
+		sort.Ints(quad)
+	}
+
+	// Sort the slice of quadruplets
+	sort.Slice(quads, func(i, j int) bool {
+		for k := 0; k < 4 && k < len(quads[i]) && k < len(quads[j]); k++ {
+			if quads[i][k] != quads[j][k] {
+				return quads[i][k] < quads[j][k]
+			}
+		}
+		return false
+	})
+}
+
+// Test for no duplicates in results
+func TestFourSumNoDuplicates(t *testing.T) {
+	nums := []int{1, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3}
+	target := 8
+
+	result := fourSum(nums, target)
+
+	// Check for duplicate quadruplets
+	seen := make(map[[4]int]bool)
+	for _, quad := range result {
+		if len(quad) != 4 {
+			t.Errorf("Expected quadruplet of length 4, got %d", len(quad))
+		}
+
+		key := [4]int{quad[0], quad[1], quad[2], quad[3]}
+		if seen[key] {
+			t.Errorf("Found duplicate quadruplet: %v", quad)
+		}
+		seen[key] = true
+
+		// Verify sum
+		sum := quad[0] + quad[1] + quad[2] + quad[3]
+		if sum != target {
+			t.Errorf("Quadruplet %v sums to %d, expected %d", quad, sum, target)
+		}
+	}
+}