Como propagar corretamente o gerador de números aleatórios

Estou tentando gerar uma seqüência aleatória no Go e aqui está o código que escrevi até agora:

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)
}

Minha implementação é muito lenta. A propagação usando timetraz o mesmo número aleatório por um certo tempo, portanto o loop itera repetidamente. Como posso melhorar meu código?

Cada vez que você define a mesma semente, obtém a mesma sequência. Então, é claro, se você estiver definindo a semente no tempo em um ciclo rápido, provavelmente a chamará com a mesma semente muitas vezes.

No seu caso, como você está chamando seu randInt função até ter um valor diferente, você está aguardando a hora (conforme retornada pelo Nano) mudar.

Quanto a todas as bibliotecas pseudo-aleatórias , você deve definir a semente apenas uma vez, por exemplo, ao inicializar seu programa, a menos que precise especificamente reproduzir uma determinada sequência (o que geralmente é feito apenas para depuração e teste de unidade).

Depois disso, basta ligar Intnpara obter o próximo número inteiro aleatório.

Mova a rand.Seed(time.Now().UTC().UnixNano())linha da função randInt para o início da principal e tudo será mais rápido.

Observe também que acho que você pode simplificar sua construção de strings:

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)
}

Não entendo por que as pessoas estão semeando com um valor de tempo. Na minha experiência, isso nunca foi uma boa ideia. Por exemplo, embora o relógio do sistema seja talvez representado em nanossegundos, a precisão do relógio do sistema não é de nanossegundos.

Este programa não deve ser executado no playground Go, mas se você o executar na máquina, obterá uma estimativa aproximada do tipo de precisão que você pode esperar. Eu vejo incrementos de cerca de 1000000 ns, então incrementos de 1 ms. São 20 bits de entropia que não são usados. Enquanto isso, os bits altos são na maioria constantes.

O grau em que isso é importante para você varia, mas você pode evitar as armadilhas dos valores das sementes baseadas no relógio simplesmente usando a crypto/rand.Readfonte como para sua semente. Isso fornecerá a qualidade não determinística que você provavelmente está procurando em seus números aleatórios (mesmo que a própria implementação seja limitada a um conjunto de seqüências aleatórias distintas e determinísticas).

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[:])))
}

Como uma nota lateral, mas em relação à sua pergunta. Você pode criar o seu próprio rand.Sourceusando esse método para evitar o custo de ter bloqueios protegendo a origem. orand funções do utilitário de pacotes são convenientes, mas também usam travas sob o capô para impedir que a fonte seja usada simultaneamente. Se você não precisar, pode evitá-lo criando o seu Sourcee usá-lo de maneira não simultânea. Independentemente disso, você NÃO deve realizar uma nova propagação do gerador de números aleatórios entre as iterações, nunca foi projetado para ser usado dessa maneira.

apenas para descartá-lo para a posteridade: às vezes pode ser preferível gerar uma sequência aleatória usando uma sequência inicial de caracteres. Isso é útil se a string for inserida manualmente por um ser humano; excluindo 0, O, 1 e eu podemos ajudar a reduzir o erro do usuário.

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)
}

e normalmente coloco a semente dentro de um init()bloco. Eles estão documentados aqui: http://golang.org/doc/effective_go.html#init

OK por que tão complexo!

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())
}

Isso é baseado no código do distro, mas adequado às minhas necessidades.

São seis (rands ints 1 =< i =< 6)

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

A função acima é exatamente a mesma coisa.

Espero que esta informação tenha sido útil.

São nano segundos, quais são as chances de obter a mesma semente duas vezes.
De qualquer forma, obrigado pela ajuda, aqui está minha solução final com base em todas as informações.

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))
}

Se o seu objetivo é apenas gerar um número aleatório, acho desnecessário complicá-lo com várias chamadas de função ou redefinir a semente toda vez.

O passo mais importante é chamar a função de semente apenas uma vez antes de realmente executar rand.Init(x). Semente usa o valor de semente fornecido para inicializar a Origem padrão para um estado determinístico. Portanto, seria sugerido chamá-lo uma vez antes da chamada de função real para o gerador de números pseudo-aleatórios.

Aqui está um código de exemplo criando uma sequência de números aleatórios

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)
}

A razão pela qual eu usei o Sprintf é porque ele permite formatação simples de string.

Além disso, In rand.Intn(7) Intn retorna, como int, um número pseudo-aleatório não negativo em [0,7).

@ [Denys Séguret] postou correto. Mas, no meu caso, preciso de novas sementes toda vez que estão abaixo do código;

Caso você precise de funções rápidas. Eu uso assim.

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)
}

fonte

Pequena atualização devido a alterações na API do golang, omita .UTC ():

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)
}