c语言按概率生成随机数

在C语言中，可以使用rand()函数来生成随机数。但是，它仅能生成伪随机数，即在一定范围内按照固定的算法生成的数字序列，因此它并不是真正的随机数。如果需要按照概率生成随机数，可以使用概率分布函数，例如均匀分布、正态分布等。

例如，如果需要按照均匀分布生成随机数，可以使用rand()函数生成0到RAND_MAX（通常是32767）之间的随机数，然后将其除以RAND_MAX，就可以得到一个0到1之间的随机数。如果需要生成指定范围内的随机数，可以使用如下代码：

int min = 1, max = 6; // 生成1到6的随机数
int rand_num = min + (int)((max - min + 1) * rand() / (RAND_MAX + 1.0));

其中，(int)((max - min + 1) * rand() / (RAND_MAX + 1.0))可以生成一个1到6之间的随机整数。

相关问题

c语言生成概率相关函数库

1. rand(): 生成一个0到RAND_MAX之间的伪随机整数，其中RAND_MAX是stdlib.h头文件中定义的常量。

2. srand(seed): 初始化随机数生成器，其中seed是一个整数值，通常使用time(NULL)函数返回的时间戳作为种子。

3. drand48(): 生成一个[0,1)之间的伪随机双精度浮点数。

4. srand48(seed): 初始化伪随机数生成器，其中seed是一个长整型值。

5. erand48(xsubi): 生成一个[0,1)之间的伪随机双精度浮点数，其中xsubi是一个48位的无符号整数数组。

6. lrand48(): 生成一个伪随机长整数。

7. nrand48(xsubi): 生成一个伪随机长整数。

8. mrand48(): 生成一个伪随机长整数。

9. jrand48(xsubi): 生成一个伪随机长整数。

10. srand48(seedval): 初始化伪随机数生成器，其中seedval是一个长整型值。

11. seed48(seed16v): 初始化伪随机数生成器，其中seed16v是一个16位的无符号整数数组。

12. srandom(seed): 初始化随机数生成器，其中seed是一个整数值。

13. random(): 生成一个随机长整数。

14. initstate(seed, state, size): 初始化随机数生成器，其中seed是一个整数值，state是一个状态数组，size是状态数组的大小。

15. setstate(state): 设置随机数生成器的状态，其中state是一个状态数组。

16. jrand48(xsubi): 生成一个伪随机长整数，其中xsubi是一个48位的无符号整数数组。

17. nrand48(xsubi): 生成一个伪随机长整数，其中xsubi是一个48位的无符号整数数组。

18. mrand48(): 生成一个伪随机长整数。

19. lrand48(): 生成一个伪随机长整数。

20. erand48(xsubi): 生成一个[0,1)之间的伪随机双精度浮点数，其中xsubi是一个48位的无符号整数数组。

21. drand48(): 生成一个[0,1)之间的伪随机双精度浮点数。

22. srand48(seed): 初始化伪随机数生成器，其中seed是一个长整型值。

23. seed48(seed16v): 初始化伪随机数生成器，其中seed16v是一个16位的无符号整数数组。

24. lcong48(param): 初始化伪随机数生成器，其中param是一个7元素的长整型数组。

25. rand_r(seed): 生成一个0到RAND_MAX之间的伪随机整数，其中seed是一个指向unsigned int类型的指针。

26. random_r(seed): 生成一个随机长整数，其中seed是一个指向unsigned int类型的指针。

27. srandom_r(seed, ctx): 初始化随机数生成器，其中seed是一个整数值，ctx是一个指向struct random_data结构的指针。

28. initstate_r(seed, statebuf, statelen, ctx): 初始化随机数生成器，其中seed是一个整数值，statebuf是一个状态数组，statelen是状态数组的大小，ctx是一个指向struct random_data结构的指针。

29. setstate_r(statebuf, ctx): 设置随机数生成器的状态，其中statebuf是一个状态数组，ctx是一个指向struct random_data结构的指针。

30. rand_p(seed): 生成一个0到RAND_MAX之间的伪随机整数，其中seed是一个指向unsigned int类型的指针。

31. srand_p(seed): 初始化随机数生成器，其中seed是一个指向unsigned int类型的指针。

32. rand_inc(seed): 生成一个0到RAND_MAX之间的伪随机整数，其中seed是一个指向unsigned int类型的指针。

33. srand_inc(seed): 初始化随机数生成器，其中seed是一个指向unsigned int类型的指针。

使用c语言生成概率统计函数库

1. 随机数生成函数

#include <stdlib.h>
#include <time.h>

void initRand() {
    srand(time(NULL));
}

int randInt(int min, int max) {
    return rand() % (max - min + 1) + min;
}

double randDouble(double min, double max) {
    return (double)rand() / RAND_MAX * (max - min) + min;
}

2. 统计函数

#include <stdio.h>

int countChar(const char* str, char c) {
    int count = 0;
    while (*str) {
        if (*str == c) {
            count++;
        }
        str++;
    }
    return count;
}

int countWord(const char* str) {
    int count = 0;
    while (*str) {
        if (*str == ' ' || *str == '\n' || *str == '\t') {
            count++;
        }
        str++;
    }
    return count;
}

int countLine(const char* str) {
    int count = 0;
    while (*str) {
        if (*str == '\n') {
            count++;
        }
        str++;
    }
    return count;
}

int countDigit(int n) {
    int count = 0;
    while (n) {
        count++;
        n /= 10;
    }
    return count;
}

int countPrime(int n) {
    if (n <= 1) {
        return 0;
    }
    for (int i = 2; i <= n / 2; i++) {
        if (n % i == 0) {
            return 0;
        }
    }
    return 1;
}

3. 概率函数

#include <math.h>

double normalPDF(double x, double mu, double sigma) {
    return exp(-pow(x - mu, 2) / (2 * pow(sigma, 2))) / (sqrt(2 * M_PI) * sigma);
}

double normalCDF(double x, double mu, double sigma) {
    return (1 + erf((x - mu) / (sigma * sqrt(2)))) / 2;
}

double binomialPDF(int k, int n, double p) {
    int c = 1;
    for (int i = 1; i <= k; i++) {
        c *= n - i + 1;
        c /= i;
    }
    return c * pow(p, k) * pow(1 - p, n - k);
}

double binomialCDF(int k, int n, double p) {
    double cdf = 0;
    for (int i = 0; i <= k; i++) {
        cdf += binomialPDF(i, n, p);
    }
    return cdf;
}

double uniformPDF(double x, double a, double b) {
    if (x < a || x > b) {
        return 0;
    }
    return 1 / (b - a);
}

double uniformCDF(double x, double a, double b) {
    if (x < a) {
        return 0;
    }
    if (x >= b) {
        return 1;
    }
    return (x - a) / (b - a);
}

4. 示例代码

#include <stdio.h>
#include "stats.h"

int main() {
    initRand();

    // 随机数生成
    printf("randInt(1, 10): %d\n", randInt(1, 10));
    printf("randDouble(0, 1): %f\n", randDouble(0, 1));

    // 统计函数
    printf("countChar(\"hello world\", 'l'): %d\n", countChar("hello world", 'l'));
    printf("countWord(\"hello world\\nhi there\\n\"): %d\n", countWord("hello world\nhi there\n"));
    printf("countLine(\"hello world\\nhi there\\n\"): %d\n", countLine("hello world\nhi there\n"));
    printf("countDigit(12345): %d\n", countDigit(12345));
    printf("countPrime(7): %d\n", countPrime(7));

    // 概率函数
    printf("normalPDF(0, 0, 1): %f\n", normalPDF(0, 0, 1));
    printf("normalCDF(1, 0, 1): %f\n", normalCDF(1, 0, 1));
    printf("binomialPDF(2, 5, 0.5): %f\n", binomialPDF(2, 5, 0.5));
    printf("binomialCDF(2, 5, 0.5): %f\n", binomialCDF(2, 5, 0.5));
    printf("uniformPDF(0.5, 0, 1): %f\n", uniformPDF(0.5, 0, 1));
    printf("uniformCDF(0.5, 0, 1): %f\n", uniformCDF(0.5, 0, 1));

    return 0;
}