Comment trouver la différence entre deux tranches de chaînes dans Golang?

Selon la taille des tranches, différentes solutions pourrait être la meilleure.

Ma réponse suppose ordre n'a pas d'importance.

À l'aide de simples boucles, uniquement pour être utilisé avec de petites tranches:

package main

import "fmt"

func difference(slice1 []string, slice2 []string) []string {
    var diff []string

    //Loop two times, first to find slice1 strings not in slice2,
    //second loop to find slice2 strings not in slice1
    for i := 0; i < 2; i++ {
        for _, s1 := range slice1 {
            found := false
            for _, s2 := range slice2 {
                if s1 == s2 {
                    found = true
                    break
                }
            }
            //String not found. We add it to return slice
            if !found {
                diff = append(diff, s1)
            }
        }
        //Swap the slices, only if it was the first loop
        if i == 0 {
            slice1, slice2 = slice2, slice1
        }
    }

    return diff
}

func main() {
    slice1 := []string{"foo", "bar", "hello"}
    slice2 := []string{"foo", "world", "bar", "foo"}

    fmt.Printf("%+v\n", difference(slice1, slice2))
}

De sortie:

[hello world]

Aire de jeux: http://play.golang.org/p/KHTmJcR4rg

OriginalL'auteur ANisus

- Je utiliser la carte pour résoudre ce problème

package main

import "fmt"

func main() {
    slice1 := []string{"foo", "bar","hello"}
    slice2 := []string{"foo", "bar","world"}

    diffStr := difference(slice1, slice2)

    for _, diffVal := range diffStr {
        fmt.Println(diffVal)
    }

}

func difference(slice1 []string, slice2 []string) ([]string){
    diffStr := []string{}
    m :=map [string]int{}

    for _, s1Val := range slice1 {
        m[s1Val] = 1
    }
    for _, s2Val := range slice2 {
        m[s2Val] = m[s2Val] + 1
    }

    for mKey, mVal := range m {
        if mVal==1 {
            diffStr = append(diffStr, mKey)
        }
    }

    return diffStr
}

de sortie:

bonjour

monde

OriginalL'auteur alexis

Comme mentionné par ANisus, des approches différentes selon les différentes tailles d'entrée tranches. Cette solution fonctionne dans le temps linéaire O(n) indépendant de la taille de l'image, mais suppose que "l'égalité" comprend la position d'index.

Ainsi, dans le cas des OP exemples de:

slice1 := []string{"foo", "bar","hello"}
slice2 := []string{"foo", "bar"}

Les entrées foo et bar sont égaux non seulement en raison de la valeur, mais aussi en raison de leur index dans la tranche.

Compte tenu de ces conditions, vous pouvez faire quelque chose comme:

package main

import "fmt"

func difference(s1, s2 []string) string {
    var (
        lenMin  int
        longest []string
        out     string
    )
    //Determine the shortest length and the longest slice
    if len(s1) < len(s2) {
        lenMin = len(s1)
        longest = s2
    } else {
        lenMin = len(s2)
        longest = s1
    }
    //compare common indeces
    for i := 0; i < lenMin; i++ {
        if s1[i] != s2[i] {
            out += fmt.Sprintf("=>\t%s\t%s\n", s1[i], s2[i])
        }
    }
    //add indeces not in common
    for _, v := range longest[lenMin:] {
        out += fmt.Sprintf("=>\t%s\n", v)
    }
    return out
}

func main() {
    slice1 := []string{"foo", "bar", "hello"}
    slice2 := []string{"foo", "bar"}
    fmt.Print(difference(slice1, slice2))
}

Produit:

=> bonjour

Aire de jeux

Si vous modifiez les tranches à:

func main() {
    slice1 := []string{"foo", "baz", "hello"}
    slice2 := []string{"foo", "bar"}    
    fmt.Print(difference(slice1, slice2))
}

Il va produire:

=> baz bar

=> bonjour

OriginalL'auteur Intermernet