如何产生随机数，使它们的总和等于给定的数字？

Question

我想产生 X 个随机数，每个随机数来自区间 <0; Y>（给定 Y 作为每个数字的最大值），但有限制，这些数字的总和必须等于 Z。

示例： 5个随机数，每个最多6个，总和必须等于14，例如：0, 2, 6, 4, 2

是否已经有可以做类似事情的 C/C++ 函数？

就我个人而言，我只能想出一些丑陋的 if-else-constructs。

Answer 1

由于您不需要生成的序列是统一的，这可能是可能的解决方案之一：

#include <iostream>
#include <vector>
#include <cstdlib>

int irand(int min, int max) {
    return ((double)rand() / ((double)RAND_MAX + 1.0)) * (max - min + 1) + min;
}

int main()
{
    int COUNT = 5,    // X
        MAX_VAL = 6,  // Y
        MAX_SUM = 14; // Z

    std::vector<int> buckets(COUNT, 0);
    srand(time(0));
    int remaining = MAX_SUM;
    while (remaining > 0)
    {
        int rndBucketIdx = irand(0, COUNT-1);
        if (buckets[rndBucketIdx] == MAX_VAL)
            continue;                       // this bucket is already full
        buckets[rndBucketIdx]++;
        remaining--;
    }

    std::cout << "Printing sequence: "; 
    for (size_t i = 0; i < COUNT; ++i)
        std::cout << buckets[i] << ' ';
}

它只是简单地将总和分成一堆桶，直到它消失:)

输出示例：Printing sequence: 4 4 1 0 5

Answer 2

注意：此解决方案是在问题指定“MAX SUM”参数时编写的，这意味着小于该数量的总和同样可以接受。该问题现在已根据 OP 的评论进行了编辑，他们表示累积总和必须实际达到该目标。我不会更新此答案，但显然它可以在最后一级递归中轻易丢弃较小的总数。

此解决方案一次性填充 vector<vector<int>> 并使用所有可能的数字组合来解决输入标准，然后每次需要新的解决方案时，它都会随机选择其中一个并将数字打乱顺序（从而选择组合的排列）。

它有点重——也许不适合你在我开始写它之后提到的实际用途；-P——但它产生了一个均匀加权分布，并且您可以轻松地做一些事情，例如保证在返回所有其他组合之前不会再次返回组合（带有支持的组合索引的混洗向量）。

#include <iostream>
#include <vector>
#include <algorithm>

using std::min;
using std::max;
using std::vector;

// print solutions...    
void p(const vector<vector<int>>& vvi)
{
    for (int i = 0; i < vvi.size(); ++i)
    {
        for (int j = 0; j < vvi[i].size(); ++j)
            std::cout << vvi[i][j] << ' ';
        std::cout << '\n';
    }
}

// populate results with solutions...
void f(vector<vector<int>>& results, int n, int max_each, int max_total)
{
    if (n == 0) return;
    if (results.size() == 0)
    {
        for (int i = 0; i <= min(max_each, max_total); ++i)
             results.push_back(vector<int>(2, i));
        f(results, n - 1, max_each, max_total);
        return;
    }

    vector<vector<int>> new_results;

    for (int r = 0; r < results.size(); ++r)
    {
        int previous = *(results[r].rbegin() + 1);
        int current_total = results[r].back();
        int remaining = max_total - current_total;
        for (int i = 0; i <= min(previous,min(max_each, remaining)); ++i)
        {
            vector<int> v = results[r];
            v.back() = i;
            v.push_back(current_total + i);
            new_results.push_back(v);
        }
    }
    results = new_results;
    f(results, n - 1, max_each, max_total);
}

const vector<int>& once(vector<vector<int>>& solutions)
{
    int which = std::rand() % solutions.size();
    vector<int>& v = solutions[which];
    std::random_shuffle(v.begin(), v.end() - 1);
    return v;
}

int main()
{
    vector<vector<int>> solutions;
    f(solutions, 5, 6, 14);
    std::cout << "All solution combinations...\n";
    p(solutions);
    std::cout << "------------------\n";
    std::cout << "A few sample permutations...\n";
    for (int n = 1; n <= 100; ++n)
    {
        const vector<int>& o = once(solutions);
        for (int i = 0; i < o.size() - 1; ++i)
            std::cout << o[i] << ' ';
        std::cout << '\n';
    }
}

Answer 3

#include<iostream>
#include <cstdlib> //rand ()
using namespace std;

void main()
{
    int random ,x=5;
    int max , totalMax=0 , sum=0;
    cout<<"Enter the total maximum number : ";
    cin>>totalMax;
    cout<<"Enter the maximum number: ";
    cin>>max;
    srand(0);
    for( int i=0; i<x ; i++)
    {

        random=rand()%max+1; //range from 0 to max
        sum+=random;
        if(sum>=totalMax)
        {
            sum-=random;
            i--;
        }
        else
        cout<<random<<' ';
    }
    cout<<endl<<"Reached total maximum number "<<totalMax<<endl; 


}

我写了这个简单的代码
我使用 totalMax=14 和 max=3 对其进行了测试，它对我有用 希望这是你要求的

Answer 4

LiHo 的回答看起来与我的第二个建议非常相似，所以我将保留它，但这里是第一个的示例。它可能可以改进，但它不应该有任何悲惨的错误。 Here's a live sample.

#include <algorithm>
#include <array>
#include <random>

std::random_device rd;
std::mt19937 gen(rd());

constexpr int MAX = 14;
constexpr int LINES = 5;

int sum{};
int maxNum = 6;
int minNum{};

std::array<int, LINES> nums;

for (int i = 0; i < LINES; ++i) {
    maxNum = std::min(maxNum, MAX - sum);

    // e.g., after 0 0, min is 2 because only 12/14 can be filled after
    int maxAfterThis = maxNum * (LINES - i - 1);
    minNum = std::min(maxNum, std::max(minNum, MAX - sum - maxAfterThis));
    
    std::uniform_int_distribution<> dist(minNum, maxNum);
    int num = dist(gen);
    
    nums[i] = num;
    sum += num;
}

std::shuffle(std::begin(nums), std::end(nums), gen);

每次创建该分布可能会减慢它的速度（我不知道），但范围必须在构造函数中进行，我并不是说这些数字的分布情况如何。但是，逻辑非常简单。除此之外，它还使用了漂亮、闪亮的 C++11 <random> 标头。

我们只是确保没有剩余的数字超过 MAX (14) 并且最后达到 MAX。 minNum 是奇怪的部分，这是由于它的进展方式。它从零开始并根据需要逐步上升（std::max 的第二部分正在计算如果我们得到 6s 剩下的部分需要什么），但我们不能让它超过 maxNum。如果存在minNum，我愿意接受更简单的计算方法。

Answer 5

由于您知道需要多少个数字，因此可以根据给定分布生成它们，但无需其他条件，存储它们，计算实际总和，然后按比例放大/缩小它们以获得所需的总和。