範囲内からランダムな整数を生成する方法

これは以前に投稿された質問の続きです：

Cで乱数を生成する方法は？

サイコロの側面を模倣するために、1から6などの特定の範囲内から乱数を生成できるようにしたいと考えています。

これを行うにはどうすればよいですか？

これまでのすべての答えは数学的に間違っています。返す間隔rand() % Nの範囲の長さを2の累乗で除算し[0, N)ない限り、範囲内の数値Nがrand()返されることはありません。さらに、の係数rand()が独立しているかどうかはわかり0, 1, 2, ...ません。均一であるが非常にランダムではない可能性があります。妥当であると思われる唯一の仮定はrand()、ポアソン分布を出力することです。同じサイズの2つの重複しない部分区間は、等しく可能性が高く、独立しています。値の有限セットの場合、これは均一な分布を意味し、の値rand()が適切に分散されることも保証します。

つまり、範囲を変更する唯一の正しい方法は、範囲rand()をボックスに分割することです。たとえば、のRAND_MAX == 11範囲が1..6必要な場合は、{0,1}1 {2,3}から2に割り当てる必要があります。これらはばらばらで、同じサイズの間隔であるため、均一かつ独立して分散されます。

浮動小数点除算を使用するという提案は数学的にもっともらしいですが、原則として丸めの問題に悩まされています。おそらくdouble、それを機能させるのに十分な精度があります。おそらくない。私にはわかりませんし、理解する必要もありません。いずれにせよ、答えはシステムに依存します。

正しい方法は、整数演算を使用することです。つまり、次のようなものが必要です。

#include <stdlib.h> // For random(), RAND_MAX

// Assumes 0 <= max <= RAND_MAX
// Returns in the closed interval [0, max]
long random_at_most(long max) {
  unsigned long
    // max <= RAND_MAX < ULONG_MAX, so this is okay.
    num_bins = (unsigned long) max + 1,
    num_rand = (unsigned long) RAND_MAX + 1,
    bin_size = num_rand / num_bins,
    defect   = num_rand % num_bins;

  long x;
  do {
   x = random();
  }
  // This is carefully written not to overflow
  while (num_rand - defect <= (unsigned long)x);

  // Truncated division is intentional
  return x/bin_size;
}

ループは、完全に均一な分布を得るために必要です。たとえば、0から2までの乱数が与えられ、0から1までの乱数のみが必要な場合は、2が得られなくなるまでプルし続けます。これが等しい確率で0または1を与えることを確認するのは難しくありません。この方法は、コードが異なっていても、nosが回答で示したリンクにも記載されています。（のmanページに記載されているように）より良いディストリビューションを持っているrandom()のでrand()、私は使用していますrand()。

デフォルトの範囲外のランダムな値を取得したい場合は、注意が必要です[0, RAND_MAX]。おそらく、最も好都合には、関数を定義することであるrandom_extended()引っ張るnビット（使用random_at_most()中）と戻り[0, 2**n)、その後、適用random_at_most()とrandom_extended()の代わりにrandom()（と2**n - 1の代わりにRAND_MAX）未満のランダムな値を引っ張って2**nこのようなを保持することができ、数値型であると仮定すると、価値。最後に、もちろん、負の値を含むを[min, max]使用して値を取得できmin + random_at_most(max - min)ます。

@Ryan Reichの回答に続き、私は私のクリーンアップしたバージョンを提供すると思いました。最初の境界チェックは2番目の境界チェックを前提として不要であり、再帰的ではなく反復的にしました。これは、範囲[MIN、MAX]の値を返すmax >= minと1+max-min < RAND_MAX。

unsigned int rand_interval(unsigned int min, unsigned int max)
{
    int r;
    const unsigned int range = 1 + max - min;
    const unsigned int buckets = RAND_MAX / range;
    const unsigned int limit = buckets * range;

    /* Create equal size buckets all in a row, then fire randomly towards
     * the buckets until you land in one of them. All buckets are equally
     * likely. If you land off the end of the line of buckets, try again. */
    do
    {
        r = rand();
    } while (r >= limit);

    return min + (r / buckets);
}

範囲の最大値と最小値がわかっていて、その範囲内に含まれる数値を生成する場合の数式は次のとおりです。

r = (rand() % (max + 1 - min)) + min

unsigned int
randr(unsigned int min, unsigned int max)
{
       double scaled = (double)rand()/RAND_MAX;

       return (max - min +1)*scaled + min;
}

その他のオプションについては、こちらをご覧ください。

あなたはただやってみませんか？

srand(time(NULL));
int r = ( rand() % 6 ) + 1;

%モジュラス演算子です。基本的には、6で割って余りを0〜5で返します。

バイアスの問題は理解しているが、拒否ベースのメソッドの予測できない実行時間に耐えられない人のために、このシリーズは、[0, n-1]間隔の中で次第にバイアスの少ないランダムな整数を生成します。

r = n / 2;
r = (rand() * n + r) / (RAND_MAX + 1);
r = (rand() * n + r) / (RAND_MAX + 1);
r = (rand() * n + r) / (RAND_MAX + 1);
...

これは、高精度の固定小数点乱数i * log_2(RAND_MAX + 1)ビット（ここiで、は反復数）を合成し、による長い乗算を実行することによって行われnます。

と比較してビット数が十分に多いn場合、バイアスは非常に小さくなります。

かどうかは関係ありませんRAND_MAX + 1未満であるn（のように、この質問）、またはそれは2の累乗でない場合は、しかし場合は注意がオーバーフロー、整数避けるようにしなければならないRAND_MAX * n大きさです。

モジュロバイアス（他の回答で推奨）を回避するために、常に以下を使用できます。

arc4random_uniform(MAX-MIN)+MIN

「MAX」は上限、「MIN」は下限です。たとえば、10〜20の数値の場合：

arc4random_uniform(20-10)+10

arc4random_uniform(10)+10

シンプルなソリューションで、「rand（）％N」を使用するよりも優れています。

以下は、Ryan Reichのソリューションよりも少し単純なアルゴリズムです。

/// Begin and end are *inclusive*; => [begin, end]
uint32_t getRandInterval(uint32_t begin, uint32_t end) {
    uint32_t range = (end - begin) + 1;
    uint32_t limit = ((uint64_t)RAND_MAX + 1) - (((uint64_t)RAND_MAX + 1) % range);

    /* Imagine range-sized buckets all in a row, then fire randomly towards
     * the buckets until you land in one of them. All buckets are equally
     * likely. If you land off the end of the line of buckets, try again. */
    uint32_t randVal = rand();
    while (randVal >= limit) randVal = rand();

    /// Return the position you hit in the bucket + begin as random number
    return (randVal % range) + begin;
}

Example (RAND_MAX := 16, begin := 2, end := 7)
    => range := 6  (1 + end - begin)
    => limit := 12 (RAND_MAX + 1) - ((RAND_MAX + 1) % range)

The limit is always a multiple of the range,
so we can split it into range-sized buckets:
    Possible-rand-output: 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16
    Buckets:             [0, 1, 2, 3, 4, 5][0, 1, 2, 3, 4, 5][X, X, X, X, X]
    Buckets + begin:     [2, 3, 4, 5, 6, 7][2, 3, 4, 5, 6, 7][X, X, X, X, X]

1st call to rand() => 13
    → 13 is not in the bucket-range anymore (>= limit), while-condition is true
        → retry...
2nd call to rand() => 7
    → 7 is in the bucket-range (< limit), while-condition is false
        → Get the corresponding bucket-value 1 (randVal % range) and add begin
    => 3

ライアンは正しいですが、解はランダム性の原因について知られていることに基づいてはるかに単純になる可能性があります。問題を再度述べるには：

• 乱数の発生源があり、範囲内の整数[0, MAX)を均一な分布で出力します。
• 目標は、の範囲[rmin, rmax]で一様に分布するランダムな整数を生成すること0 <= rmin < rmax < MAXです。

ビン（または「ボックス」）の数は、元の番号の範囲、より著しく小さい場合私の経験では、と元のソース暗号的に強いです-すべてがrigamaroleを通過する必要がない、とシンプルなモジュロ除算だろう（output = rnd.next() % (rmax+1)ifのようにrmin == 0）十分であり、速度を失うことなく、「十分」に均一に分布する乱数を生成します。重要な要素はランダム性のソースです（つまり、子供たち、これを自宅で試してはいけませんrand()）。

これが実際にどのように機能するかの例/証明です。1から22までの乱数を生成したかったのですが、（Intel RDRANDに基づいて）ランダムなバイトを生成する暗号的に強力なソースがあります。結果は次のとおりです。

Rnd distribution test (22 boxes, numbers of entries in each box):     
 1: 409443    4.55%
 2: 408736    4.54%
 3: 408557    4.54%
 4: 409125    4.55%
 5: 408812    4.54%
 6: 409418    4.55%
 7: 408365    4.54%
 8: 407992    4.53%
 9: 409262    4.55%
10: 408112    4.53%
11: 409995    4.56%
12: 409810    4.55%
13: 409638    4.55%
14: 408905    4.54%
15: 408484    4.54%
16: 408211    4.54%
17: 409773    4.55%
18: 409597    4.55%
19: 409727    4.55%
20: 409062    4.55%
21: 409634    4.55%
22: 409342    4.55%   
total: 100.00%

これは、私が必要とする限り、ユニフォームに近いです（公正なサイコロの投げ、http：//users.telenet.be/d.rijmenants/en/kl-7sim.htmなどの第二次世界大戦の暗号マシン用の暗号的に強力なコードブックの生成など） ）。出力には、かなりの偏りはありません。

暗号学的に強力な（真の）乱数ジェネレーターのソースは次のとおりです： インテルデジタル乱数ジェネレーター と64ビット（符号なし）乱数を生成するサンプルコード。

int rdrand64_step(unsigned long long int *therand)
{
  unsigned long long int foo;
  int cf_error_status;

  asm("rdrand %%rax; \
        mov $1,%%edx; \
        cmovae %%rax,%%rdx; \
        mov %%edx,%1; \
        mov %%rax, %0;":"=r"(foo),"=r"(cf_error_status)::"%rax","%rdx");
        *therand = foo;
  return cf_error_status;
}

Mac OS Xでclang-6.0.1（ストレート）を使用してコンパイルし、gcc-4.8.3で "-Wa、q"フラグを使用してコンパイルしました（GASはこれらの新しい命令をサポートしていないため）。

前に述べたように、モジュロは分布を歪めるので十分ではありません。ビットをマスクして、分布が歪んでいないことを確認するためにそれらを使用する私のコードを示します。

static uint32_t randomInRange(uint32_t a,uint32_t b) {
    uint32_t v;
    uint32_t range;
    uint32_t upper;
    uint32_t lower;
    uint32_t mask;

    if(a == b) {
        return a;
    }

    if(a > b) {
        upper = a;
        lower = b;
    } else {
        upper = b;
        lower = a; 
    }

    range = upper - lower;

    mask = 0;
    //XXX calculate range with log and mask? nah, too lazy :).
    while(1) {
        if(mask >= range) {
            break;
        }
        mask = (mask << 1) | 1;
    }


    while(1) {
        v = rand() & mask;
        if(v <= range) {
            return lower + v;
        }
    }

}

次の簡単なコードで、分布を確認できます。

int main() {

    unsigned long long int i;


    unsigned int n = 10;
    unsigned int numbers[n];


    for (i = 0; i < n; i++) {
        numbers[i] = 0;
    }

    for (i = 0 ; i < 10000000 ; i++){
        uint32_t rand = random_in_range(0,n - 1);
        if(rand >= n){
            printf("bug: rand out of range %u\n",(unsigned int)rand);
            return 1;
        }
        numbers[rand] += 1;
    }

    for(i = 0; i < n; i++) {
        printf("%u: %u\n",i,numbers[i]);
    }

}

[0,1]の範囲の浮動小数点数を返します。

#define rand01() (((double)random())/((double)(RAND_MAX)))