【问题标题】:random numbers from a small range without multiple repeats来自小范围的随机数,没有多次重复
【发布时间】:2020-08-11 10:05:31
【问题描述】:

我需要从一个很小的范围内生成随机数(有时只是 0-1,即抛硬币)。分布的准确性并不是特别重要,但我确实需要避免相同数量的长序列。

我尝试使用 C++11 std::uniform_int_distribution 生成随机数,虽然分布非常好,但它可以连续生成 15+ 个单个值的序列(请注意,我并不真正重新- 每次都为 RNG 播种)。

int randomInRange(int range)
{
    std::mt19937 rng(0);
    auto seed = std::random_device{}();
    rng.seed(seed);

    std::uniform_int_distribution<int> dist(0, range - 1);
    return dist(rng);
}

我构建了一个测试程序 (https://ideone.com/f9p0WJ),它表明它可以连续生成多达 18 个正面。我想将概率降低到超出均匀分布所给出的范围,例如将运行 3 的概率减半,而没有运行 5 的机会。

有没有通用的解决方案?我天真的解决方案是保留一些历史记录并在我检测到太长的序列时丢弃(概率

【问题讨论】:

  • 实际上,如果过程是真正随机的,则必须出现长运行(以适当的频率)。如果你人为地压制它们,你的数字就不会那么随机了(即更可预测)。
  • 从(0,0,0,0), (0,0,0,1), ..., (1,1,1,1) 生成所有可能的 4 元素运行表,从中删除足够的条目,其中运行 0,0,0 和 1,1,1 以满足您的概率要求。然后,从表中随机选择一个运行。如果它以1 结尾,则随机选择一个以0 开头的运行,重复直到你有一个序列,只要你需要。
  • @HighPerformanceMark 如果这样做,如果您以前看过这些数字,则可以准确预测每个第 4 个数字。
  • 您的意思是“16 个正面的运行比它们应该出现的频率更高”(大约 16000 分之一)还是“16 个正面的运行在任何情况下都不应该出现”?
  • @Henry 是的,我不担心随机性 - 避免长时间运行是更高的优先级。

标签: algorithm random


【解决方案1】:

正如@Henry 所说,您所追求的并不是纯粹的均匀分布。

为了强制执行您的约束,我认为最好的解决方案是在您的随机数生成器中包含一个衰减因子。随着数字序列的增加,该数字接下来出现的概率会降低。

我在python 3中实现了一些原型代码,因为我的cpp技能目前有点生疏,但基本概念很容易翻译成cpp。这里是:

def my_random(range: int, iterations: int, decay_rate :float = 2) -> List[int]:
    assert range > 0, "`range` must be a positive non-zero integer"

    if range == 1: 
        return [0] * iterations

    last_num: int = 0
    last_prob: float = 1/range
    
    rand_num_lst: List[int] =  []
    while iterations > 0:
        rnd = random() # generates a random number: 0 <= rnd < 1
        if rnd < last_prob:
            num = last_num
            last_prob /= decay_rate
            
        else:
            # The `int` function is converting the float into integer by 
            #    flooring the number
            num = int( (rnd - last_prob) / (1 - last_prob) * (range - 1) )
            
            if num >= last_num:
                num += 1
            
            last_num = num
            last_prob = 1/range/decay_rate
        
        rand_num_lst.append(num)
        iterations -= 1
        
    return rand_num_lst

请注意,在 Python3 中默认除法是浮点除法,这意味着 1/2 = 0.5 而不是在 Python2 中发生的 1/2 = 0。

我进行了一些测试来检查最大序列长度以及由此生成的数字分布是否仍然均匀分布,并且它似乎继续保持这些属性:

以range = 2 和不同的衰减率运行:

decay_rate: 2.00000 max sequence length:  6 number count: {0: 499830, 1: 500170}
decay_rate: 1.50000 max sequence length:  6 number count: {0: 499455, 1: 500545}
decay_rate: 1.25000 max sequence length:  9 number count: {0: 500241, 1: 499759}
decay_rate: 1.12500 max sequence length: 11 number count: {0: 499799, 1: 500201}
decay_rate: 1.06250 max sequence length: 14 number count: {0: 500655, 1: 499345}
decay_rate: 1.03125 max sequence length: 16 number count: {0: 500495, 1: 499505}
decay_rate: 1.01562 max sequence length: 16 number count: {0: 500010, 1: 499990}
decay_rate: 1.00781 max sequence length: 18 number count: {0: 499748, 1: 500252}
decay_rate: 1.00391 max sequence length: 18 number count: {0: 499987, 1: 500013}
decay_rate: 1.00195 max sequence length: 21 number count: {0: 499503, 1: 500497}
decay_rate: 1.00098 max sequence length: 21 number count: {0: 500495, 1: 499505}
decay_rate: 1.00000 max sequence length: 19 number count: {0: 499451, 1: 500549}

以range = 5 和不同的衰减率运行:

decay_rate: 2.00000 max sequence length:  5 number count: {0: 200314, 1: 199245, 2: 200213, 3: 199962, 4: 200266}
decay_rate: 1.50000 max sequence length:  5 number count: {0: 199372, 1: 199829, 2: 199937, 3: 200527, 4: 200335}
decay_rate: 1.25000 max sequence length:  6 number count: {0: 199373, 1: 199784, 2: 200561, 3: 200062, 4: 200220}
decay_rate: 1.12500 max sequence length:  8 number count: {0: 199752, 1: 199931, 2: 200579, 3: 200287, 4: 199451}
decay_rate: 1.06250 max sequence length:  8 number count: {0: 199280, 1: 200286, 2: 199688, 3: 200446, 4: 200300}
decay_rate: 1.03125 max sequence length:  8 number count: {0: 199577, 1: 199582, 2: 200652, 3: 199870, 4: 200319}
decay_rate: 1.01562 max sequence length:  9 number count: {0: 200442, 1: 199916, 2: 200142, 3: 199729, 4: 199771}
decay_rate: 1.00781 max sequence length:  9 number count: {0: 199784, 1: 200544, 2: 199921, 3: 199557, 4: 200194}
decay_rate: 1.00391 max sequence length:  9 number count: {0: 199920, 1: 199054, 2: 200303, 3: 200833, 4: 199890}
decay_rate: 1.00195 max sequence length:  9 number count: {0: 200011, 1: 200530, 2: 199806, 3: 200321, 4: 199332}
decay_rate: 1.00098 max sequence length: 10 number count: {0: 199741, 1: 199861, 2: 199822, 3: 200081, 4: 200495}
decay_rate: 1.00000 max sequence length:  9 number count: {0: 199717, 1: 199184, 2: 200182, 3: 200891, 4: 200026}

当然,您可以明确地编写如下代码:如果运行序列的长度大于X,则忽略该数字并生成与最后一个随机数不同的数字。虽然我不确定这种方法是否会继续均匀分布。

【讨论】:

  • 我认为这是最好的解决方案(在刚刚接受有时可能会发生的事情之后),但您应该指出,这些长期运行仍然是可能的,尽管比以前更不可能。跨度>
  • @tobias_k 添加了我运行的一些测试
  • 谢谢,这很好用。这是我的 C++ 实现(与标准 C++11 随机数分布具有相同的接口)和改进的测试代码。 ideone.com/40f0Ry
  • @HamishMoffatt Python3 中没有,默认的除法是浮点除法。在 Python2 中,它会产生一个 int ya。我会把它添加到答案中:)
  • @HamishMoffatt Ups,已更正!我编码的环境实际上并没有检查/强制执行类型。我写它们是为了让你更容易理解发生了什么。
【解决方案2】:

这是我对@MkWTF 答案的 C++ 实现,其接口与 C++11 std::uniform_int_distribution 兼容。 (它需要 reset() 和其他方法才能成为完整的 C++11 RandomNumberDistribution。)

#include <random>

class decaying_sequence_distribution
{
private:
    const int min;
    const int range;
    const double decay_rate;
 
    std::uniform_real_distribution<> dist{0., 1.};
    int last_num;
    double last_prob;
 
public:
    decaying_sequence_distribution(int min_, int max_, double decay_rate_ = 2.)
        : min(min_)
        , range(max_ - min_ + 1)
        , decay_rate(decay_rate_)
        , last_num(min_)
        , last_prob(1. / range)
        {
        }
 
    template<class Generator>
    int operator()(Generator& g)
    {
        int num;
        double rnd = dist(g);
        if (rnd < last_prob)
        {
            num = last_num;
            last_prob /= decay_rate;
        }
        else
        {
            num = static_cast<int>( (rnd - last_prob) / (1 - last_prob) * (range - 1) );
 
            if (num >= last_num)
                num += 1;
 
            last_num = num;
            last_prob = 1./range/decay_rate;
        }
 
        return num + min;
    }
};

【讨论】:

    猜你喜欢
    • 2019-08-09
    • 2013-04-17
    • 2012-10-10
    • 1970-01-01
    • 2011-02-27
    • 2013-11-07
    • 2013-02-14
    • 2017-02-13
    • 2018-04-22
    相关资源
    最近更新 更多