Wie man den Zufallszahlengenerator richtig aussät

Ich versuche, eine zufällige Zeichenfolge in Go zu generieren, und hier ist der Code, den ich bisher geschrieben habe:

package main

import (
    "bytes"
    "fmt"
    "math/rand"
    "time"
)

func main() {
    fmt.Println(randomString(10))
}

func randomString(l int) string {
    var result bytes.Buffer
    var temp string
    for i := 0; i < l; {
        if string(randInt(65, 90)) != temp {
            temp = string(randInt(65, 90))
            result.WriteString(temp)
            i++
        }
    }
    return result.String()
}

func randInt(min int, max int) int {
    rand.Seed(time.Now().UTC().UnixNano())
    return min + rand.Intn(max-min)
}

Meine Implementierung ist sehr langsam. Seeding using timebringt für eine bestimmte Zeit dieselbe Zufallszahl, sodass die Schleife immer wieder wiederholt wird. Wie kann ich meinen Code verbessern?

Jedes Mal, wenn Sie denselben Startwert festlegen, erhalten Sie dieselbe Sequenz. Wenn Sie also den Startwert in einer schnellen Schleife auf die Zeit einstellen, werden Sie ihn wahrscheinlich viele Male mit demselben Startwert aufrufen.

In Ihrem Fall randIntwarten Sie beim Aufrufen Ihrer Funktion, bis Sie einen anderen Wert haben, darauf, dass sich die Zeit (wie von Nano zurückgegeben) ändert.

Wie bei allen Pseudozufallsbibliotheken müssen Sie den Startwert nur einmal festlegen, z. B. beim Initialisieren Ihres Programms, es sei denn, Sie müssen eine bestimmte Sequenz speziell reproduzieren (dies wird normalerweise nur zum Debuggen und Testen von Einheiten durchgeführt).

Danach rufen Sie einfach Intnauf, um die nächste zufällige Ganzzahl zu erhalten.

Bewegen Sie die rand.Seed(time.Now().UTC().UnixNano())Zeile von der Funktion randInt zum Anfang der Hauptfunktion, und alles wird schneller.

Beachten Sie auch, dass Sie meiner Meinung nach das Erstellen von Zeichenfolgen vereinfachen können:

package main

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

func main() {
    rand.Seed(time.Now().UTC().UnixNano())
    fmt.Println(randomString(10))
}

func randomString(l int) string {
    bytes := make([]byte, l)
    for i := 0; i < l; i++ {
        bytes[i] = byte(randInt(65, 90))
    }
    return string(bytes)
}

func randInt(min int, max int) int {
    return min + rand.Intn(max-min)
}

Ich verstehe nicht, warum Leute mit einem Zeitwert säen. Dies war meiner Erfahrung nach nie eine gute Idee. Während beispielsweise die Systemuhr möglicherweise in Nanosekunden dargestellt wird, beträgt die Taktgenauigkeit des Systems keine Nanosekunden.

Dieses Programm sollte nicht auf dem Go-Spielplatz ausgeführt werden. Wenn Sie es jedoch auf Ihrem Computer ausführen, erhalten Sie eine grobe Schätzung der zu erwartenden Genauigkeit. Ich sehe Inkremente von ungefähr 1000000 ns, also Inkremente von 1 ms. Das sind 20 Bit Entropie, die nicht verwendet werden. Währenddessen sind die hohen Bits meist konstant.

Der Grad, in dem dies für Sie von Bedeutung ist, variiert, aber Sie können Fallstricke von uhrbasierten Startwerten vermeiden, indem Sie einfach die crypto/rand.Readals Quelle für Ihren Startwert verwenden . Sie erhalten die nicht deterministische Qualität, nach der Sie wahrscheinlich in Ihren Zufallszahlen suchen (selbst wenn die tatsächliche Implementierung selbst auf eine Reihe unterschiedlicher und deterministischer Zufallssequenzen beschränkt ist).

import (
    crypto_rand "crypto/rand"
    "encoding/binary"
    math_rand "math/rand"
)

func init() {
    var b [8]byte
    _, err := crypto_rand.Read(b[:])
    if err != nil {
        panic("cannot seed math/rand package with cryptographically secure random number generator")
    }
    math_rand.Seed(int64(binary.LittleEndian.Uint64(b[:])))
}

Als Randnotiz aber in Bezug auf Ihre Frage. rand.SourceMit dieser Methode können Sie eigene erstellen , um die Kosten für Sperren zum Schutz der Quelle zu vermeiden. Die randFunktionen des Paketdienstprogramms sind praktisch, verwenden jedoch auch Schlösser unter der Haube, um zu verhindern, dass die Quelle gleichzeitig verwendet wird. Wenn Sie das nicht benötigen, können Sie es vermeiden, indem Sie Ihre eigenen erstellen Sourceund diese nicht gleichzeitig verwenden. Unabhängig davon sollten Sie Ihren Zufallszahlengenerator zwischen den Iterationen NICHT neu säen, er wurde nie für diese Verwendung entwickelt.

Nur um es für die Nachwelt wegzuwerfen: Manchmal kann es vorzuziehen sein, eine zufällige Zeichenfolge mit einer anfänglichen Zeichensatzzeichenfolge zu generieren. Dies ist nützlich, wenn die Zeichenfolge von einem Menschen manuell eingegeben werden soll. Das Ausschließen von 0, O, 1 und l kann dazu beitragen, Benutzerfehler zu reduzieren.

var alpha = "abcdefghijkmnpqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ23456789"

// generates a random string of fixed size
func srand(size int) string {
    buf := make([]byte, size)
    for i := 0; i < size; i++ {
        buf[i] = alpha[rand.Intn(len(alpha))]
    }
    return string(buf)
}

und ich setze normalerweise den Samen innerhalb eines init()Blocks. Sie sind hier dokumentiert: http://golang.org/doc/effective_go.html#init

OK warum so komplex!

package main

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

func main() {
    rand.Seed( time.Now().UnixNano())
    var bytes int

    for i:= 0 ; i < 10 ; i++{ 
        bytes = rand.Intn(6)+1
        fmt.Println(bytes)
        }
    //fmt.Println(time.Now().UnixNano())
}

Dies basiert auf dem Code des Dystroy, ist aber für meine Bedürfnisse geeignet.

Es ist die sechs (Rand Ints 1 =< i =< 6)

func randomInt (min int , max int  ) int {
    var bytes int
    bytes = min + rand.Intn(max)
    return int(bytes)
}

Die obige Funktion ist genau das gleiche.

Ich hoffe, diese Informationen waren von Nutzen.

Es sind Nanosekunden, wie hoch sind die Chancen, zweimal denselben Samen zu bekommen?
Wie auch immer, danke für die Hilfe, hier ist meine Endlösung, die auf allen Eingaben basiert.

package main

import (
    "math/rand"
    "time"
)

func init() {
    rand.Seed(time.Now().UTC().UnixNano())
}

// generates a random string
func srand(min, max int, readable bool) string {

    var length int
    var char string

    if min < max {
        length = min + rand.Intn(max-min)
    } else {
        length = min
    }

    if readable == false {
        char = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"
    } else {
        char = "ABCDEFHJLMNQRTUVWXYZabcefghijkmnopqrtuvwxyz23479"
    }

    buf := make([]byte, length)
    for i := 0; i < length; i++ {
        buf[i] = char[rand.Intn(len(char)-1)]
    }
    return string(buf)
}

// For testing only
func main() {
    println(srand(5, 5, true))
    println(srand(5, 5, true))
    println(srand(5, 5, true))
    println(srand(5, 5, false))
    println(srand(5, 7, true))
    println(srand(5, 10, false))
    println(srand(5, 50, true))
    println(srand(5, 10, false))
    println(srand(5, 50, true))
    println(srand(5, 10, false))
    println(srand(5, 50, true))
    println(srand(5, 10, false))
    println(srand(5, 50, true))
    println(srand(5, 4, true))
    println(srand(5, 400, true))
    println(srand(6, 5, true))
    println(srand(6, 5, true))
    println(srand(6, 5, true))
    println(srand(6, 5, true))
    println(srand(6, 5, true))
    println(srand(6, 5, true))
    println(srand(6, 5, true))
    println(srand(6, 5, true))
    println(srand(6, 5, true))
    println(srand(6, 5, true))
    println(srand(6, 5, true))
    println(srand(6, 5, true))
}

Wenn Sie nur einen Stich einer Zufallszahl erzeugen möchten, ist es meines Erachtens nicht erforderlich, ihn jedes Mal durch mehrere Funktionsaufrufe oder das Zurücksetzen des Startwerts zu komplizieren.

Der wichtigste Schritt besteht darin, die Seed-Funktion nur einmal aufzurufen, bevor sie tatsächlich ausgeführt wird rand.Init(x). Seed verwendet den angegebenen Seed-Wert, um die Standardquelle in einen deterministischen Zustand zu initialisieren. Es wird daher empfohlen, es einmal vor dem eigentlichen Funktionsaufruf des Pseudozufallszahlengenerators aufzurufen.

Hier ist ein Beispielcode, der eine Folge von Zufallszahlen erstellt

package main 
import (
    "fmt"
    "math/rand"
    "time"
)



func main(){
    rand.Seed(time.Now().UnixNano())

    var s string
    for i:=0;i<10;i++{
    s+=fmt.Sprintf("%d ",rand.Intn(7))
    }
    fmt.Printf(s)
}

Der Grund, warum ich Sprintf verwendet habe, ist, dass es eine einfache Formatierung von Zeichenfolgen ermöglicht.

Außerdem gibt In rand.Intn(7) Intn als int eine nicht negative Pseudozufallszahl in [0,7] zurück.

@ [Denys Séguret] hat richtig gepostet. Aber in meinem Fall brauche ich jedes Mal neuen Samen, daher unter dem Code;

Für den Fall, dass Sie schnelle Funktionen benötigen. Ich benutze so.

func RandInt(min, max int) int {
    r := rand.New(rand.NewSource(time.Now().UnixNano()))
    return r.Intn(max-min) + min
}

func RandFloat(min, max float64) float64 {
    r := rand.New(rand.NewSource(time.Now().UnixNano()))
    return min + r.Float64()*(max-min)
}

Quelle

Kleines Update aufgrund einer Änderung der Golang-API, bitte .UTC () weglassen:

time.Now (). UTC () .UnixNano () -> time.Now (). UnixNano ()

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

func main() {
    rand.Seed(time.Now().UnixNano())
    fmt.Println(randomInt(100, 1000))
}

func randInt(min int, max int) int {
    return min + rand.Intn(max-min)
}