java随机百分比

Question

我需要生成 n 个百分比（0 到 100 之间的整数），使得所有 n 个数字的总和为 100。

如果我只做nextInt() n 次，每次确保参数是 100 减去之前累积的总和，那么我的百分比是有偏差的（即第一个生成的数字通常是最大的等等.)。我该如何以公正的方式做到这一点？

Answer 1

一些答案​​建议选择随机百分比并获取它们之间的差异。正如 Nikita Ryback 指出的那样，这不会给出所有可能性的均匀分布；特别是，零的频率将低于预期。

要解决此问题，请考虑从 100“百分比”开始并插入分隔线。我将展示一个 10 的示例：

 % % % % % % % % % 

我们可以在十一个地方插入分隔符：在任意两个百分比之间或开头或结尾。所以插入一个：

 % % % % / % % % % % % 

这代表选择四和六。现在插入另一个分隔线。这一次，有十二个地方，因为已经插入的分隔线创建了一个额外的地方。具体有两种获取方式

 % % % % // % % % % % % 

在前一个分隔符之前或之后插入。您可以继续该过程，直到您拥有所需数量的分隔符（比百分比数少一个）。

 % % / % / % / / % % % / % % % / 

这对应于 2,1,1,0,3,3,0。

我们可以证明这给出了均匀分布。 100的组合数分成k份就是二项式系数100+k-1选k-1。那是 (100+k-1)(100+k-2)...101 / (k-1)(k-2)*...*2* 1 因此，选择任何特定组合的概率是这个的倒数。当我们一次插入一个分隔符时，首先我们从 101 个位置中进行选择，然后是 102、103 等，直到达到 100+k-1。所以任何特定插入序列的概率是 1 / (100+k-1)*...*101。多少个插入序列产生相同的组成？最终组合包含 k-1 个分隔符。它们可以按任何顺序插入，所以有 (k-1)！产生给定构图的序列。所以任何特定组合的概率正是它应该是的。

在实际代码中，您可能不会这样表示您的步骤。您应该能够只保留数字，而不是百分比和分隔符的序列。这个算法的复杂度我还没想过。

Answer 2

生成 n 个任意范围的随机整数（称它们为 a[1]..a[n]）。总结你的整数并称之为b。您的百​​分比将为[a[1]/b, ..., a[n]/b]。

编辑：好点，将结果四舍五入到总计 100 是不平凡的。一种方法是在1..n 中为x 取a[x]/b 作为整数，然后随机分配剩余的单位100-(sum of integers)。我不确定这是否会给结果带来任何偏见。

Answer 3

您可能需要定义“有偏见”的真正含义 - 但如果您只关心数字的分布与其位置无关，那么您可以简单地以“有偏见”的方式创建数字并且然后随机化他们的位置。

另一种“不偏不倚”的方法是创建 n-1 个随机百分比，对它们进行排序（称为 x1 x2 x3...），然后将最终百分比定义为：

x1
x2 - x1
x3 - x2
...
100 - x(n-1)

这样你会得到 n 个加到 100 的随机数。

Answer 4

这个问题被称为单纯形的均匀采样，维基百科提供了两种算法：

http://en.wikipedia.org/wiki/Simplex#Random_sampling

另请参阅以下相关问题：

• Sample uniformly at random from an n-dimensional unit simplex
• Generating a probability distribution

Answer 5

关键是要生成 N 个介于 0 和 100 之间的随机数，但要使用这些作为“标记”而不是要输出的最终数字序列。然后按升序遍历标记列表，计算每个百分比以输出为（当前标记 - 前一个标记）。

与简单地一次生成和输出每个数字相比，这将提供更均匀的分布。

示例

import java.util.Random;
import java.util.TreeSet;
import java.util.SortedSet;

public class Main {
  public static void main(String[] args) {
    Random rnd = new Random();
    SortedSet<Integer> set = new TreeSet<Integer>();

    for (int i=0; i<9; ++i) {
      set.add(rnd.nextInt(101));
    }

    if (set.last() < 100) {
      set.add(100);
    }    

    int prev = 0;
    int total = 0;    
    int output;

    for (int j : set) {
      output = j - prev;
      total += output;
      System.err.println(String.format("Value: %d, Output: %d, Total So Far: %d", j, output, total));
      prev = j;
    }
  }
}

输出

$ java Main
Value: 0, Output: 0, Total So Far: 0
Value: 2, Output: 2, Total So Far: 2
Value: 55, Output: 53, Total So Far: 55
Value: 56, Output: 1, Total So Far: 56
Value: 57, Output: 1, Total So Far: 57
Value: 69, Output: 12, Total So Far: 69
Value: 71, Output: 2, Total So Far: 71
Value: 80, Output: 9, Total So Far: 80
Value: 92, Output: 12, Total So Far: 92
Value: 100, Output: 8, Total So Far: 100

Answer 6

制作一个数组。将 100% 随机放入该数组的每个部分。 示例显示 n=7。

import java.util.Random;

public class random100 {
    public static void main (String [] args) {
        Random rnd = new Random();
            int percents[] = new int[7];
            for (int i = 0; i < 100; i++) {
                int bucket = rnd.nextInt(7);
                percents[bucket] = percents[bucket] + 1;
            }
        for (int i = 0; i < 7; i++) {
            System.out.println("bucket " + i + ": " + percents[i]);
        }

    }

}

Answer 7

确切地说，这取决于您希望样本如何不偏不倚。这是一个粗略的方法，大致会给你一个很好的结果。

1. 从 0,..100 生成 n-1 整数，例如 a[i] 为 i = 0, to n-2。
2. 让total 是这些数字的总和
3. 为i = 0, to n-2 计算b[i] = floor(100*a[i]/total)
4. 设置b[n-1] = 100 - (b[0] + ... b[n-2])。

那么 b 就是你得到的百分比数组。

最后一个会有偏差，但其余的应该是统一的。

当然，如果您想以更准确的方式执行此操作，则必须使用 Gibbs 采样或 Metropolis hastings。

Answer 8

使用您描述的方法选择数字后，将数字的顺序打乱。这样，最终的数字列表分布更均匀。

但是，请注意，无论您做什么，都无法获得完美均匀的分布，因为一旦您开始选择数字，您的随机试验就不是独立的。请参阅ataylor 的答案。 p>

另请注意，您描述的算法可能无法为您提供所需的输出。最后一个数字不能是随机的，因为它必须使总和等于 100。

Answer 9

首先，显而易见的解决方案。

do
    int[] a = new int[n];
    for (int i = 0; i < n; ++i) {
        a[i] = random number between 0 and 100;
    }
until sum(a) == 100;

它在复杂性方面并不完美（达到总和 100 的迭代次数可能非常大），但分布肯定是“无偏的”。

编辑
类似的问题：如何在半径为 1 且中心在 (0, 0) 的圆中生成随机点？解决方案：继续在范围（正方形）[-1..1,-1..1] 中生成随机点，直到其中一个适合圆圈:)

Answer 10

我遇到了类似的问题，最终按照你说的做，生成随机整数，直到现有整数之和与限制之差。然后我随机化了整数的顺序。它工作得很好。那是为了遗传算法。

Answer 11

假设您有 100 块石头和 N 个桶来放置它们。您可以将所有 100 块石头放入随机桶中。这样，总数将是您开始时的 100，并且任何存储桶之间都不会存在偏差。

public static int[] randomBuckets(int total, int n_buckets) {
    int[] buckets = new int[n_buckets];
    Random rand = new Random();
    for(int i=0;i<total;i++)
        buckets[rand.nextInt(n_buckets)]++;
    return buckets;
}

public static void main(String... args) {
    for(int i=2; i<=10;i++)
        System.out.println(Arrays.toString(randomBuckets(100, i)));
}

打印

[55, 45]
[38, 34, 28]
[22, 21, 32, 25]
[28, 24, 18, 15, 15]
[17, 14, 13, 21, 18, 17]
[17, 19, 14, 15, 6, 15, 14]
[11, 14, 14, 14, 4, 17, 9, 17]
[13, 12, 15, 12, 8, 10, 9, 11, 10]
[11, 13, 12, 6, 6, 11, 13, 3, 15, 10]

随着计数的增加，分布趋于均匀。

System.out.println(Arrays.toString(randomBuckets(100000000, 100)));

打印

[1000076, 1000612, 999600, 999480, 998226, 998303, 1000528, 1000450, 999529, 
998480, 998903, 1002685, 999230, 1000631, 1001171, 997757, 1000349, 1000527, 
1002408, 1000852, 1000450, 999318, 999453, 1000099, 1000759, 1000426, 999404, 
1000758, 1000939, 999950, 1000493, 1001396, 1001007, 999258, 1001709, 1000593,
1000614, 1000667, 1000168, 999448, 999350, 1000479, 999991, 999778, 1000513, 
998812, 1001295, 999314, 1000738, 1000211, 999855, 999349, 999842, 999635, 
999301, 1001707, 998224, 1000577, 999405, 998760, 1000036, 1000110, 1002471, 
1000234, 1000975, 998688, 999434, 999660, 1001741, 999834, 998855, 1001009, 
999523, 1000207, 998885, 999598, 998375, 1000319, 1000660, 1001727, 1000546, 
1000438, 999815, 998121, 1001128, 1000191, 998609, 998535, 999617, 1001895, 
999230, 998968, 999844, 999392, 999669, 999407, 998380, 1000732, 998778, 1000522]

Answer 12

这是我为正在创建的程序编写的一些代码。我在尝试解决这个确切问题时发现了这个线程，所以希望这对其他人有帮助。该设计基于阅读上面的@eruonna 回复。

public static int[] randomNumbers(int numOfNumbers){

    int percentN = numOfNumbers;

    int[] intArray = new int[101];

    //set up the array with values
    for(int i = 0; i < intArray.length; i++){
        intArray[i] = i;
    }

    //set up an array to hold the selected values
    int[] selectionArray = new int[(percentN - 1)];

    //run a for loop to go through and select random numbers from the intArray
    for(int n = 0; n < selectionArray.length; n++){
        int randomNum = (int)(Math.random() * 100);
        selectionArray[n] = intArray[randomNum];
    }

    //bubble sort the items in the selectionArray
    for(int out = (selectionArray.length - 1); out > 1; out--){
        for(int in = 0; in < out; in++){
            if(selectionArray[in] > selectionArray[in + 1]){
                int temp = selectionArray[in];
                selectionArray[in] = selectionArray[in + 1];
                selectionArray[in + 1] = temp;
            }
        }
    }

    //create an array to hold the calculated differences between each of the values to create random numbers
    int[] calculationArray = new int[percentN];

    //calculate the difference between the first item in the array and 0
    calculationArray[0] = (selectionArray[0] - 0);

    //calculate the difference between the other items in the array (except for the last value)
    for(int z = 1; z < (calculationArray.length - 1); z++){
        calculationArray[z] = (selectionArray[z] - selectionArray[z - 1]);
    }

    //calculate the difference for the last item in the array
    calculationArray[(calculationArray.length - 1)] = (100 - selectionArray[(selectionArray.length - 1)]);

    return calculationArray;

}