Supprimer et ajouter des éléments à un tableau en ALLER lang

J'ai 2 tableaux déclarés comme :
var input []string et var output []string .

Le tableau d'entrée est remplie avec des Id d'abord. Le tableau de sortie est NULLE.

Après chaque itération, je veux supprimer un élément aléatoire à partir d'une entrée de tableau et l'ajouter sur le tableau de sortie.

À la fin de tous les éléments dans le tableau de sortie sera le même que l'entrée de tableau (mais avec un autre ordre(indexation)).

for index := 0; index < len(input); index++ {
    if !visited[index] {
        //do something
    }
}
output[#iteration index] = input[current index]

Quand j'essaie de faire ceci, j'obtiens array out of bounds error.

OriginalL'auteur fnaticRC ggwp | 2015-11-20

append arrays go slice

17

Pour la output tableau, vous devez utiliser append ou allouer avec une capacité initiale en fonction de la taille de input.
```
//before the loop
output := make([]string, len(input))
```
serait ma recommandation, car append provoque un tas de inutile réaffectations et vous savez déjà ce que la capacité dont vous avez besoin, car il est basé sur la input.

L'autre chose, ce serait:
```
output = append(output, input[index])
```
Mais comme je l'ai dit, de ce que j'ai observé ajouter pousse la capacité initiale de façon exponentielle. Ce sera la base de 2 si vous n'avez pas spécifié ce qui signifie que vous allez faire plusieurs inutiles réaffectations avant d'atteindre la capacité souhaitée.

Merci beaucoup les gars ! Qui fonctionnait parfaitement bien 🙂
Est-il possible d'ajouter une tranche sans réaffectation?

OriginalL'auteur evanmcdonnal
2

Vous pourriez trouver quelques astuces utiles à golang/SliceTricks.

Depuis l'introduction de la append construit, la plupart des fonctionnalités de la container/vector paquet, qui a été supprimée en 1, peut être répliqué à l'aide de append et copy.

Voici le vecteur des méthodes et de leur tranche de manipulation analogues:

AppendVector
```
a = append(a, b...)
```
Copie
```
b = make([]T, len(a))
copy(b, a)
//or
b = append([]T(nil), a...)
```
Couper
```
a = append(a[:i], a[j:]...)
```
Supprimer
```
a = append(a[:i], a[i+1:]...)
//or
a = a[:i+copy(a[i:], a[i+1:])]
```
Supprimer sans le maintien de l'ordre
```
a[i] = a[len(a)-1] 
a = a[:len(a)-1]
```
NOTE Si le type de l'élément est un pointeur ou une structure (struct) avec le pointeur de champs, qui doivent être des ordures, le ci-dessus implémentations de Cut et Delete ont un potentiel fuite de mémoire problème: certains éléments avec des valeurs sont encore référencés par tranche a et donc ne peuvent pas être collectées. Le code suivant peut résoudre ce problème:

Couper
```
copy(a[i:], a[j:])
for k, n := len(a)-j+i, len(a); k < n; k++ {
    a[k] = nil //or the zero value of T
}
a = a[:len(a)-j+i]
```
Supprimer
```
copy(a[i:], a[i+1:])
a[len(a)-1] = nil //or the zero value of T
a = a[:len(a)-1]
```
Supprimer sans le maintien de l'ordre
```
a[i] = a[len(a)-1]
a[len(a)-1] = nil
a = a[:len(a)-1]
```
Développez
```
a = append(a[:i], append(make([]T, j), a[i:]...)...)
```
Étendre
```
a = append(a, make([]T, j)...)
```
Insérer
```
a = append(a[:i], append([]T{x}, a[i:]...)...)
```
NOTE La deuxième append crée une nouvelle tranche avec ses propres sous-jacente de stockage et de copies d'éléments dans a[i:] de cette tranche, et ces éléments sont alors copiés sur la tranche a (par la première append). La création de la nouvelle tranche (et donc la mémoire garbage) et la deuxième copie peut être évité en utilisant un autre moyen:

Insérer
```
s = append(s, 0)
copy(s[i+1:], s[i:])
s[i] = x
```
InsertVector
```
a = append(a[:i], append(b, a[i:]...)...)
```
Pop
```
x, a = a[0], a[1:]
```
De La Pop De Retour
```
x, a = a[len(a)-1], a[:len(a)-1]
```
Pousser
```
a = append(a, x)
```
Pousser
```
a = append([]T{ x }, a...)
```
Maj
```
x, a := a[0], a[1:]
```
Unshift
```
a = append([]T{x}, a...)
```
Vous Trouverez D'Autres Astuces

De filtrage sans allocation

Cette astuce utilise le fait qu'une tranche partage le même support de tableau et de la capacité que l'original, de sorte que le stockage est réutilisée pour l'filtré tranche. Bien sûr, le contenu original est modifié.
```
b := a[:0]
for _, x := range a {
    if f(x) {
        b = append(b, x)
    }
}
```
Inverser

Pour remplacer le contenu d'une tranche avec les mêmes éléments mais dans l'ordre inverse:
```
for i := len(a)/2-1; i >= 0; i-- {
    opp := len(a)-1-i
    a[i], a[opp] = a[opp], a[i]
}
```
La même chose, sauf avec deux indices:
```
for left, right := 0, len(a)-1; left < right; left, right = left+1, right-1 {
    a[left], a[right] = a[right], a[left]
}
```
Brassage

De Fisher–Yates algorithme:
```
for i := len(a) - 1; i > 0; i-- {
    j := rand.Intn(i + 1)
    a[i], a[j] = a[j], a[i]
}
```
OriginalL'auteur TonnyL

Vous devez vous connecter pour publier un commentaire.

Vous Trouverez D'Autres Astuces

De filtrage sans allocation

Inverser

Brassage