shuffle tableau en Aller

J'ai essayé de traduire le code Python suivant pour Aller

import random

list = [i for i in range(1, 25)]
random.shuffle(list)
print(list)

mais trouvé mon Go version longue et difficile car il n'existe pas de fonction de lecture aléatoire et j'ai dû mettre en place des interfaces et de convertir des types.

Ce qui serait une idiomatiques Go version de mon code?

Cette question a un shuffle() mise en œuvre: Traitement de Tableaux en Aller.

InformationsquelleAutor deamon | 2012-09-04

arrays go

90

Que votre liste est juste les entiers de 1 à 25, vous pouvez utiliser Perm :
```
list := rand.Perm(25)
for i, _ := range list {
    list[i]++
}
```
Noter que l'utilisation d'une permutation donnée par rand.Perm est un moyen efficace de mélanger n'importe quel tableau.
```
dest := make([]int, len(src))
perm := rand.Perm(len(src))
for i, v := range perm {
    dest[v] = src[i]
}
```
- Je ne suis pas sûr si la Perm méthode a changé depuis cette réponse, mais il renvoie "une pseudo-aléatoire permutation des entiers de [0,n)". Dans ce scénario, le résultat serait une permutation de 0 à 24.
- c'est pourquoi les chiffres sont incrémentés (une autre solution aurait été de simplement changer de 0 à 25).
InformationsquelleAutor Denys Séguret
99

dystroy réponse est parfaitement raisonnable, mais il est également possible de mélanger sans allocation supplémentaire tranches.
```
for i := range slice {
    j := rand.Intn(i + 1)
    slice[i], slice[j] = slice[j], slice[i]
}
```
Voir cet article de Wikipédia pour plus de détails sur l'algorithme. rand.Perm utilise cet algorithme à l'interne ainsi.
- Je le prends c'est le "inside-out" de la version dans l'article, et vous éluder la i!=j vérifier?
- En regardant la page de Wikipedia, ce qui semble être le "moderne" algorithme (première variante). Le "inside-out" version semble stocker le résultat dans un nouveau tableau, plutôt que de faire le shuffle en place.
InformationsquelleAutor Evan Shaw
33

Depuis 1.10 Go est équipé d'un fonctionnaire Shuffle de Fisher-Yates fonction.

Documentation: pkg/math/rand/#Shuffle

math/rand: ajouter Shuffle

Shuffle utilise le Fisher-Yates algorithme.

Puisque c'est de cette nouvelle API, il nous offre la possibilité
pour utiliser un beaucoup plus rapide Int31n mise en œuvre que pour la plupart évite la division.

Comme un résultat, BenchmarkPerm30ViaShuffle est
environ 30% plus rapide que BenchmarkPerm30,
malgré nécessitant une distinct de l'initialisation de la boucle
et en utilisant des appels de fonction pour permuter les éléments.

Voir aussi à l'origine CL 51891

Exemple:
```
words := strings.Fields("ink runs from the corners of my mouth")
rand.Shuffle(len(words), func(i, j int) {
    words[i], words[j] = words[j], words[i]
})
fmt.Println(words)
```
- Je vous remercie. J'ai inclus ce lien dans la réponse.
InformationsquelleAutor VonC
7

Réponse par Evan Shaw a un bug mineur. Si nous parcourir la tranche d'index la plus faible à la plus élevée, afin d'obtenir un uniforme (pseudo) aléatoire shuffle, selon le même l'article, nous devons choisir un entier aléatoire dans l'intervalle [i,n) par opposition à [0,n+1).

Que la mise en œuvre permettra de faire ce que vous avez besoin pour les grandes entrées, mais pour les plus petites tranches, il va effectuer une non-uniforme shuffle.

À utiliser rand.Intn(), nous pouvons faire:
```
    for i := len(slice) - 1; i > 0; i-- {
        j := rand.Intn(i + 1)
        slice[i], slice[j] = slice[j], slice[i]
    }
```
suivant le même algorithme à partir de l'article de Wikipedia.

InformationsquelleAutor

Peut-être que vous pouvez également utiliser la fonction suivante:

func main() {
   slice := []int{10, 12, 14, 16, 18, 20}
   Shuffle(slice)
   fmt.Println(slice)
}

func Shuffle(slice []int) {
   r := rand.New(rand.NewSource(time.Now().Unix()))
   for n := len(slice); n > 0; n-- {
      randIndex := r.Intn(n)
      slice[n-1], slice[randIndex] = slice[randIndex], slice[n-1]
   }
}

InformationsquelleAutor hkucuk

Lors de l'utilisation de la math/rand paquet, ne pas oublier de mettre une source

//Random numbers are generated by a Source. Top-level functions, such as
//Float64 and Int, use a default shared Source that produces a deterministic
//sequence of values each time a program is run. Use the Seed function to
//initialize the default Source if different behavior is required for each run.

J'ai donc écrit un Shuffle fonction qui prend cela en considération:

import (
    "math/rand"
)

func Shuffle(array []interface{}, source rand.Source) {
    random := rand.New(source)
    for i := len(array) - 1; i > 0; i-- {
        j := random.Intn(i + 1)
        array[i], array[j] = array[j], array[i]
    }
}

Et de l'utiliser:

source := rand.NewSource(time.Now().UnixNano())
array := []interface{}{"a", "b", "c"}

Shuffle(array, source) //[c b a]

Si vous souhaitez l'utiliser, vous pouvez le trouver ici https://github.com/shomali11/util

InformationsquelleAutor Raed Shomali

Raed l'approche de est très rigide en raison de []interface{} comme entrée. Ici, c'est plus pratique version pour aller>=1.8:

func Shuffle(slice interface{}) {
    rv := reflect.ValueOf(slice)
    swap := reflect.Swapper(slice)
    length := rv.Len()
    for i := length - 1; i > 0; i-- {
            j := rand.Intn(i + 1)
            swap(i, j)
    }
}

Exemple d'utilisation:

    rand.Seed(time.Now().UnixNano()) //do it once during app initialization
    s := []int{1, 2, 3, 4, 5}
    Shuffle(s)
    fmt.Println(s) //Example output: [4 3 2 1 5]

Et aussi, n'oubliez pas que un peu de la copie est de mieux qu'une petite dépendance

InformationsquelleAutor Joseph Buchma

Utilisation Shuffle() de la math/rand bibliothèque.

Voici un exemple:

package main

import (
    "fmt"
    "math/rand"
    "strings"
)

func main() {
    words := strings.Fields("ink runs from the corners of my mouth")
    rand.Shuffle(len(words), func(i, j int) {
        words[i], words[j] = words[j], words[i]
    })
    fmt.Println(words)
}

Puisqu'il vient de la math/rand bibliothèque, il doit être ensemencées. Voir ici pour plus de détails.

InformationsquelleAutor stwykd

Vous devez vous connecter pour publier un commentaire.

math/rand: ajouter Shuffle