多字符串数组求交集

func IntersectString(strSlices ...[]string) []string {
    if len(strSlices) == 0 {
        return nil
    }
 
    elemNum := len(strSlices)
    if elemNum == 1 {
        return UniqString(strSlices[0])
    }
 
    minIndex := func() int {
        min, minLength := 0, len(strSlices[0])
 
        for i, strs := range strSlices[1:] {
            if len(strs) < minLength {
                min, minLength = i+1, len(strs)
            }
        }
 
        return min
    }()
 
    strSlices[0], strSlices[minIndex] = strSlices[minIndex], strSlices[0]
 
    if len(strSlices[0]) == 0 {
        return nil
    }
 
    set := make(map[string]int, len(strSlices[0]))
    for _, str := range strSlices[0] {
        set[str] = 1
    }
 
    for i, str := range strSlices[1:] {
        for _, s := range str {
            if v, ok := set[s]; ok && v == i+1 {
                set[s]++
            }
        }
    }
 
    ret := make([]string, 0, len(set))
    for key, value := range set {
        if value == elemNum {
            ret = append(ret, key)
        }
    }
 
    return ret
}
 
 
// UniqString 字符串数组去重
func UniqString(strs []string) []string {
   length := len(strs)
 
   seen := make(map[string]struct{}, length)
   var j int
 
   for i := 0; i < length; i++ {
      v := strs[i]
 
      if _, ok := seen[v]; ok {
         continue
      }
 
      seen[v] = struct{}{}
      strs[j] = v
      j++
   }
 
   return strs[:j]
}