随机百分比分支的编码模式？ [英] Coding pattern for random percentage branching?
问题描述
因此，假设我们有一个代码块，我们希望执行70％的次数，另一次执行30％的次数。
So let's say we have a code block that we want to execute 70% of times and another one 30% of times.
if(Math.random() < 0.7)
70percentmethod();
else
30percentmethod();
足够简单。但是，如果我们希望它可以很容易地扩展到30％/ 60％/ 10％等怎么办？
这里需要添加和更改所有关于更改的if语句，这些语句使用起来不是很好，缓慢和错误诱导。
Simple enough. But what if we want it to be easily expandable to say, 30%/60%/10% etc.? Here it would require adding and changing all the if statements on change which isn't exactly great to use, slow and mistake inducing.
到目前为止我'我发现大型开关对这个用例非常有用，例如：
So far I've found large switches to be decently useful for this use case, for example:
switch(rand(0, 10)){
case 0:
case 1:
case 2:
case 3:
case 4:
case 5:
case 6:
case 7:70percentmethod();break;
case 8:
case 9:
case 10:30percentmethod();break;
}
可以很容易地改为：
switch(rand(0, 10)){
case 0:10percentmethod();break;
case 1:
case 2:
case 3:
case 4:
case 5:
case 6:
case 7:60percentmethod();break;
case 8:
case 9:
case 10:30percentmethod();break;
}
但这些也有它们的缺点，既麻烦又分成预定数量分区。
But these have their drawbacks as well, being cumbersome and split onto a predetermined amount of divisions.
理想的东西是基于频率数系统，我想是这样的：
Something ideal would be based on a "frequency number" system I guess, like so:
(1,a),(1,b),(2,c) -> 25% a, 25% b, 50% c
然后如果你又增加了一个：
then if you added another one:
(1,a),(1,b),(2,c),(6,d) -> 10% a, 10% b, 20% c, 60% d
所以简单地加上数字，使总和等于100％，然后拆分。
So simply adding up the numbers, making the sum equal 100% and then split that.
我想用自定义的hashmap或其他东西为它做一个处理程序不会那么麻烦，但我想知道是否有一些既定的方式/模式或lambda为它之前我去了所有的意大利面。
I suppose it wouldn't be that much trouble to make a handler for it with a customized hashmap or something, but I'm wondering if there's some established way/pattern or lambda for it before I go all spaghetti on this.
推荐答案
编辑：请参阅最后编辑以获得更优雅的解决方案。我会留下这个。
See edit at end for more elegant solution. I'll leave this in though.
您可以使用 NavigableMap 来存储映射到其百分比的这些方法。
You can use a NavigableMap to store these methods mapped to their percentages.
NavigableMap<Double, Runnable> runnables = new TreeMap<>();
runnables.put(0.3, this::30PercentMethod);
runnables.put(1.0, this::70PercentMethod);
public static void runRandomly(Map<Double, Runnable> runnables) {
double percentage = Math.random();
for (Map.Entry<Double, Runnable> entry : runnables){
if (entry.getKey() < percentage) {
entry.getValue().run();
return; // make sure you only call one method
}
}
throw new RuntimeException("map not filled properly for " + percentage);
}
// or, because I'm still practicing streams by using them for everything
public static void runRandomly(Map<Double, Runnable> runnables) {
double percentage = Math.random();
runnables.entrySet().stream()
.filter(e -> e.getKey() < percentage)
.findFirst().orElseThrow(() ->
new RuntimeException("map not filled properly for " + percentage))
.run();
}
NavigableMap 是按键排序排序（例如 HashMap 不保证条目），因此您可以获得按百分比排序的条目。这是相关的，因为如果你有两个项（3，r1），（7，r2），它们会产生以下条目： r1 = 0.3 和 r2 = 1.0 并且需要按此顺序进行评估（例如，如果以相反的顺序评估它们，结果将总是是 r2 ）。
The NavigableMap is sorted (e.g. HashMap gives no guarantees of the entries) by keys, so you get the entries ordered by their percentages. This is relevant because if you have two items (3,r1),(7,r2), they result in the following entries: r1 = 0.3 and r2 = 1.0 and they need to be evaluated in this order (e.g. if they are evaluated in the reverse order the result would always be r2).
至于拆分，它应该是这样的：
使用像这样的元组类
As for the splitting, it should go something like this: With a Tuple class like this
static class Pair<X, Y>
{
public Pair(X f, Y s)
{
first = f;
second = s;
}
public final X first;
public final Y second;
}
您可以创建这样的地图
// the parameter contains the (1,m1), (1,m2), (3,m3) pairs
private static Map<Double,Runnable> splitToPercentageMap(Collection<Pair<Integer,Runnable>> runnables)
{
// this adds all Runnables to lists of same int value,
// overall those lists are sorted by that int (so least probable first)
double total = 0;
Map<Integer,List<Runnable>> byNumber = new TreeMap<>();
for (Pair<Integer,Runnable> e : runnables)
{
total += e.first;
List<Runnable> list = byNumber.getOrDefault(e.first, new ArrayList<>());
list.add(e.second);
byNumber.put(e.first, list);
}
Map<Double,Runnable> targetList = new TreeMap<>();
double current = 0;
for (Map.Entry<Integer,List<Runnable>> e : byNumber.entrySet())
{
for (Runnable r : e.getValue())
{
double percentage = (double) e.getKey() / total;
current += percentage;
targetList.put(current, r);
}
}
return targetList;
}
并且所有这些都添加到了课程中
class RandomRunner {
private List<Integer, Runnable> runnables = new ArrayList<>();
public void add(int value, Runnable toRun) {
runnables.add(new Pair<>(value, toRun));
}
public void remove(Runnable toRemove) {
for (Iterator<Pair<Integer, Runnable>> r = runnables.iterator();
r.hasNext(); ) {
if (toRemove == r.next().second) {
r.remove();
break;
}
}
}
public void runRandomly() {
// split list, use code from above
}
}
编辑：
其实，以上就是你的如果你的想法陷入困境，并且没有正确地质疑它。
保持 RandomRunner 类接口，这更容易：
EDIT :
Actually, the above is what you get if you get an idea stuck in your head and don't question it properly.
Keeping the RandomRunner class interface, this is much easier:
class RandomRunner {
List<Runnable> runnables = new ArrayList<>();
public void add(int value, Runnable toRun) {
// add the methods as often as their weight indicates.
// this should be fine for smaller numbers;
// if you get lists with millions of entries, optimize
for (int i = 0; i < value; i++) {
runnables.add(toRun);
}
}
public void remove(Runnable r) {
Iterator<Runnable> myRunnables = runnables.iterator();
while (myRunnables.hasNext()) {
if (myRunnables.next() == r) {
myRunnables.remove();
}
}
public void runRandomly() {
if (runnables.isEmpty()) return;
// roll n-sided die
int runIndex = ThreadLocalRandom.current().nextInt(0, runnables.size());
runnables.get(runIndex).run();
}
}
这篇关于随机百分比分支的编码模式？的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！
