Как получить пересечение двух среза в golang?

есть ли эффективный способ получить пересечение двух срезов в Go?

Я хочу избежать вложенного for loop как решения 
slice1 := []string{"foo", "bar","hello"}
slice2 := []string{"foo", "bar"}

intersection(slice1, slice2)
=> ["foo", "bar"]
порядок строк не имеет значения
6
go

4 ответов

Да, есть несколько разных способов сделать это.. Вот пример, который можно оптимизировать.

package main

import "fmt"

func intersection(a []string, b []string) (inter []string) {
    // interacting on the smallest list first can potentailly be faster...but not by much, worse case is the same
    low, high := a, b
    if len(a) > len(b) {
        low = b
        high = a
    }

    done := false
    for i, l := range low {
        for j, h := range high {
            // get future index values
            f1 := i + 1
            f2 := j + 1
            if l == h {
                inter = append(inter, h)
                if f1 < len(low) && f2 < len(high) {
                    // if the future values aren't the same then that's the end of the intersection
                    if low[f1] != high[f2] {
                        done = true
                    }
                }
                // we don't want to interate on the entire list everytime, so remove the parts we already looped on will make it faster each pass
                high = high[:j+copy(high[j:], high[j+1:])]
                break
            }
        }
        // nothing in the future so we are done
        if done {
            break
        }
    }
    return
}

func main() {
    slice1 := []string{"foo", "bar", "hello", "bar"}
    slice2 := []string{"foo", "bar"}
    fmt.Printf("%+v\n", intersection(slice1, slice2))
}

теперь метод пересечения, определенный выше, будет работать только на slices of strings, как и ваш пример.. Теоретически вы можете создать определение, которое выглядит следующим образом func intersection(a []interface, b []interface) (inter []interface), однако вы будете полагаться на отражение и литье типа, чтобы вы могли сравнить, что добавит задержку и затруднит чтение вашего кода. Вероятно, легче поддерживать и читать, чтобы писать отдельная функция для каждого типа, о котором вы заботитесь.

func intersectionString(a []string, b []string) (inter []string),

func intersectionInt(a []int, b []int) (inter []int),

func intersectionFloat64(a []Float64, b []Float64) (inter []Float64), ..ect

затем вы можете создать свой собственный пакет и повторно использовать, как только вы решите, как вы хотите это реализовать.

package intersection

func String(a []string, b []string) (inter []string)

func Int(a []int, b []int) (inter []int)

func Float64(a []Float64, b []Float64) (inter []Float64)
1

как получить пересечение между двумя массивами в качестве нового массива?

  • простое пересечение: сравните каждый элемент в A каждому в B (O(n^2))
  • хэш-пересечение: поместите их в хэш-таблицу (O(n))
  • Сортированное Пересечение: Сортировка A и сделайте оптимизированное пересечение (O(n*log(n)))

все из которых реализуются вот!--9-->

https://github.com/juliangruber/go-intersect

12

Если в вашем []string, может быть, вам нужен этот простой код:

func filter(src []string) (res []string) {
    for _, s := range src {
        newStr := strings.Join(res, " ")
        if !strings.Contains(newStr, s) {
            res = append(res, s)
        }
    }
    return
}

func intersections(section1, section2 []string) (intersection []string) {
    str1 := strings.Join(filter(section1), " ")
    for _, s := range filter(section2) {
        if strings.Contains(str1, s) {
            intersection = append(intersection, s)
        }
    }
    return
}
1

Это лучший метод для пересечения двух срезов. Сложность слишком низкая.

сложность времени: O (m+n)

m = длина первого среза.

N = длина второго среза.

func intersection(s1, s2 []string) (inter []string) {
    hash := make(map[string]bool)
    for _, e := range s1 {
        hash[e] = true
    }
    for _, e := range s2 {
        // If elements present in the hashmap then append intersection list.
        if hash[e] {
            inter = append(inter, e)
        }
    }
    //Remove dups from slice.
    inter = removeDups(inter)
    return
}

//Remove dups from slice.
func removeDups(elements []string)(nodups []string) {
    encountered := make(map[string]bool)
    for _, element := range elements {
        if !encountered[element] {
            nodups = append(nodups, element)
            encountered[element] = true
        }
    }
    return
}
0