拒绝抽样（例如在您的解决方案中）是第一个想到的事情，即您构建一个查找表，其中包含按权重分布填充的元素，然后在表中随机选择一个位置并返回它。作为一种实现选择，我会创建一个高阶函数，它接受一个规范并返回一个函数，该函数根据规范中的分布返回值，这样您就不必为每次调用构建表。缺点是构建表格的算法性能与项目数量呈线性关系，并且对于大型规范（或那些具有非常小或精确权重的成员，例如 {0:0.99999, 1 :0.00001})。好处是选择一个值有恒定的时间，如果性能至关重要，这可能是可取的。在 JavaScript 中：

function weightedRand(spec) {
  var i, j, table=[];
  for (i in spec) {
    // The constant 10 below should be computed based on the
    // weights in the spec for a correct and optimal table size.
    // E.g. the spec {0:0.999, 1:0.001} will break this impl.
    for (j=0; j<spec[i]*10; j++) {
      table.push(i);
    }
  }
  return function() {
    return table[Math.floor(Math.random() * table.length)];
  }
}
var rand012 = weightedRand({0:0.8, 1:0.1, 2:0.1});
rand012(); // random in distribution...

另一种策略是选择一个随机数[0,1)并迭代权重规范求和，如果随机数小于总和，则返回相关值。当然，这假设权重总和为 1。该解决方案没有前期成本，但平均算法性能与规范中的条目数量呈线性关系。例如，在 JavaScript 中：

function weightedRand2(spec) {
  var i, sum=0, r=Math.random();
  for (i in spec) {
    sum += spec[i];
    if (r <= sum) return i;
  }
}
weightedRand2({0:0.8, 1:0.1, 2:0.1}); // random in distribution...

生成一个介于 0 和 1 之间的随机数 R。

如果 R 在 [0, 0.1) -> 1

如果 R 在 [0.1, 0.2) -> 2

如果 R 在 [0.2, 1] -> 3

如果您不能直接获得 0 到 1 之间的数字，请生成一个范围内的数字，该数字将产生所需的精度。例如，如果你有权重

(1, 83.7%) 和 (2, 16.3%) 掷出一个从 1 到 1000 的数字。1-837 是 1。838-1000 是 2。

我使用以下

function weightedRandom(min, max) {
  return Math.round(max / (Math.random() * max + min));
}

这是我的首选“加权”随机数，我使用“x”的反函数（其中 x 是最小值和最大值之间的随机数）来生成加权结果，其中最小值是最重的元素，最大值是最轻（获得结果的机会最小）

所以基本上，使用weightedRandom(1, 5)意味着获得 1 的机会高于 2，高于 3，高于 4，高于 5。

可能对您的用例没有用，但可能对谷歌搜索同样问题的人有用。

经过 100 次迭代尝试，它给了我：

==================
| Result | Times |
==================
|      1 |    55 |
|      2 |    28 |
|      3 |     8 |
|      4 |     7 |
|      5 |     2 |
==================

这里有 3 种 javascript 解决方案，因为我不确定您想要哪种语言。根据您的需要，前两种中的一种可能有效，但第三种可能最容易用大量数字实现。

function randomSimple(){
  return [0,0,0,0,0,0,0,0,1,2][Math.floor(Math.random()*10)];
}

function randomCase(){
  var n=Math.floor(Math.random()*100)
  switch(n){
    case n<80:
      return 0;
    case n<90:
      return 1;
    case n<100:
      return 2;
  }
}

function randomLoop(weight,num){
  var n=Math.floor(Math.random()*100),amt=0;
  for(var i=0;i<weight.length;i++){
    //amt+=weight[i]; *alternative method
    //if(n<amt){
    if(n<weight[i]){
      return num[i];
    }
  }
}

weight=[80,90,100];
//weight=[80,10,10]; *alternative method
num=[0,1,2]

这或多或少是@trinithis 在 Java 中编写的内容的通用版本：我使用整数而不是浮点数来完成它以避免混乱的舍入错误。

static class Weighting {

    int value;
    int weighting;

    public Weighting(int v, int w) {
        this.value = v;
        this.weighting = w;
    }

}

public static int weightedRandom(List<Weighting> weightingOptions) {

    //determine sum of all weightings
    int total = 0;
    for (Weighting w : weightingOptions) {
        total += w.weighting;
    }

    //select a random value between 0 and our total
    int random = new Random().nextInt(total);

    //loop thru our weightings until we arrive at the correct one
    int current = 0;
    for (Weighting w : weightingOptions) {
        current += w.weighting;
        if (random < current)
            return w.value;
    }

    //shouldn't happen.
    return -1;
}

public static void main(String[] args) {

    List<Weighting> weightings = new ArrayList<Weighting>();
    weightings.add(new Weighting(0, 8));
    weightings.add(new Weighting(1, 1));
    weightings.add(new Weighting(2, 1));

    for (int i = 0; i < 100; i++) {
        System.out.println(weightedRandom(weightings));
    }
}