Aller: Ajouter si unique

Est-il un moyen de vérifier en tranches/cartes pour la présence d'une valeur?

Je voudrais ajouter une valeur à une tranche seulement si elle ne pas existent dans le secteur.

Cela fonctionne, mais il semble clair. Est-il un beter façon de le faire?

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]

Re:MODIFIER - c'est la même histoire pour être valable, toute carte de clé de type chaîne qui est.
Re:EDIT2 - si l'ordre des valeurs dans 'newSlice' n'a pas d'importance ET il sera utilisé/consommé à l'aide d'une gamme énoncé de sa construction est redondant - il suffit de gamme, les clés de la "set".
Merci pour vos commentaires. Je suis stocker la liste des ints en FGA de la banque de données et pour la fin de l'interrogation, il doit être une tranche ( []int ). N'cette exigence rend ma technique initiale le meilleur choix? Les listes seront petites.
Vous pouvez éviter l'utilisation de append() (et tous les réaffectations) par la création de la création d'un newslice := make([]int, len(set)) en premier lieu. Si vous faites beaucoup de ces "contient la clé ..." tests (au moins 2), la conversion de la tranche d'une carte[int]struct{} sera probablement beaucoup plus rapide, si vous faites juste un peu, une boucle dans la tranche directement est probablement mieux.
Ok, merci, j'apprécie vraiment que vous preniez le temps de vous expliquer tout cela.

InformationsquelleAutor Kyle Finley | 2012-02-12

append go slice

74

Votre approche permettrait de prendre le temps linéaire pour chaque insertion. Une meilleure approche serait d'utiliser un map[int]struct{}. Sinon, vous pouvez également utiliser un map[int]bool ou quelque chose de similaire, mais le vide struct{} a l'avantage de ne pas occuper tout l'espace supplémentaire. Donc 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")
}
```
- Je vous remercie pour votre réponse. Quelques questions: Comment voulez-vous alors de recréer la tranche? Est-il un moyen de rendre cette stratégie avec des chaînes? Désolé si elles sont évidentes - je suis de nouveau Aller.
- Je voudrais utiliser seulement la carte lors du calcul (parce que c'est un O(1) comportement au lieu de O(n)). Après cela, vous pouvez créer une tranche et la copie de chaque valeur de la carte. Les éléments ont un ordre aléatoire après cela, de sorte que vous pouvez les trier. Et vous pouvez utiliser des int, float, struct, chaîne de caractères, et des tableaux d'une map (au moins dans Go1).
- Merci spécifiquement pour l'exposant qui vide les structures ne prennent pas d'espace supplémentaire. Je ne savais pas, et l'utilisation de la carte[type]interface{} et à attribuer, nulle à l'interface.
- J'ai été en utilisant la carte[type]interface{} méthode, n'est-ce pas aussi de ne pas prendre plus d'espace?
InformationsquelleAutor tux21b
32

Plus efficace est susceptible d'être une itération sur la tranche et en ajoutant si vous ne le trouvez pas.
```
func AppendIfMissing(slice []int, i int) []int {
    for _, ele := range slice {
        if ele == i {
            return slice
        }
    }
    return append(slice, i)
}
```
C'est simple et évident et rapide pour les petites listes.

En outre, il sera toujours plus vite que votre carte actuelle à base de solution. La carte à base de solution effectue une itération sur l'ensemble de la tranche n'importe quoi; cette solution revient immédiatement lorsqu'il constate que la nouvelle valeur est déjà présente. Les deux solutions comparer les éléments comme ils itérer. (Chaque carte de l'instruction d'affectation n'est certainement au moins une carte de la comparaison clé en interne.) Une carte ne serait utile que si vous pouvait le conserver dans de nombreuses insertions. Si vous le reconstruire sur chaque insertion, puis tous les avantage est perdu.

Si vous avez réellement besoin pour gérer efficacement les grandes listes, envisager de maintenir les listes dans l'ordre de tri. (Je soupçonne que la commande n'est pas question pour vous, parce que votre première solution ajoutés au début de la liste et de votre dernière solution, ajoute à la fin.) Si vous avez toujours garder les listes triées puis vous vous pouvez utiliser le tri.Fonction de recherche pour faire binaire efficace insertions.
- "La carte à base de solution effectue une itération sur l'ensemble de la tranche n'importe quoi" - êtes-vous sûr que c'est la table de hachage à sens-cartes de travail?
- est-il mauvais? Beaucoup de gens upvoted mais pas de réponse de la gauche.
- En fait, je pense que j'ai peut-être mal compris le sens de cette déclaration. Hachage-cartes, évidemment, de ne pas effectuer une itération sur les éléments de trouver la clé, mais la "carte basée sur la solution" à "ajouter à la tranche si unique" perd c'est avantage si nous avons pour convertir la tranche de la carte et la carte en arrière de la tranche.
InformationsquelleAutor Sonia

distincting un tableau de struct :

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 struct ici est quelque chose comme :

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

l'objet distinctes par les champs cochés ici :

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

InformationsquelleAutor Bit

package main
import (
"fmt"
"os"
"reflect"
)
func main() {
/*  s := []string{"a", "b"}
fmt.Println(s)
s = AppendIfMissing(s, "4").([]string)
fmt.Println(s)*/
/*  var a []*string
a = make([]*string, 0)
e := "4"
a = AppendIfMissing(a, &e).([]*string)
fmt.Println(*a[0])*/
var a []*float64
a = make([]*float64, 3)
e := 4.4
d := 4.41
a = AppendIfMissing(a, &e).([]*float64)
a = AppendIfMissing(a, &d).([]*float64)
fmt.Println(*a[3], *a[4])
}
func AppendIfMissing(array interface{}, element interface{}) interface{} {
if reflect.ValueOf(array).IsNil() {
fmt.Fprintf(os.Stderr, "array not initialized\n")
return nil
}
switch reflect.TypeOf(array).Kind() {
case reflect.Slice:
arrayV := reflect.ValueOf(array)
arrayVLen := arrayV.Len()
if arrayVLen == 0 {//if make len == 0
sliceNew := reflect.MakeSlice(reflect.ValueOf(array).Type(), 1, 1)
if sliceNew.Index(0).Type() != reflect.ValueOf(element).Type() {
fmt.Fprintf(os.Stderr, "types are not same\n")
return sliceNew.Interface()
}
sliceNew.Index(0).Set(reflect.ValueOf(element))
return sliceNew.Interface()
}
for i := 0; i < arrayVLen; i++ {
if i == 0 && reflect.ValueOf(element).Kind() != arrayV.Index(i).Kind() {
fmt.Fprintf(os.Stderr, "types are not same\n")
return array
}
if arrayV.Index(i).Interface() == element {
return array
}
}
default:
fmt.Fprintf(os.Stderr, "first element is not array\n")
return array
}
arrayV := reflect.ValueOf(array)
elementV := reflect.ValueOf(element)
appendAE := reflect.Append(arrayV, elementV)
return appendAE.Interface()
}

InformationsquelleAutor book777

Vous devez vous connecter pour publier un commentaire.