生成和为常数的随机数

Question

我在想，是否有办法生成一组随机数，其和总是一个常数。例如，20可以被划分为5个数字（1，2，3，4，10）。我不在乎这5个数字中的每一个是什么，只要它们的和等于20。有任何方法可以通过编程实现吗？

Answer 1

这是一个小技巧，但仍然：）
我提出这是一种可能的想法，并不是说它是最好的
（大多数情况下，您需要整数，所以它无论如何都不会工作）

如果所需的随机数不是所需的整数：
那么您可以在[0,1]之间生成N个随机数，然后将数组规范化为您的S：）

for(i=0; i<N; i++)
   arr[i] = rand;

cursum = 0;
for(i=0; i<N; i++)
   cursum+=arr[i];

norm = S / cursum;

for(i=0; i<N; i++)
    arr[i] *= norm;

Answer 2

这个方法完成了工作，并且还允许控制值之间的“差异度”(例如，如果您希望数组值彼此接近)

/**
     * Create array of positive integers which exactly sums to a given (integer) number.
     * @param {Number} number of items
     * @param {Number} sum  required sum
     * @param {Number} [d=100] difference degree between the values (0..100)
     */
    randomSumArray: function(len, sum, d) {
        var _sum = 0;
        var arr = [];
        var n, i;

        if (!d && d !== 0) {
            d = 100;
        }

        for (i = 0; i < len; i++) {
            var from = (100 - d) * 1000,
                to = (100 + d) * 1000,
                n = Math.floor(Math.random() * (to - from + 1) + from); //random integer between from..to

            _sum += n;
            arr.push(n);
        }

        var x = sum / _sum;

        _sum = 0; //count sum (again)
        for (var i = 0; i < len; i++) {
            arr[i] = Math.round(arr[i] * x);
            _sum += arr[i];
        }

        var diff = sum - _sum;

        // Correct the array if its sum does not match required sum (usually by a small bit)
        if (diff) {
            x = diff / Math.abs(diff); //x will be 1 or -1
            var j = 0;
            while (diff && j < 1000) { //limit to a finite number of 'corrections'
                i = Math.floor(Math.random() * (len + 1)); //random index in the array
                if (arr[i] + x >= 0) {
                    arr[i] += x;
                    diff -= x;
                }
                j++;
            }
        }

        return arr;
    }

Answer 3

要获得均匀分布，诀窍是将您的总和视为一条数线，而不是为段生成随机数，而是生成n-1个数作为沿线的点，然后相减以获得段。以下是ojrandlib中的函数:

static int compare(const void *a, const void *b) {
    return *(int*)a - *(int*)b;
}
void ojr_array_with_sum(ojr_generator *g, int *a, int count, int sum) {
    int i;
    for (i = 0; i < count-1; ++i) { a[i] = ojr_rand(g, sum+1); }
    qsort(a, count-1, sizeof(int), compare);
    a[count-1] = sum;
    for (i = count-1; i > 0; --i) { a[i] -= a[i-1]; }
}

ojr_rand（g，limit）生成一个从0到limit-1的统一随机整数。然后，该函数用计数随机整数填充数组a，这些随机整数加在和中。将其适应于任何其他RNG应该不会太难。