Product of array except self

Author: volodimyr

238.product_of_array_except_self/product.go

@@ -0,0 +1,50 @@
+// 238. Product of array except self
+// Topics: 'Prefix Sum', 'Array'
+// Level: 'Medium'
+
+// Given an integer array nums, return an array answer such that answer[i] is equal to the product of all the elements of nums except nums[i].
+
+// The product of any prefix or suffix of nums is guaranteed to fit in a 32-bit integer.
+
+// You must write an algorithm that runs in O(n) time and without using the division operation.
+
+// Example 1:
+
+// Input: nums = [1,2,3,4]
+// Output: [24,12,8,6]
+
+// Example 2:
+
+// Input: nums = [-1,1,0,-3,3]
+// Output: [0,0,9,0,0]
+
+// Constraints:
+
+//     2 <= nums.length <= 105
+//     -30 <= nums[i] <= 30
+//     The input is generated such that answer[i] is guaranteed to fit in a 32-bit integer.
+
+// Follow up: Can you solve the problem in O(1) extra space complexity? (The output array does not count as extra space for space complexity analysis.)
+
+package productofarrayexceptself
+
+func productExceptSelf(nums []int) []int {
+	res := make([]int, len(nums))
+
+	prefix := 1
+	for i := range nums {
+		prefix *= nums[i]
+		res[i] = prefix
+	}
+	suffix := 1
+	for i := len(nums) - 1; i >= 0; i-- {
+		p := 1
+		if (i - 1) >= 0 {
+			p = res[i-1]
+		}
+		res[i] = p * suffix
+		suffix *= nums[i]
+	}
+
+	return res
+}

238.product_of_array_except_self/product_test.go

@@ -0,0 +1,119 @@
+package productofarrayexceptself
+
+import (
+	"reflect"
+	"testing"
+)
+
+func TestProductExceptSelf(t *testing.T) {
+	tests := []struct {
+		name string
+		nums []int
+		want []int
+	}{
+		{
+			name: "example 1 - basic positive numbers",
+			nums: []int{1, 2, 3, 4},
+			want: []int{24, 12, 8, 6},
+		},
+		{
+			name: "example 2 - with zero in middle",
+			nums: []int{-1, 1, 0, -3, 3},
+			want: []int{0, 0, 9, 0, 0},
+		},
+		{
+			name: "two elements",
+			nums: []int{2, 3},
+			want: []int{3, 2},
+		},
+		{
+			name: "all ones",
+			nums: []int{1, 1, 1, 1},
+			want: []int{1, 1, 1, 1},
+		},
+		{
+			name: "zero at start",
+			nums: []int{0, 2, 3},
+			want: []int{6, 0, 0},
+		},
+		{
+			name: "zero at end",
+			nums: []int{2, 3, 0},
+			want: []int{0, 0, 6},
+		},
+		{
+			name: "multiple zeros",
+			nums: []int{0, 0, 2, 3},
+			want: []int{0, 0, 0, 0},
+		},
+		{
+			name: "negative numbers",
+			nums: []int{-2, -3, -4},
+			want: []int{12, 8, 6},
+		},
+		{
+			name: "mixed positive and negative",
+			nums: []int{2, -3, 4, -5},
+			want: []int{60, -40, 30, -24},
+		},
+		{
+			name: "single negative with positives",
+			nums: []int{1, -2, 3, 4},
+			want: []int{-24, 12, -8, -6},
+		},
+		{
+			name: "larger array",
+			nums: []int{1, 2, 3, 4, 5},
+			want: []int{120, 60, 40, 30, 24},
+		},
+		{
+			name: "array with one and zero",
+			nums: []int{1, 0},
+			want: []int{0, 1},
+		},
+		{
+			name: "maximum negative value",
+			nums: []int{-30, 2, 3},
+			want: []int{6, -90, -60},
+		},
+		{
+			name: "all negative ones",
+			nums: []int{-1, -1, -1},
+			want: []int{1, 1, 1},
+		},
+		{
+			name: "even count of negatives",
+			nums: []int{-1, -2, -3, -4},
+			want: []int{-24, -12, -8, -6},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := productExceptSelf(tt.nums)
+			if !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("productExceptSelf(%v) = %v, want %v", tt.nums, got, tt.want)
+			}
+		})
+	}
+}
+
+func TestProductExceptSelf_Properties(t *testing.T) {
+	t.Run("output length equals input length", func(t *testing.T) {
+		nums := []int{1, 2, 3, 4, 5}
+		result := productExceptSelf(nums)
+		if len(result) != len(nums) {
+			t.Errorf("output length %d != input length %d", len(result), len(nums))
+		}
+	})
+
+	t.Run("no mutation of input array", func(t *testing.T) {
+		nums := []int{1, 2, 3, 4}
+		original := make([]int, len(nums))
+		copy(original, nums)
+		productExceptSelf(nums)
+		if !reflect.DeepEqual(nums, original) {
+			t.Errorf("input array was mutated: got %v, want %v", nums, original)
+		}
+	})
+}