Go : Ajouter si unique

Question

Existe-t-il un moyen de vérifier la présence d'une valeur dans les tranches/cartes ?

Je voudrais ajouter une valeur à une tranche uniquement si elle n'existe pas dans la tranche.

Cela fonctionne, mais cela semble verbeux. Y a-t-il une meilleure façon de faire cela?

 orgSlice := []int{1, 2, 3}
newSlice := []int{}
newInt := 2

newSlice = append(newSlice, newInt)
for _, v := range orgSlice {
    if v != newInt {
        newSlice = append(newSlice, v)
    }
}

newSlice == [2 1 3]

Answer 1

Votre approche prendrait un temps linéaire pour chaque insertion. Une meilleure façon serait d'utiliser un map[int]struct{} . Alternativement, vous pouvez également utiliser un map[int]bool ou quelque chose de similaire, mais le struct{} vide a l'avantage de ne pas occuper d'espace supplémentaire. Par conséquent, map[int]struct{} est un choix populaire pour un ensemble d'entiers.

Exemple:

 set := make(map[int]struct{})
set[1] = struct{}{}
set[2] = struct{}{}
set[1] = struct{}{}
// ...

for key := range(set) {
  fmt.Println(key)
}
// each value will be printed only once, in no particular order


// you can use the ,ok idiom to check for existing keys
if _, ok := set[1]; ok {
  fmt.Println("element found")
} else {
  fmt.Println("element not found")
}

Answer 2

Une autre option:

 package main
import "golang.org/x/tools/container/intsets"

func main() {
   var (
      a intsets.Sparse
      b bool
   )
   b = a.Insert(9)
   println(b) // true
   b = a.Insert(9)
   println(b) // false
}

https://pkg.go.dev/golang.org/x/tools/container/intsets

Answer 3

distinguer un tableau d'une structure :

 func distinctObjects(objs []ObjectType) (distinctedObjs [] ObjectType){
        var output []ObjectType
    for i:= range objs{
        if output==nil || len(output)==0{
            output=append(output,objs[i])
        } else {
            founded:=false
            for j:= range output{
                    if output[j].fieldname1==objs[i].fieldname1 && output[j].fieldname2==objs[i].fieldname2 &&......... {
                    founded=true
                }
            }
            if !founded{
                output=append(output,objs[i])
            }
        }
    }
    return output
}

où la structure ici est quelque chose comme :

 type ObjectType struct {
    fieldname1 string
    fieldname2 string
    .........
}

l'objet se distinguera par des champs cochés ici :

 if output[j].fieldname1==objs[i].fieldname1 && output[j].fieldname2==objs[i].fieldname2 &&......... {