go rand 创建 伪随机数,随机字符串,随机slice切片,偏向随机

一、创建伪随机数

1.1 rand.Int()与rand.Intn()方法的区别

官方文档 https://pkg.go.dev/math/rand
Int:不带参数

Int returns a non-negative pseudo-random int.
Int 方法将返回一个非负的伪随机 int 类型的数

Intn:带参数

Intn returns, as an int, a non-negative pseudo-random number in the half-open interval [0,n). It panics if n <= 0.
Intn 方法将返回一个非负伪随机数,其值范围在半开区间 [0, n)。如果传入的 n <= 0,将会 panic
表示生成一个值在区间 [0, n) 的 Int 数

让我们用 Go 语言创建一个伪随机数。
这是一个简单的代码:
从 0 到 9 的数字输出 10 次。

func TestRandIntn(t *testing.T) {
    rand.Seed(time.Now().UnixNano())
    for i := 0; i < 10; i++ {
        fmt.Println("number is ", rand.Intn(10))
    }
}

输出:

number is  7
number is  1
number is  6
number is  1
number is  8
number is  7
number is  3
number is  4
number is  9
number is  9

关键是在名为rand.Seed(time.Now().UnixNano())的地方给出作为随机数来源的种子。
给个种子的原因是这里使用的函数rand.Intn在rand包中生成新的随机数生成器的时候好像初始化rand.NewSource(1)一样,所以给个种子,好像是需要发出不同的随机数。

下面是一个没有播种的具有相同结果的示例。


func TestRandIntnNoSeed(t *testing.T) {
    // 无种子rand.Intn 随机
    for i := 0; i < 10; i++ {
        fmt.Print(rand.Intn(10), " ")
    }
    fmt.Println(" ")

    // rand.NewSource初始化rand并执行
    myRand := rand.New(rand.NewSource(1))
    for i := 0; i < 10; i++ {
        fmt.Print(myRand.Intn(10), " ")
    }
    fmt.Println(" ")

    // 添加种子在rand
    myRand.Seed(time.Now().UnixNano())
    for i := 0; i < 10; i++ {
        fmt.Print(myRand.Intn(10), " ")
    }
}

第一次运行

=== RUN   TestRandIntnNoSeed
1 7 7 9 1 8 5 0 6 0  
1 7 7 9 1 8 5 0 6 0  
7 6 9 1 4 2 1 5 3 1 --- PASS: TestRandIntnNoSeed (0.00s)
PASS

第二次运行

=== RUN   TestRandIntnNoSeed
1 7 7 9 1 8 5 0 6 0  
1 7 7 9 1 8 5 0 6 0  
3 9 3 8 6 6 2 5 2 6 --- PASS: TestRandIntnNoSeed (0.00s)
PASS

二、随机字符串

思路:先申明一个字符串,然后随机字符串的index,生成一个新的字符串。

func TestRandString(t *testing.T) {
    var s = "abcdefghi_+!@"
    var ss []byte = make([]byte, 0, len(s))

    rand.Seed(time.Now().UnixNano())
    for i := 0; i < len(s); i++ {
        index := rand.Intn(len(s))
        ss = append(ss, s[index])
    }

    t.Log(string(ss))
}

输出:

i+dfh_gfbd_ae

三、随机slice切片

func TestRandSlice(t *testing.T) {
    var sl []string = []string{"hello", "word", "1", "你", "中国"}
    rand.Seed(time.Now().UnixNano())
    for i := 0; i < len(sl); i++ {
        index := rand.Intn(len(sl))
        t.Log(sl[index])
    }
}

输出:

你
中国
word
hello
1

四、偏向随机

type randPercent struct {
    name    string
    Percent int
}

var ps []randPercent = []randPercent{
    {name: "a", Percent: 10},
    {name: "b", Percent: 50},
    {name: "c", Percent: 20},
}

如上a,b,c出现的概率大约10%,50%,20%.
则是大约出现10次a,就出现50次b,20次c,这个就是偏向随机。
思路:我们画一个如下数字分布点图,大约如下
image.png
把概率变成数据,然后随机数字范围。落在哪个区域就是随机到哪组。

名称范围
a[0,9]
b[10,59]
c[60,79]
type randPercent struct {
    name    string
    Percent int
}

func random(ps []randPercent) randPercent {
    type limit struct {
        Min int
        Max int
    }

    //1.实现数字分配概率范围
    var numSlice = make([]limit, 0, len(ps))
    var min = 0
    var max = 0
    for _, p := range ps {
        max += p.Percent
        lt := limit{
            Min: min,
            Max: max - 1,
        }
        min = max
        numSlice = append(numSlice, lt)
    }
    fmt.Println(numSlice) //[{0 9} {10 59} {60 79}]

    //2 随机
    rand.Seed(time.Now().UnixNano())
    n := rand.Intn(max)
    fmt.Println(n)
    for i, l := range numSlice {
        fmt.Println(i, n, l)
        if n >= l.Min && n <= l.Max {
            return ps[i]
        }
    }
    return randPercent{}
}
func TestRand2(t *testing.T) {
    var ps []randPercent = []randPercent{
        {name: "a", Percent: 10},
        {name: "b", Percent: 50},
        {name: "c", Percent: 20},
    }
    for i := 0; i < 100; i++ {
        t.Log(random(ps))
    }

}

输出如下100个随机的偏向数据

{b 50}
{c 20}
{b 50}
{b 50}
{c 20}
{b 50}
{b 50}
{b 50}
{a 10}
......

谢谢您的观看,欢迎关注我的公众号。

image.png

评论

暂无评论