[Arrays & Hashing][Product of Array Except Self] - Implement solution for Leetcode 238 (#12)

Author: javydevx

1_arrays_and_hashing/7_product_of_array_except_self/solution.go

@@ -0,0 +1,98 @@
+package productofarrayexceptself
+
+// Time complexity: O(n^2), where n is the length of the input array.
+// Space complexity: O(n), for the output array.
+func ProductExceptSelfBruteForce(nums []int) []int {
+	n := len(nums)
+	result := make([]int, n)
+
+	for i := 0; i < n; i++ {
+		product := 1
+		for j := 0; j < n; j++ {
+			if i != j {
+				product *= nums[j]
+			}
+		}
+		result[i] = product
+	}
+	return result
+}
+
+// Time complexity: O(n), where n is the length of the input array.
+// Space complexity: O(1), for the output array (ignoring the output size).
+func ProductExceptSelfDivision(nums []int) []int {
+	n := len(nums)
+	result := make([]int, n)
+
+	totalProduct := 1
+	zeroCount := 0
+
+	for _, num := range nums {
+		if num != 0 {
+			totalProduct *= num
+		} else {
+			zeroCount++
+		}
+	}
+
+	for i, num := range nums {
+		if zeroCount > 1 {
+			result[i] = 0
+		} else if zeroCount == 1 {
+			if num == 0 {
+				result[i] = totalProduct
+			} else {
+				result[i] = 0
+			}
+		} else {
+			result[i] = totalProduct / num
+		}
+	}
+	return result
+}
+
+// Time complexity: O(n), where n is the length of the input array.
+// Space complexity: O(n), for the output array.
+func ProductExceptSelfPrefixSuffix(nums []int) []int {
+	n := len(nums)
+	prefix := make([]int, n)
+	suffix := make([]int, n)
+	result := make([]int, n)
+
+	prefix[0] = 1
+	for i := 1; i < n; i++ {
+		prefix[i] = prefix[i-1] * nums[i-1]
+	}
+
+	suffix[n-1] = 1
+	for i := n - 2; i >= 0; i-- {
+		suffix[i] = suffix[i+1] * nums[i+1]
+	}
+
+	for i := 0; i < n; i++ {
+		result[i] = prefix[i] * suffix[i]
+	}
+	return result
+}
+
+// Time complexity: O(n), where n is the length of the input array.
+// Space complexity: O(1), for the output array (ignoring the output size).
+func ProductExceptSelfPrefixSuffixOptimal(nums []int) []int {
+	n := len(nums)
+	res := make([]int, n)
+
+	// Prefix pass
+	res[0] = 1
+	for i := 1; i < n; i++ {
+		res[i] = res[i-1] * nums[i-1]
+	}
+
+	// Suffix pass
+	suffix := 1
+	for i := n - 1; i >= 0; i-- {
+		res[i] *= suffix
+		suffix *= nums[i]
+	}
+
+	return res
+}

1_arrays_and_hashing/7_product_of_array_except_self/solution_test.go

@@ -0,0 +1,52 @@
+package productofarrayexceptself
+
+import (
+	"reflect"
+	"testing"
+)
+
+func TestProductExceptSelf(t *testing.T) {
+	cases := []struct {
+		name     string
+		fn       func([]int) []int
+		nums     []int
+		expected []int
+	}{
+		// ProductExceptSelfBruteForce
+		{"Brute Force - Basic", ProductExceptSelfBruteForce, []int{1, 2, 3, 4}, []int{24, 12, 8, 6}},
+		{"Brute Force - One Zero", ProductExceptSelfBruteForce, []int{1, 2, 0, 4}, []int{0, 0, 8, 0}},
+		{"Brute Force - Two Zeros", ProductExceptSelfBruteForce, []int{0, 2, 0, 4}, []int{0, 0, 0, 0}},
+		{"Brute Force - Single", ProductExceptSelfBruteForce, []int{10}, []int{1}},
+		{"Brute Force - Same Elements", ProductExceptSelfBruteForce, []int{3, 3, 3}, []int{9, 9, 9}},
+
+		// ProductExceptSelfDivision
+		{"Division - Basic", ProductExceptSelfDivision, []int{1, 2, 3, 4}, []int{24, 12, 8, 6}},
+		{"Division - One Zero", ProductExceptSelfDivision, []int{1, 2, 0, 4}, []int{0, 0, 8, 0}},
+		{"Division - Two Zeros", ProductExceptSelfDivision, []int{0, 2, 0, 4}, []int{0, 0, 0, 0}},
+		{"Division - Single", ProductExceptSelfDivision, []int{10}, []int{1}},
+		{"Division - Same Elements", ProductExceptSelfDivision, []int{3, 3, 3}, []int{9, 9, 9}},
+
+		// ProductExceptSelfPrefixSuffix
+		{"Prefix & Suffix - Basic", ProductExceptSelfPrefixSuffix, []int{1, 2, 3, 4}, []int{24, 12, 8, 6}},
+		{"Prefix & Suffix - One Zero", ProductExceptSelfPrefixSuffix, []int{1, 2, 0, 4}, []int{0, 0, 8, 0}},
+		{"Prefix & Suffix - Two Zeros", ProductExceptSelfPrefixSuffix, []int{0, 2, 0, 4}, []int{0, 0, 0, 0}},
+		{"Prefix & Suffix - Single", ProductExceptSelfPrefixSuffix, []int{10}, []int{1}},
+		{"Prefix & Suffix - Same Elements", ProductExceptSelfPrefixSuffix, []int{3, 3, 3}, []int{9, 9, 9}},
+
+		// ProductExceptSelfPrefixSuffixOptimal
+		{"Prefix & Suffix Optimal - Basic", ProductExceptSelfPrefixSuffixOptimal, []int{1, 2, 3, 4}, []int{24, 12, 8, 6}},
+		{"Prefix & Suffix Optimal - One Zero", ProductExceptSelfPrefixSuffixOptimal, []int{1, 2, 0, 4}, []int{0, 0, 8, 0}},
+		{"Prefix & Suffix Optimal - Two Zeros", ProductExceptSelfPrefixSuffixOptimal, []int{0, 2, 0, 4}, []int{0, 0, 0, 0}},
+		{"Prefix & Suffix Optimal - Single", ProductExceptSelfPrefixSuffixOptimal, []int{10}, []int{1}},
+		{"Prefix & Suffix Optimal - Same Elements", ProductExceptSelfPrefixSuffixOptimal, []int{3, 3, 3}, []int{9, 9, 9}},
+	}
+
+	for _, c := range cases {
+		t.Run(c.name, func(t *testing.T) {
+			got := c.fn(c.nums)
+			if !reflect.DeepEqual(got, c.expected) {
+				t.Errorf("%s failed: expected %v, got %v", c.name, c.expected, got)
+			}
+		})
+	}
+}