如何在GO中检查切片是否在切片中？

Question

I have the following code:

func main(){
    l1 := []string{"a", "b", "c"}
    l2 := []string {"a", "c"}
    //l2 in l1?
}

I can check this using loops and flags but Is there a simple way to check if l2 is inside l1 like python command "l2 in l1"?

Answer 1

Following from How to check if a slice is inside a slice in GO? , @Mostafa posted the following for checking if an element is in a slice:

func contains(s []string, e string) bool {
   for _, a := range s {
        if a == e {
            return true
        }
    }
    return false
}

Now it's a matter of checking element by element:

func subslice (s1 []string, s2 []string) bool {
    if len(s1) > len(s2) { return false }
    for _, e := range s1 {
        if ! contains(s2,e) {
            return false
        }
    }
    return true
}

Of course, this ignores duplicates, so there's room for improvement.

Answer 2

@Kabanus's answer is of O(mn) time complexity. Despite being slow in large scale, it only requires elemenent of both set to be == comparable, which is almost any cases.

But if your data is hashable, and preferably hashable by default (ie can be used as key of a map ), using an auxiliary map is a much more efficient way:

package main

import (
    "fmt"
)

type Universe map[string]bool

func NewUniverse(s []string) Universe {
    u:=make(Universe)
    for _,i:=range s {
        u[i]=true
    }
    return u
}

func (u Universe) CountainSet(s []string) bool {
    for _,i:=range s {
        if !u[i] {
            return false
        }
    }
    return true
}

func main() {
    fmt.Println(NewUniverse([]string{"a","b","c"}).CountainSet([]string{"a","c"}))
}

Dealing with duplicate is very trivial: change map[string]bool to map[string]int and compare element count.

Playground: https://play.golang.org/p/pdM4DO3UO2e

Answer 3

It appears that you are looking for set issubset:

In Python it would look like this:

In [1]: l1 = ["a", "b", "c"]

In [2]: l2 = ["a", "c"]

In [3]: set(l2).issubset(l1)
Out[3]: True

The most similar version of this in go uses golang-set and looks like this:

package main

import (
    "fmt"

    "github.com/deckarep/golang-set"
)

func sliceToSet(mySlice []string) mapset.Set {
    mySet := mapset.NewSet()
    for _, ele := range mySlice {
        mySet.Add(ele)
    }   
    return mySet
}

func main() {

    l1 := []string{"a", "b", "c"}
    l2 := []string{"a", "c"}

    s1 := sliceToSet(l1)
    s2 := sliceToSet(l2)

    result := s2.IsSubset(s1)

    fmt.Println(result)
}

The time complexity of above approach is linear time. The time complexity of issubset itself is O(n), where n is length of a set we are checking if subset, in this case s2 . There is also conversion from slice to set that is also linear time.