java - 随机分配每个单词的百分比

Question

Percentage:70 - CommandA  Data:Previous/New(80/20)    User:true/false(50/50)
Percentage:30 - CommandB  Data:Previous/New(50/50)    User:true/false(30/70)

上面是我的文本文件，其中 70% 的时间我打印 CommandA，30% 的时间打印 CommandB，这是我通过从 StackOverflow 获取建议而在下面编写的逻辑。现在我想要的是，如果 CommandA 70% 的时间被打印，那么 70% 的时间中的 80% 也应该打印 Previous，70% 的时间中的 20% 应该打印 New。同样，它应该打印 70% 的时间中的 50% true 和 50% 的时间 false。所以基本上问题是这样的 - 问题陈述

<小时/>

Print "CommandA" 70% of the time, and out of those 70% print 80% "Previous" and print 20% "New". And out of those 70% print 50% "true" and print 50% "false" Likewise, for CommandB print "CommandB" 30% of the time, and out of those 30% print 50% "Previous" and print 50% "New". And out of those 30% print 30% "true" and print 70% "false"

<小时/>

因此，目前在我的下面的代码中，我正在打印 CommandA 的 70% 和 CommandB 的 30%。我不知道如何添加满足上述要求的代码。

public static void main(String[] args) {
        commands = new LinkedList<Command>();
        values = new ArrayList<String>();
        br = new BufferedReader(new FileReader("S:\\Testing\\Test2.txt"));
        while ((sCurrentLine = br.readLine()) != null) {
            percentage = sCurrentLine.split("-")[0].split(":")[1].trim();
            values = Arrays.asList(sCurrentLine.split("-")[1].trim().split("\\s+"));
            for(String s : values) {
                if(s.contains("Data:")) {
                // Here data contains **Previous/New(80/20)**
                    data = s.split(":")[1];
                } else if(s.contains("User:")) {
                // Here userLogged contains **true/false(50/50)**
                    userLogged = s.split(":")[1];
                } else {
                    cmdName = s;
                }
            }

            Command command = new Command();
            command.setName(cmdName);
            command.setExecutionPercentage(Double.parseDouble(percentage));
            command.setDataCriteria(data);
            command.setUserLogging(userLogged);
            commands.add(command);
        }

        executedFrequency = new Long[commands.size()];

        for (int i=0; i < commands.size(); i++) {
            executedFrequency[i] = 0L;
        }

        for(int i = 1; i < 10000; i++) {
            Command nextCommand = getNextCommandToExecute();
    // So by my logic each command is being printed specified number of percentage times                    
    System.out.println(nextCommand.getName()); 


/*
 * What I want is that if Command A is executed 70% of time, then according 
 * to properties  file 80% times of 70% of CommandA it should print Previous 
 * and 20% times of 70% of CommandA it should print New Likewise same thing 
 * for User. It should print 50% times of 70% of CommandA true and 50% to false.
 * 
 */

        }
    } 

}

// Get the next command to execute based on percentages
private static Command getNextCommandToExecute() {
    int commandWithMaxNegativeOffset = 0; // To initiate, assume the first one has the max negative offset
    if (totalExecuted != 0) {
        // Manipulate that who has max negative offset from its desired execution
        double executedPercentage = ((double)executedFrequency[commandWithMaxNegativeOffset] / (double)totalExecuted) * 100;
        double offsetOfCommandWithMaxNegative = executedPercentage - commands.get(commandWithMaxNegativeOffset).getExecutionPercentage();

        for (int j=1; j < commands.size(); j++) {
            double executedPercentageOfCurrentCommand = ((double)executedFrequency[j] / (double)totalExecuted) * 100;
            double offsetOfCurrentCommand = executedPercentageOfCurrentCommand - commands.get(j).getExecutionPercentage();

            if (offsetOfCurrentCommand < offsetOfCommandWithMaxNegative) {
                offsetOfCommandWithMaxNegative = offsetOfCurrentCommand;
                commandWithMaxNegativeOffset = j;
            }
        }
    }

    // Next command to execute is the one with max negative offset
    executedFrequency[commandWithMaxNegativeOffset] ++;
    totalExecuted ++;

    return commands.get(commandWithMaxNegativeOffset);
}

附注我为百分比执行编写的逻辑来 self 在 stackoverflow 上发布的帖子。

Answer 1

您可以使用java.util.Random类来生成随机数。 Random.nextDouble() 方法返回一个介于 0 和 1 之间的值，因此如果将其乘以 100，就会得到一个百分比。然后将数字与命令所需的百分比进行比较(例如 CommandA 为 70)

由于您知道命令所需的百分比，因此您可以生成另一个随机数或使用刚刚生成的随机数来选择命令。

1. 生成一个新数字:(参见上面的生成)，然后您可以将百分比与所需的第二级分布进行比较(例如，上一个为 80) )

2. 重复使用相同的数字:计算命令选择阈值的适当部分并将数字与其进行比较。例如。对于 CommandA ，阈值为 70。假设您生成了 69(小于 70，因此选择了 CommandA)。所以你算出70*80%=56。 69 大于该值，因此您选择新建(而不是上一个)

注意:即使您保留当前选择命令的逻辑，也可以采用方法 1)

更新:代码示例:

Random rnd = new Random();
double percent = rnd.getNextDouble()*100;
for (Command c : commands) {
  if (percent < c.getExecutionPercentage()) {
    // we select the current command
    percent = rnd.getNextDouble()*100;
    if (percent < command.getDataCriteria().getPreviousPercentage()) {
      // we select Previous
    } else {
      // we select New
    }
    break;
  } else {
    percent -= c.getExecutionPercentage();
  }
}

注意:上面的代码假设所有 Command 的 getExecutionPercentage() 的总和(至少)为 100

更新:创建了一个Random对象，因为方法不是静态的