วิธีการสร้างเครื่องกำเนิดจำนวนสุ่มอย่างถูกต้อง

ฉันกำลังพยายามสร้างสตริงแบบสุ่มใน Go และนี่คือรหัสที่ฉันเขียน:

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

การใช้งานของฉันช้ามาก การเพาะโดยใช้timeจะมีตัวเลขสุ่มเหมือนกันในช่วงเวลาหนึ่งดังนั้นวนซ้ำซ้ำแล้วซ้ำอีก ฉันจะปรับปรุงรหัสของฉันได้อย่างไร

ทุกครั้งที่คุณตั้งค่าเมล็ดเดียวกันคุณจะได้รับลำดับเดียวกัน แน่นอนถ้าคุณตั้งค่าเมล็ดเป็นเวลาในการวนรอบอย่างรวดเร็วคุณอาจเรียกมันด้วยเมล็ดเดียวกันหลายครั้ง

ในกรณีของคุณในขณะที่คุณกำลังเรียกrandIntใช้ฟังก์ชันของคุณจนกว่าคุณจะมีค่าที่แตกต่างกันคุณกำลังรอเวลา (ที่ส่งคืนโดยนาโน) เพื่อเปลี่ยน

สำหรับไลบรารีหลอกแบบสุ่มทั้งหมดคุณต้องตั้งค่า seed เพียงครั้งเดียวเช่นเมื่อเริ่มต้นโปรแกรมของคุณเว้นแต่ว่าคุณต้องการสร้างลำดับที่กำหนด (โดยเฉพาะสำหรับการดีบักและการทดสอบหน่วย)

หลังจากนั้นคุณเพียงโทรIntnเพื่อรับจำนวนเต็มแบบสุ่มถัดไป

ย้ายrand.Seed(time.Now().UTC().UnixNano())สายจากฟังก์ชั่น randInt ไปที่จุดเริ่มต้นของหลักและทุกอย่างจะเร็วขึ้น

โปรดทราบว่าฉันคิดว่าคุณสามารถทำให้การสร้างสตริงของคุณง่ายขึ้น:

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

ฉันไม่เข้าใจว่าเพราะเหตุใดผู้คนจึงเริ่มมีคุณค่ากับเวลา สิ่งนี้มีในประสบการณ์ของฉันไม่เคยเป็นความคิดที่ดี ตัวอย่างเช่นในขณะที่นาฬิการะบบอาจแสดงเป็นนาโนวินาทีความแม่นยำสัญญาณนาฬิกาของระบบไม่ใช่นาโนวินาที

โปรแกรมนี้ไม่ควรรันบนสนามเด็กเล่นของ Go แต่ถ้าคุณรันบนเครื่องของคุณคุณจะได้รับการประเมินคร่าวๆเกี่ยวกับประเภทของความแม่นยำที่คุณคาดหวัง ฉันเห็นการเพิ่มขึ้นประมาณ 1000000 ns ดังนั้นเพิ่มขึ้น 1 ms นั่นคือเอนโทรปี 20 บิตที่ไม่ได้ใช้ ในขณะที่บิตสูงส่วนใหญ่คงที่

ระดับที่สิ่งนี้มีความสำคัญกับคุณจะแตกต่างกันไป แต่คุณสามารถหลีกเลี่ยงข้อผิดพลาดของค่าเมล็ดที่มีนาฬิกาได้โดยเพียงแค่ใช้crypto/rand.Readแหล่งที่มาสำหรับเมล็ดของคุณ มันจะทำให้คุณมีคุณภาพที่ไม่สามารถกำหนดค่าได้ซึ่งคุณอาจกำลังมองหาในตัวเลขสุ่มของคุณ (แม้ว่าการใช้งานจริงนั้น จำกัด อยู่ที่ชุดของลำดับสุ่มที่แตกต่าง

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

เป็นหมายเหตุด้านข้าง แต่เกี่ยวข้องกับคำถามของคุณ คุณสามารถสร้างของคุณเองrand.Sourceโดยใช้วิธีนี้เพื่อหลีกเลี่ยงค่าใช้จ่ายในการล็อคป้องกันแหล่งที่มา randฟังก์ชันอรรถประโยชน์แพคเกจมีความสะดวก แต่พวกเขายังใช้ล็อคภายใต้ประทุนเพื่อป้องกันไม่ให้แหล่งที่มาจากการถูกใช้พร้อมกัน หากคุณไม่ต้องการให้คุณสามารถหลีกเลี่ยงได้โดยการสร้างของคุณเองSourceและใช้มันในแบบที่ไม่เกิดขึ้นพร้อมกัน ไม่ว่าคุณไม่ควรทำการสุ่มตัวเลขซ้ำระหว่างการทำซ้ำมันไม่เคยถูกออกแบบมาให้ใช้แบบนั้น

เพียงแค่โยนมันออกมาเพื่อลูกหลาน: บางครั้งมันอาจจะดีกว่าที่จะสร้างสตริงแบบสุ่มโดยใช้สตริงชุดอักขระเริ่มต้น สิ่งนี้มีประโยชน์หากมนุษย์ควรป้อนสตริงด้วยตนเอง การยกเว้น 0, O, 1 และ l สามารถช่วยลดข้อผิดพลาดของผู้ใช้ได้

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

และฉันมักจะตั้งค่าเมล็ดในinit()บล็อก มีการบันทึกไว้ที่นี่: http://golang.org/doc/effective_go.html#init

ตกลงทำไมซับซ้อนจัง!

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

นี่เป็นไปตามรหัสของ dystroy แต่พอดีกับความต้องการของฉัน

มันตายหก (rands ints 1 =< i =< 6)

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

ฟังก์ชั่นด้านบนเป็นสิ่งเดียวกัน

ฉันหวังว่าข้อมูลนี้มีการใช้งาน

มันคือนาโนวินาทีอะไรคือโอกาสที่จะได้เมล็ดเดียวกันสองครั้ง
อย่างไรก็ตามขอขอบคุณสำหรับความช่วยเหลือนี่คือทางออกสุดท้ายของฉันตามอินพุตทั้งหมด

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

หากเป้าหมายของคุณคือสร้างหมายเลขสุ่มต่อจากนั้นฉันคิดว่ามันไม่จำเป็นที่จะต้องยุ่งยากกับการเรียกฟังก์ชั่นหลายครั้งหรือรีเซ็ตเมล็ดทุกครั้ง

rand.Init(x)ขั้นตอนที่สำคัญที่สุดคือการฟังก์ชั่นเมล็ดโทรเพียงครั้งเดียวก่อนที่จะใช้จริง Seedใช้ค่าเมล็ดที่จัดเตรียมไว้เพื่อเริ่มต้นแหล่งที่มาเริ่มต้นให้เป็นสถานะที่กำหนดไว้ล่วงหน้า ดังนั้นจึงขอแนะนำให้เรียกมันหนึ่งครั้งก่อนการเรียกใช้ฟังก์ชันจริงไปยังตัวสร้างตัวเลขแบบหลอกเทียม

นี่คือตัวอย่างรหัสที่สร้างสตริงของตัวเลขสุ่ม

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

เหตุผลที่ฉันใช้Sprintfนั้นเป็นเพราะช่วยให้การจัดรูปแบบสตริงง่าย

นอกจากนี้ In rand.Intn(7) Intnจะส่งกลับเช่นเดียวกับ int ซึ่งเป็นตัวเลขสุ่มหลอกที่ไม่เป็นลบใน [0,7)

@ [Denys Séguret] โพสต์ถูกต้องแล้ว แต่ในกรณีของฉันฉันต้องการเมล็ดพันธุ์ใหม่ทุกครั้งดังนั้นด้านล่างรหัส;

ในกรณีที่คุณต้องการฟังก์ชั่นที่รวดเร็ว ฉันใช้สิ่งนี้

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

แหล่ง

การอัปเดตเล็กน้อยเนื่องจากการเปลี่ยนแปลง golang api โปรดละเว้น. 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)
}