龙与地下城掷骰子再掷

Question

import java.util.*;

public class Project2Main {

public static void main(String args[]) {
    Scanner kb = new Scanner(System.in);
    int numSets = 0;
    System.out.println("How many sets of dice would you like to roll?");
    numSets = kb.nextInt();
    kb.nextLine();

    RollingDice roller = new RollingDice();
    List<List<Integer>> diceSets = roller.rollSets(numSets);

    for (List<Integer> diceRolls : diceSets) {
        Integer total = sum(diceRolls);
        Integer lowest = Collections.min(diceRolls);
        System.out.println("Your roll total is: " + total + " and the lowest roll was a: " + lowest);
    }
    kb.close();
}

public static int sum(List<Integer> list) {
    int sum = 0;
    for (int number : list)
        sum = sum + number;
    return sum;
}
}

import java.util.*;

public class RollingDice {
private Random rand;

public RollingDice() {
    this.rand = new Random();
}

public List<Integer> roll4d6DropLowest() {
    List<Integer> retList = new ArrayList<Integer>();

    for (int i = 0; i < 4; i++) {
        retList.add(rand.nextInt(6) + 1);
    }

    retList.remove(Collections.min(retList));

    return retList;
}

public List<List<Integer>> rollSets(int numSets) {
    List<List<Integer>> results = new ArrayList<List<Integer>>();
    for (int i = 0; i < numSets; i++) {
        results.add(roll4d6DropLowest());
    }
    return results;
}
}

你好堆栈溢出，我有一个小问题与这个程序。我正在尝试制作一个程序来掷四个骰子并将三个最高的掷骰子加在一起，然后打印这三个掷骰子中最低的一个。我犯了一个错误，就是把三个最高的卷子加在一起，然后打印出四个卷子中最低的一个。

我如何解决这个问题？我在谷歌上搜索了很多，想知道如何使用列表和集合，但我找不到任何可以解决这个问题的东西。

此外，我如何才能迫使用户选择一个集合并重新滚动该集合？

基本上，我想做的是将每个集合分配给一个数字（集合1是1，集合2是2，依此类推），然后用户输入一个与他们拥有的集数量相关的数字，然后重新滚动三个最高卷中的最低卷。

任何帮助都非常感谢。

Answer 1

在这里使用列表列表是一个轻微的过度轰炸案例，这个怎么样：

public class Project2Main {
    private static Random rand = new Random(System.currentTimeMillis());

    public static void main(String args[]) {
        int numSets = 4; //set via Scanner, if wanted

        List<Integer> dices = new ArrayList<Integer>(numSets);
        for (int c = 0; c < numSets; c++) {
            int roll = rand.nextInt(6) + 1;
            dices.add(Integer.valueOf(roll));
            System.out.println(roll);
        }

        int[] pair = roll4d6DropLowest(dices);
        System.out.println("lowest of three highest: " + pair[0]);
        System.out.println("sum of 3 highest is: " + pair[1]);    
    }


    /**@param diceRolls Array of dice rolls
     * @return return array of two ints: 
           0: lowest of three highest
           1: sum of three highest */
    private static int[] rollXd6DropLowest(List<Integer> array) {
        int sum = 0;
        int low = 0;

        Collections.sort(array);
        for (int c = (array.size() - 1); c > 0; c--) {
            sum += (int) array.get(c);
            if (c == 1) {
                low = (int) array.get(c);
            }
        }

        int[] pair = { low, sum };
        return pair;
    }

}

我承认，返回int[]并不是所有解决方案中最好的，但对于那一小段代码来说，它应该没问题。

请注意按当前时间毫秒初始化Random以确保随机性。

诀窍是将掷骰子存储在< code >整数的< code >列表中，并在< code >集合的帮助下根据它们的“自然顺序”对它们进行排序。最高是最高的。