如何从 rand() 获取特定范围的数字？

Question

srand(time(null));

printf("%d", rand());

给出一个高范围的随机数（0-32000ish），但我只需要大约 0-63 或 0-127，虽然我不知道如何去做。有什么帮助吗？

Answer 1

你可以通过在rand函数前面加一个%来改变代码

例如：

rand() % 50

会给你一个 50 范围内的随机数。对你来说，将 50 替换为 63 或 127

Answer 2

此答案不关注随机性，而是关注算术顺序。 要得到一个范围内的数字，通常我们可以这样做：

// the range is between [aMin, aMax]
double f = (double)rand() / RAND_MAX;
double result = aMin + f * (aMax - aMin);

但是，(aMax - aMin) 有可能溢出。例如。 aMax = 1，aMin = -DBL_MAX。更安全的方法是这样写：

// the range is between [aMin, aMax]
double f = (double)rand() / RAND_MAX;
double result = aMin - f * aMin + f * aMax;

基于这个概念，这样的事情可能会导致问题。

rand() % (max_number + 1 - minimum_number) + minimum_number
// 1. max_number + 1 might overflow
// 2. max_number + 1 - min_number might overflow

Answer 3

你可以用这个：

int random(int min, int max){
   return min + rand() / (RAND_MAX / (max - min + 1) + 1);
}

来自：

comp.lang.c 常见问题列表·问题13.16

问：如何获取一定范围内的随机整数？

A：显而易见的方式，

rand() % N        /* POOR */

（它试图返回从 0 到 N-1 的数字）很差，因为 许多随机数发生器的低位令人痛苦 非随机。 （见问题13.18。）更好的方法是

(int)((double)rand() / ((double)RAND_MAX + 1) * N)

如果你不想使用浮点，另一种方法是

rand() / (RAND_MAX / N + 1)

如果你只需要以 1/N 的概率做某事，你可以使用

if(rand() < (RAND_MAX+1u) / N)

所有这些方法显然都需要知道 RAND_MAX（ANSI #defines 在 中），并假设 N 远小于 RAND_MAX。当 N 接近 RAND_MAX 时，如果随机数的范围 生成器不是 N 的倍数（即如果 (RAND_MAX+1) % N != 0），所有 这些方法中的一些失败：一些输出发生的频率高于 其他。 （使用浮点没有帮助；问题是 rand 返回 RAND_MAX+1 个不同的值，这些值并不总是均匀的 分成N个桶。）如果这是一个问题，关于唯一的事情 你可以做的是多次调用 rand ，丢弃某些值：

unsigned int x = (RAND_MAX + 1u) / N;
unsigned int y = x * N;
unsigned int r;
do {
  r = rand();
} while(r >= y);
return r / x;

对于这些技术中的任何一种，移动范围都很简单， 如有必要； [M, N] 范围内的数字可以用 像

M + rand() / (RAND_MAX / (N - M + 1) + 1)

（注意，顺便说一下，R​​AND_MAX 是一个常数，告诉你什么 C 库 rand 函数的固定范围是。你不能设置 RAND_MAX 到其他值，并且没有办法要求 rand 返回其他范围内的数字。）

如果您从返回的随机数生成器开始 介于 0 和 1 之间的浮点值（例如 PMrand 提到有问题的 13.15，或有问题的 drand48 13.21)，要获得从 0 到 N-1 的整数，您所要做的就是 将该生成器的输出乘以 N：

(int)(drand48() * N)

Additional links

参考：K&R2 Sec. 7.8.7 页。 168
个人电脑秒。 11 页。 172

引用自：http://c-faq.com/lib/randrange.html

Answer 4

在多次运行程序时，只要使用 rand() 就会给你相同的随机数。即当你第一次运行你的程序时，它会产生随机数 x、y 和 z。如果您再次运行该程序，那么它将产生与我观察到的相同的 x、y 和 z 数。

我发现每次都保持其唯一性的解决方案是使用 srand()

这是附加代码，

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

time_t t;
srand((unsigned) time(&t));
int rand_number = rand() % (65 + 1 - 0) + 0 //i.e Random numbers in range 0-65.

要设置范围，您可以使用公式：rand() % (max_number + 1 - minimum_number) + minimum_number

希望对你有帮助！

Answer 5

2 cents (ok 4 cents):

n = rand()
x = result
l = limit

n/RAND_MAX = x/l

Refactor:

(l/1)*(n/RAND_MAX) = (x/l)*(l/1)

Gives:

x = l*n/RAND_MAX

int randn(int limit)

{

    return limit*rand()/RAND_MAX;

}

int i;

for (i = 0; i < 100; i++) { 

    printf("%d ", randn(10)); 
    if (!(i % 16)) printf("\n"); 

}

> test
0
5 1 8 5 4 3 8 8 7 1 8 7 5 3 0 0
3 1 1 9 4 1 0 0 3 5 5 6 6 1 6 4
3 0 6 7 8 5 3 8 7 9 9 5 1 4 2 8
2 7 8 9 9 6 3 2 2 8 0 3 0 6 0 0
9 2 2 5 6 8 7 4 2 7 4 4 9 7 1 5
3 7 6 5 3 1 2 4 8 5 9 7 3 1 6 4
0 6 5

Answer 6

只是为现有答案添加一些额外的细节。

mod % 操作将始终执行完全除法，因此产生的余数小于除数。

x % y = x - (y * floor((x/y)))

使用 cmets 进行随机范围查找函数的示例：

uint32_t rand_range(uint32_t n, uint32_t m) {
    // size of range, inclusive
    const uint32_t length_of_range = m - n + 1;

    // add n so that we don't return a number below our range
    return (uint32_t)(rand() % length_of_range + n);
}

上述另一个有趣的属性：

x % y = x，如果 x

const uint32_t value = rand_range(1, RAND_MAX); // results in rand() % RAND_MAX + 1
// TRUE for all x = RAND_MAX, where x is the result of rand()
assert(value == RAND_MAX);
result of rand()

Answer 7

rand() % (max_number + 1 - minimum_number) + minimum_number

所以，对于 0-65：

rand() % (65 + 1 - 0) + 0

（显然您可以不使用 0，但它的存在是为了完整性）。

请注意，这会稍微偏向随机性，但如果您没有做特别敏感的事情，则可能无需担心。

Answer 8

如果您关心随机数的质量，请不要使用 rand()

使用其他一些 prng，例如 http://en.wikipedia.org/wiki/Mersenne_twister 或其他高质量的 prng 之一

那么就用模数吧。

Answer 9

正如其他人所指出的那样，简单地使用模数会扭曲单个数字的概率，因此更倾向于使用较小的数字。

在 Java 的 java.util.Random 类中使用了一个非常巧妙且很好的解决方案：

public int nextInt(int n) {
    if (n <= 0)
        throw new IllegalArgumentException("n must be positive");

    if ((n & -n) == n)  // i.e., n is a power of 2
        return (int)((n * (long)next(31)) >> 31);

    int bits, val;
    do {
        bits = next(31);
        val = bits % n;
    } while (bits - val + (n-1) < 0);
    return val;
}

我花了一段时间才理解它为什么起作用，我把它留给读者作为练习，但这是一个非常简洁的解决方案，可以确保数字具有相等的概率。

那段代码中的重要部分是while 循环的条件，它拒绝落在数字范围内的数字，否则会导致分布不均。

Answer 10

更新为不使用#define

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

Answer 11

double scale = 1.0 / ((double) RAND_MAX + 1.0);
int min, max;
...
rval = (int)(rand() * scale * (max - min + 1) + min);

Answer 12

在这里查看

http://c-faq.com/lib/randrange.html

对于这些技术中的任何一种，如有必要，可以直接移动范围； [M, N] 范围内的数字可以用类似的东西生成

M + rand() / (RAND_MAX / (N - M + 1) + 1)

Answer 13

我认为以下是半正确的。自从我接触 C 以来已经有一段时间了。这个想法是使用除法，因为模数并不总是给出随机结果。我在 RAND_MAX 中加了 1，因为有很多可能的值来自 rand，包括 0。而且由于范围也包括 0，所以我也在那里加了 1。我认为数学排列正确避免了整数数学问题。

#define MK_DIVISOR(max) ((int)((unsigned int)RAND_MAX+1/(max+1)))

num = rand()/MK_DIVISOR(65);

Answer 14

对结果取模，正如其他发帖人所断言的那样，会给你一些几乎随机的东西，但并不完全如此。

考虑这个极端的例子，假设你想模拟掷硬币，返回 0 或 1。你可以这样做：

isHeads = ( rand() % 2 ) == 1;

看起来很无害，对吧？假设 RAND_MAX 仅为 3。当然它要高得多，但这里的重点是，当您使用不均分 RAND_MAX 的模数时存在偏差。如果你想要高质量的随机数，你就会遇到问题。

考虑我的例子。可能的结果是：

rand()  freq. rand() % 2
0       1/3   0
1       1/3   1
2       1/3   0

因此，“反面”的出现频率是“正面”的两倍！

先生。阿特伍德讨论此事in this Coding Horror Article

Answer 15

天真的做法是：

int myRand = rand() % 66; // for 0-65

这可能是一个非常不均匀的分布（取决于您的最大值），但非常接近。

要解释为什么它不是很统一，请考虑这个非常简化的示例：
假设 RAND_MAX 是 4，并且您想要一个 0-2 之间的数字。您可以获得的可能值如下表所示：

rand()   |  rand() % 3
---------+------------
0        |  0
1        |  1
2        |  2
3        |  0

看到问题了吗？如果您的最大值不是 RAND_MAX 的偶数除数，您将更有可能选择较小的值。但是，由于 RAND_MAX 通常为 32767，因此偏差可能足够小，可以在大多数情况下逃脱。

有多种方法可以解决这个问题；有关 Java 的 Random 如何处理它的说明，请参阅 here。

Answer 16

rand() 将返回介于 0 和 RAND_MAX（至少为 32767）之间的数字。

如果你想得到一个范围内的数字，你可以使用模数。

int value = rand() % 66; // 0-65

如需更准确，请check out this article。它讨论了为什么模不一定是好的（不好的分布，特别是在高端），并提供了各种选项。

Answer 17

如果您不太关心低位的“随机性”，只需 rand() % HI_VAL。

还有：

(double)rand() / (double)RAND_MAX;  // lazy way to get [0.0, 1.0)