4

我们知道经典的范围随机函数是这样的：

public static final int random(final int min, final int max) {
    Random rand = new Random();
    return min + rand.nextInt(max - min + 1);  // +1 for including the max
}

我想创建算法函数以在 1..10 之间的范围内随机生成数字，但可能性不均匀，例如：
1) 1,2,3 -> 3/6 (1/2)
2) 4,5,6,7 -> 1/6
3) 8,9,10 -> 2/6 (1/3)

上面的意思是函数有 1/2 的机会返回 1 到 3 之间的数字，1/6 的机会返回 4 到 7 之间的数字，以及 1/3 的机会返回 8 到 10 之间的数字。

有人知道算法吗？

更新：
实际上 1..10 之间的范围仅作为示例。我要创建的函数适用于任何数字范围，例如：1..10000，但规则仍然相同：3/6 用于顶部范围（30% 部分），1/6 用于中间范围（下一个40% 部分），底部范围的 2/6（最后 30% 部分）。

4

6 回答 6

6

Use the algorithm:

int temp = random(0,5);
if (temp <= 2) {
  return random(1,3);
} else if (temp <= 3) {
 return random(4,7);
} else  {
 return random(8,10);
}

This should do the trick.

EDIT: As requested in your comment:

int first_lo = 1, first_hi = 3000; // 1/2 chance to choose a number in [first_lo, first_hi]
int second_lo = 3001, second_hi = 7000; // 1/6 chance to choose a number in [second_lo, second_hi] 
int third_lo = 7001, third_hi = 10000;// 1/3 chance to choose a number in [third_lo, third_hi] 
int second
int temp = random(0,5);
if (temp <= 2) {
  return random(first_lo,first_hi);
} else if (temp <= 3) {
 return random(second_lo,second_hi);
} else  {
 return random(third_lo,third_hi);
}
于 2012-04-26T09:20:33.307 回答
3

您可以使用所需的密度填充所需数字的数组，然后生成随机索引并获取相应的元素。我认为它更快一点，但它可能并不那么重要。类似的东西，这不是正确的解决方案，只是一个例子：

1,1,1,2,2,2,3,3,3,4,5,6 ...

或者您可以先使用 if 语句定义域，然后从该域生成一个简单的数字。

int x = random(1,6)
if (x < 4) return random(1, 3);
if (x < 5) return random(4, 7);
return random(8, 10);
于 2012-04-26T09:24:50.223 回答
2

掷出一个 72 面骰子以从以下阵列中进行选择：

// Each row represents 1/6 of the space
[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
 4, 4, 4, 5, 5, 5, 6, 6, 6, 7, 7, 7,
 8, 8, 8, 8, 8, 8, 8, 8, 9, 9, 9, 9,
 9, 9, 9, 9, 10, 10, 10, 10, 10, 10, 10, 10]
于 2012-04-26T09:27:55.573 回答
0

如果您使用整数，这可能会有所帮助：

您需要使用以下功能：

f : A -> B

B = [b0, b1] 表示您希望从随机数生成器中获得的值的范围

A = [b0, 2 * b1] 使得 f 的最后一个分支实际上到达 b1

f(x) = step((x / 3) , 
    f(x) is part of interval [b0, length(B)/3]
f(x) = step(x)  + E,   
    f(x) is part of interval [length(B) / 3, 2 * length(B) / 3],
    E is a constant that makes sure the function is continuous
f(x) = step(x / 2) + F,   
    f(x) is part of interval [2 * length(B) / 3, length(B)]
    F is a constant that makes sure the function is continuous

解释：在第一个分支上获得相同值需要比在第二个分支上多 3 倍的数字。因此，在第一个分支上获得数字的概率是第二个分支的 3 倍，其值从随机数生成器中均匀分布。这同样适用于第三个分支。

我希望这有帮助！

编辑：修改了间隔，你必须稍微调整一下，但这是我的一般想法。

于 2012-04-26T11:51:57.100 回答
0 
final int lut[] = [
  1, 1, 1,
  2, 2, 2,
  3, 3, 3,
  4,
  5,
  6,
  7,
  8, 8,
  9, 9,
  10, 10
];

int uneven_random = lut[random.nextInt(lut.length)];

或类似的规定...

于 2012-04-26T09:26:53.773 回答
0

根据要求，这是我的代码（基于 izomorphius 的代码），有望解决我的问题：

private static Random rand = new Random();

public static int rangeRandom(final int min, final int max) {
    return min + rand.nextInt(max - min + 1);  // +1 for including the max
}

/**
 * 
 * @param min           The minimum range number
 * @param max           The maximum range number
 * @param weights       Array containing distributed weight values. The sum of values must be 1.0 
 * @param chances       Array containing distributed chance values. The array length must be same with weights and the sum of values must be 1.0 
 * @return              Random number
 * @throws Exception    Probably should create own exception, but I use default Exception for simplicity
 */
public static int weightedRangeRandom(final int min, final int max, final float[] weights, final float[] chances) throws Exception {
    // some validations
    if (weights.length != chances.length) {
        throw new Exception("Length of weight & chance must be equal");
    }

    int len = weights.length;

    float sumWeight = 0, sumChance = 0;
    for (int i=0; i<len; ++i) {
        sumWeight += weights[i];
        sumChance += chances[i];
    }
    if (sumWeight != 1.0 || sumChance != 1.0) {
        throw new Exception("Sum of weight/chance must be 1.0");
    }

    // find the random number
    int tMin = min, tMax;
    int rangeLen = max - min + 1;

    double n = Math.random();
    float c = 0;
    for (int i=0; i<len; ++i) {
        if (i != (len-1)) {
            tMax = tMin + Math.round(weights[i] * rangeLen) - 1;
        }
        else {
            tMax = max;
        }

        c += chances[i];
        if (n < c) {
            return rangeRandom(tMin, tMax);
        }
        tMin = tMax + 1;
    }

    throw new Exception("You shouldn't end up here, something got to be wrong!");
}

使用示例：

int result = weightedRangeRandom(1, 10, new float[] {0.3f, 0.4f, 0.3f}, 
    new float[] {1f/2, 1f/6, 1f/3});

代码在分配子范围边界（tMin 和 tMax）时可能仍然不准确，因为按重量除法会导致十进制值。但我猜这是不可避免的，因为范围数是整数。

可能需要一些输入验证，但为了简单起见，我省略了。

批评，更正和评论非常欢迎:)

于 2012-04-27T10:19:24.897 回答