implement slices venn functions: Disjunction, Intersection, Union and Subtract

Author: sinhashubham95

src/slices/slices.go

@@ -566,3 +566,78 @@ func Filter[S ~[]E, E any](s S, predicate func(e E, i int) bool) S {
 	clear(s[i:]) // zero/nil out the obsolete elements, for GC
 	return s[:i]
 }
+
+// Disjunction returns a slice containing the exclusive disjunction (symmetric difference) of the given slices.
+// This means the elements which are in either one of the slice but not in both.
+func Disjunction[S ~[]E, E comparable](s1, s2 S) S {
+	ms1 := CardinalityMap(s1)
+	ms2 := CardinalityMap(s2)
+	r := make(S, 0, len(s1)+len(s2))
+	for _, v := range s1 {
+		if ms2[v] > 0 {
+			ms1[v] -= 1
+			ms2[v] -= 1
+		} else {
+			r = append(r, v)
+		}
+	}
+	for _, v := range s2 {
+		if ms2[v] > 0 {
+			ms2[v] -= 1
+			r = append(r, v)
+		}
+	}
+	return Clip(r)
+}
+
+// Intersection returns a slice containing the intersection of the given slices.
+// This means the elements which are in both the given slices.
+func Intersection[S ~[]E, E comparable](s1, s2 S) S {
+	ms1 := CardinalityMap(s1)
+	ms2 := CardinalityMap(s2)
+	r := make(S, 0, min(len(s1), len(s2)))
+	for _, v := range s1 {
+		if ms2[v] > 0 {
+			ms2[v] -= 1
+			r = append(r, v)
+		}
+		ms1[v] -= 1
+	}
+	return Clip(r)
+}
+
+// Union is used to do the union of the 2 provided collections.
+// The cardinality of each element in the returned collection will be equal to the maximum of that element in the given 2 collections.
+func Union[S ~[]E, E comparable](s1, s2 S) S {
+	if len(s1) == 0 {
+		return s2
+	}
+	if len(s2) == 0 {
+		return s1
+	}
+	r := make(S, 0, len(s1)+len(s2))
+	r = append(r, s1...)
+	ms1 := CardinalityMap(s1)
+	for _, v := range s2 {
+		if ms1[v] <= 0 {
+			r = append(r, v)
+		}
+		ms1[v] -= 1
+	}
+	return Clip(r)
+}
+
+// Subtract return a new slice containing s1 - s2 i.e. all elements of s2 removed from s1.
+func Subtract[S ~[]E, E comparable](s1, s2 S) S {
+	m := CardinalityMap(s2)
+	r := make(S, 0, len(s1))
+	for _, v := range s1 {
+		c := m[v]
+		if c > 0 {
+			m[v] -= 1
+		} else {
+			r = append(r, v)
+		}
+	}
+	return Clip(r)
+}

src/slices/slices_test.go

@@ -1632,3 +1632,143 @@ func BenchmarkFilter_Large(b *testing.B) {
 		_ = Filter(ss, predicate)
 	}
 }
+
+var disjunctionTests = []struct {
+	s1   []int
+	s2   []int
+	want []int
+}{
+	{
+		nil,
+		nil,
+		nil,
+	},
+	{
+		[]int{1, 5, 9, 6, 7},
+		[]int{2, 6, 7, 3},
+		[]int{1, 5, 9, 2, 3},
+	},
+	{
+		[]int{1, 2, 1, 3, 1, 2},
+		[]int{1, 2, 2, 3},
+		[]int{1, 1},
+	},
+	{
+		[]int{1, 2, 3},
+		[]int{1, 2, 3},
+		nil,
+	},
+}
+
+func TestDisjunction(t *testing.T) {
+	for _, test := range disjunctionTests {
+		if got := Disjunction(test.s1, test.s2); !Equal(got, test.want) {
+			t.Errorf("Disjunction(%v, %v) = %v, want %v", test.s1, test.s2, got, test.want)
+		}
+	}
+}
+
+var intersectionTests = []struct {
+	s1   []int
+	s2   []int
+	want []int
+}{
+	{
+		nil,
+		nil,
+		nil,
+	},
+	{
+		[]int{1, 5, 9, 6, 7},
+		[]int{2, 6, 7, 3},
+		[]int{6, 7},
+	},
+	{
+		[]int{1, 2, 1, 3, 1, 2},
+		[]int{1, 2, 2, 3},
+		[]int{1, 2, 3, 2},
+	},
+	{
+		[]int{1, 2, 3},
+		[]int{1, 2, 3},
+		[]int{1, 2, 3},
+	},
+}
+
+func TestIntersection(t *testing.T) {
+	for _, test := range intersectionTests {
+		if got := Intersection(test.s1, test.s2); !Equal(got, test.want) {
+			t.Errorf("Intersection(%v, %v) = %v, want %v", test.s1, test.s2, got, test.want)
+		}
+	}
+}
+
+var unionTests = []struct {
+	s1   []int
+	s2   []int
+	want []int
+}{
+	{
+		nil,
+		nil,
+		nil,
+	},
+	{
+		[]int{1, 5, 9, 6, 7},
+		[]int{2, 6, 7, 3},
+		[]int{1, 5, 9, 6, 7, 2, 3},
+	},
+	{
+		[]int{1, 2, 1, 3, 1, 2},
+		[]int{1, 2, 2, 3},
+		[]int{1, 2, 1, 3, 1, 2},
+	},
+	{
+		[]int{1, 2, 3},
+		[]int{1, 2, 3},
+		[]int{1, 2, 3},
+	},
+}
+
+func TestUnion(t *testing.T) {
+	for _, test := range unionTests {
+		if got := Union(test.s1, test.s2); !Equal(got, test.want) {
+			t.Errorf("Union(%v, %v) = %v, want %v", test.s1, test.s2, got, test.want)
+		}
+	}
+}
+
+var subtractTests = []struct {
+	s1   []int
+	s2   []int
+	want []int
+}{
+	{
+		nil,
+		nil,
+		nil,
+	},
+	{
+		[]int{1, 5, 9, 6, 7},
+		[]int{2, 6, 7, 3},
+		[]int{1, 5, 9},
+	},
+	{
+		[]int{1, 2, 1, 3, 1, 2},
+		[]int{1, 2, 2, 3},
+		[]int{1, 1},
+	},
+	{
+		[]int{1, 2, 3},
+		[]int{1, 2, 3},
+		nil,
+	},
+}
+
+func TestSubtract(t *testing.T) {
+	for _, test := range subtractTests {
+		if got := Subtract(test.s1, test.s2); !Equal(got, test.want) {
+			t.Errorf("Subtract(%v, %v) = %v, want %v", test.s1, test.s2, got, test.want)
+		}
+	}
+}