掷骰子直到一个值被掷出 1 000 000 次答案

【问题标题】：Rolling a dice until one value has been rolled 1 000 000 times掷骰子直到一个值被掷出 1 000 000 次
【发布时间】：2021-04-04 00:25:09
【问题描述】：

我正在编写一个程序，该程序将掷骰子 n 次，并在六种可能结果之一被掷出 1000000 次后立即停止。结果存储在一个数组中。不幸的是，我的代码没有在正确的时间停止，我认为 while 循环有问题。

import java.util.Random;

public class Wuerfel {
    
    public static void main(String[] args) {

        Random randomNumber = new Random();

        int[] rolledNumbers = {0, 0, 0, 0, 0, 0};

        while (rolledNumbers[0] < 1000000 || rolledNumbers[1] < 1000000 || rolledNumbers[2] < 1000000 || rolledNumbers[3] < 1000000 || rolledNumbers[4] < 1000000 || rolledNumbers[5] < 1000000) {

            int roll = randomNumber.nextInt(6) + 1;
            switch (roll) {
                case 1:
                    rolledNumbers[0]++;
                case 2:
                    rolledNumbers[1]++;
                case 3:
                    rolledNumbers[2]++;
                case 4:
                    rolledNumbers[3]++;
                case 5:
                    rolledNumbers[4]++;
                case 6:
                    rolledNumbers[5]++;
            }
        }
    }
}

提前致谢！

【问题讨论】：

第一个提示：你真的希望那个开关是rolledNumbers[roll - 1]++ :))
提示：当一个递增时，您不需要检查所有边。只检查你刚刚增加的那一面，看看它是否达到了 1,000,000。您可以从 while 更改为 do...while。
在每个 case 子句之后都需要 break 语句。
是的，这是个好主意。 do-while 与rolledNumbers[roll-1]++ 结合意味着不再需要开关

标签： java arrays while-loop dice

【解决方案1】：

提示 1

true || false || false || false || true 解析为 true。当您考虑 while 循环中的条件时，请考虑此提示。

提示 2

switch 语句默认通过。因此，如果滚动是1，每个 rolledNumbers[i] 都会增加，而不仅仅是rolledNumbers[0]。在每个案例批次的末尾添加 break。或者，想想如何编写一个单行代码来完成整个switch 块应该完成的事情。

【讨论】：

【解决方案2】：

你应该使用逻辑运算符 && 而不是 ||在你的 while 循环条件下，

并且还在每个 case 语句之后添加中断。

【讨论】：

【解决方案3】：

当然，如果您可以使用switch-expressions，那么您的switch 中就不需要break。

import java.util.Random;

public class Wuerfel {
    public static void main(String[] args) {
        Random randomNumber = new Random();
        int[] rolledNumbers = {0, 0, 0, 0, 0, 0};
        while (true) {
            int roll = randomNumber.nextInt(6) + 1;
            int index = switch (roll) {
                            case 1 -> 0;
                            case 2 -> 1;
                            case 3 -> 2;
                            case 4 -> 3;
                            case 5 -> 4;
                            case 6 -> 5;
                            default -> -1;
                        };
            if (index >= 0) {
                rolledNumbers[index]++;
                if (rolledNumbers[index] >= 1_000_000) {
                    break;
                }
            }
        }
    }
}

【讨论】：

@Idle_Mind 只是演示了 switch-expressions 的存在和使用。当然，您完全可以在没有switch 的情况下执行任务。
谢谢你，非常感谢你的回答！
我试过了，但它说我没有足够的代表投票：S

【解决方案4】：

这是基于我的原始评论的实现：

提示：当一个递增时，您不需要检查所有边。仅有的检查你刚刚增加的那一面，看看它是否达到了 1,000,000。你可以从一段时间改为做...一段时间。

代码：

  public static void main(String[] args) {
    Random randomNumber = new Random();

    int[] rolledNumbers = {0, 0, 0, 0, 0, 0};

    int roll;
    do {
      rolledNumbers[roll = randomNumber.nextInt(6)]++;
    } while (rolledNumbers[roll] < 1000000);

    for(int s=0; s<rolledNumbers.length; s++) {
      System.out.println("Side " + (s+1) + ": " + rolledNumbers[s]);
    }    
    System.out.println("Side " + (roll+1) + " wins!");
  }

样本输出：

Side 1: 999182
Side 2: 999885
Side 3: 1000000
Side 4: 999669
Side 5: 999952
Side 6: 999426
Side 3 wins!

注意这一行：

rolledNumbers[roll = randomNumber.nextInt(6)]++;

我们为roll 分配一个随机值（包括0 到5），该分配的结果也立即用于访问rolledNumbers 数组。这是因为 Java 中的 assignment 也会产生“结果”：

在运行时，赋值表达式的结果是赋值发生后的变量。一个结果赋值表达式本身不是变量。

【讨论】：