feat: add func ContainSubSlice

slice/slice.go

@@ -24,6 +24,21 @@ func Contain[T comparable](slice []T, value T) bool {
 	return false
 }
 
+// ContainSubSlice check if the slice contain subslice or not
+func ContainSubSlice[T comparable](slice, subslice []T) bool {
+	unique := make(map[T]bool)
+	for _, v := range slice {
+		unique[v] = true
+	}
+	for _, v := range subslice {
+		if !unique[v] {
+			return false
+		}
+	}
+
+	return true
+}
+
 // Chunk creates an slice of elements split into groups the length of size.
 func Chunk[T any](slice []T, size int) [][]T {
 	var res [][]T

slice/slice_test.go

@@ -17,6 +17,14 @@ func TestContain(t *testing.T) {
 	assert.Equal(true, Contain([]int{1, 2, 3}, 1))
 }
 
+func TestContainSubSlice(t *testing.T) {
+	assert := internal.NewAssert(t, "TestContainSubSlice")
+	assert.Equal(true, ContainSubSlice([]string{"a", "a", "b", "c"}, []string{"a", "a"}))
+	assert.Equal(false, ContainSubSlice([]string{"a", "a", "b", "c"}, []string{"a", "d"}))
+	assert.Equal(true, ContainSubSlice([]int{1, 2, 3}, []int{1}))
+	assert.Equal(false, ContainSubSlice([]int{1, 2, 3}, []int{0}))
+}
+
 func TestChunk(t *testing.T) {
 	assert := internal.NewAssert(t, "TestChunk")
 

slice/slice_util.go

@@ -5,6 +5,31 @@ import (
 	"reflect"
 )
 
+// func quickSort[T comparable](slice []T, low, high int) []T {
+// 	if low < high {
+// 		var p int
+// 		slice, p = partitionForQuickSort(slice, low, high)
+// 		slice = quickSort(slice, low, p-1)
+// 		slice = quickSort(slice, p+1, high)
+// 	}
+
+// 	return slice
+// }
+
+// func partitionForQuickSort[T comparable](slice []T, low, high int) ([]T, int) {
+// 	p := slice[high]
+// 	i := low
+// 	for j := low; j < high; j++ {
+// 		//???, error: comparable don't support operator <
+// 		if slice[j] < p {
+// 			slice[i], slice[j] = slice[j], slice[i]
+// 			i++
+// 		}
+// 	}
+// 	slice[i], slice[high] = slice[high], slice[i]
+// 	return slice, i
+// }
+
 // sliceValue return the reflect value of a slice
 func sliceValue(slice interface{}) reflect.Value {
 	v := reflect.ValueOf(slice)