Выходные данные кубиков рандомизированы, и я создал для этого функцию. Я хочу записать, сколько «попыток» потребовалось, чтобы два раза подряд кубик один стал больше, чем кубик 2. Поэтому, когда он больше в два раза подряд, я хотел бы его напечатать («потребовалось» + испытания + «для того, чтобы d1 было больше d2 два раза подряд»). Пока у меня есть это, но я застрял:
public static int Dice() {
return (int)(Math.random() * 6.0) + 1;
}
public static void main(String[] args) {
int d1 = Dice();
int d2 = Dice();
int trials = 0;
for (int i = 0; i < 100000; i++) {
if (t1 > t2) {
trials++;
if (t1 > t2) {
trials++
}
}
}
System.out.println(trials);
}
}
Во всех этих ответах используется (очень старый, не совсем случайный) метод Math.random() для генерации случайных чисел. В наши дни лучше всего использовать класс java.util.Random. Создайте поле класса private static Random RANDOM = new Random(), а затем вызовите RANDOM.nextInt(6) + 1, когда вам нужен случайный int от 1 до 6.
Не могли бы вы описать то, что вы называете судебным разбирательством в вашем деле? Оба кубика брошены одновременно два раза?




Сделайте что-нибудь вроде этого (рассматривайте это как псевдокод):
public static int[] Dice() {
int[] diceThrownTwoTimes = new int[2];
diceThrownTwoTimes[0] = (int)(Math.random() * 6.0) + 1;
diceThrownTwoTimes[1] = (int)(Math.random() * 6.0) + 1;
return diceThrownTwoTimes;
}
public static void main(String[] args) {
int trials = 0;
for (int i = 0; i < 100000; i++) {
int[] d1 = Dice();
int[] d2 = Dice();
if (d1[0] > d2[0] && d1[1] > d2[1]) {
trials++;
}
}
System.out.println(trials);
}
Обновлено:
Чтобы получить попытки, до которых значение dice1 больше значения dice2 два раза подряд, можно сделать следующее:
public static int[] Dice() {
int[] diceThrownTwoTimes = new int[2];
diceThrownTwoTimes[0] = (int)(Math.random() * 6.0) + 1;
diceThrownTwoTimes[1] = (int)(Math.random() * 6.0) + 1;
return diceThrownTwoTimes;
}
public static void main(String[] args) {
int trials = 0;
for (int i = 0; i < 100000; i++) {
int[] d1 = Dice();
int[] d2 = Dice();
if (d1[0] > d2[0] && d1[1] > d2[1]) {
break;
}else{
trials++;
}
}
System.out.println(trials);
}
Я бы сказал, что это было бы более ясно, если бы вы использовали d1[0] > d1[1] && d2[0] > d2[1], но функционально эти два выражения проверяют одно и то же (в этом контексте).
@Bobulous, да, это правда ... но поскольку вопрос состоит в том, чтобы записать, сколько попыток потребовалось, чтобы кубик один стал больше, чем кубик 2 два раза подряд, я закодировал это так :)
Я читаю d1 как «бросить один» и [0] как «первый кубик в паре», но, честно говоря, это можно было прочитать в любом случае.
Кстати, этот код работает точно так же, как вы его набрали (в Java 8), и дает ответ, которого я ожидал, учитывая, что правильная вероятность равна ((1 + 2 + 3 + 4 + 5) / 36) ^ 2 = 0,173611111111 (и первый запуск этого кода дал мне 17324/100000 = 0,17324).
Я должен отметить, что, хотя этот код правильно отвечает на вопрос «в какой пропорции бросков на две пары первый кубик будет больше, чем второй кубик в обеих парах», OP, похоже, действительно хочет знать, сколько двух- парные броски необходимы до того, как этот результат случится только один раз. Итак, этот ответ полезен, но не отвечает на заданный вопрос OP.
@Bobulous, спасибо, что указали на это ... изменил свой ответ
Ваш второй блок кода не работает, потому что во многих случаях он возвращает нулевое значение. (Вам необходимо увеличить значение trials до оценки испытания, в противном случае вы выйдете без подсчета этого испытания.)
Это не то же самое, что задается в вопросе, поскольку второй бросок в одном вызове Dice () и первый из следующего могут удовлетворить требованию. Каждый бросок нужно делать независимо.
@Bobulous, нам нужно количество попыток до того, как произойдет фактическое интересующее событие - если оно произойдет в первом испытании, то ответ должен быть нулевым, верно?
@nvioli, не могли бы вы уточнить? Каждый рулон в моем случае независим
Вы бросаете оба кубика дважды, а затем, если эти два броска не имеют желаемого свойства, вы бросаете их еще два раза. Вы сделали четыре броска пары игральных костей. Если бы у второго броска из первой пары бросков и первого броска из второй пары были правильные свойства, вы бы его пропустили. Посмотрите на этот вопрос: math.stackexchange.com/questions/238313/…
Существует вероятностная разница между последовательными отдельными бросками (о чем задается вопрос) и последовательными парами бросков (что моделирует ваш ответ).
@nvioli, хорошо, я думаю, я понимаю, что вы говорите ... Я думал, что сценарий таков, что оба кубика бросаются одновременно, но это может быть не так
Честно говоря, я не думаю, что OP делает спецификацию достаточно ясной, поэтому я проголосовал за закрытие как "Неясно ..."
Я бы пошел с
public static int Dice() {
return (int)(Math.random() * 6.0) + 1;
}
public static void main(String[] args) {
int trials = 0;
int count = 0;
while (count < 2) {
int d1 = Dice();
int d2 = Dice();
if (d1 > d2) {
++count;
} else {
count = 0;
}
++trials;
}
println("It took " + trials + " trials for d1 to be larger than d2 " + count + " times in a row.")
}
Добро пожаловать в SO! Это должно сработать. См. Комментарии о некоторых вещах, которые вы делали неправильно, и некоторые объяснения.
public static int Dice() {
return (int)(Math.random() * 6.0) + 1;
}
public static void main(String[] args) {
// initialize variables to be updated in the loop
int trials = 0;
Boolean lastTimeD1WasGreater = false;
for (int i = 0; i < 100000; i++) {
// always increment the counter!
trials++;
// you had the wrong variable names here.
// also they must be INSIDE the loop or else they would always come out the same
int d1 = Dice();
int d2 = Dice();
if (d1 > d2) {
if (lastTimeD1WasGreater) {
// if it was greater both last time and this time then we're done!
System.out.println("it took " + trials + " trials.");
break;
} else {
// otherwise set this variable so we can be on the lookout next time.
lastTimeD1WasGreater = true;
}
} else {
// d1 was not greater, so we'll start looking for a pair in the next loop.
lastTimeD1WasGreater = false;
}
}
}
Большое спасибо!! Это действительно помогло мне понять
Большой! Позвольте мне знать, если у вас есть какие-либо другие вопросы. Если я решил вашу проблему, нажмите на галочку, чтобы принять мой ответ.
Вы можете легко сделать это в основной функции, если только не требуется использовать внешнюю функцию для возврата случайного числа.
public static void main(String[] args)
{
int d1 = 0;
int d2 = 0;
int trials = 0;
int d1bigger = 0;
Random rand = new Random();
while(d1bigger < 2)
{
d1 = rand.nextInt((6 - 1) + 1) + 1 ;
d2 = rand.nextInt((6 - 1) + 1) + 1 ;
if (d1 > d2)
{
d1bigger ++;
trials++;
}
if (d2 > d1)
{
d1bigger = 0;
trials++;
}
}
System.out.println("It took " + trials + " trials for d1 to be larger than d2 two times in a row");
}
Потребовалось 7 попыток, чтобы d1 было больше d2 два раза подряд
Пример вывода
если вы запустите это с системными выходами для d1 и d2, вы увидите, что функция rand работает правильно для чисел 1-6
Хорошо, кто-то использовал java.util.Random.nextInt(int), но почему вы прибегли к сбивающему с толку аргументу (6-1)+1, когда только 6 даст вам то же самое более четко?
Если вы посмотрите документацию по нему, это сделает случайный вызов более понятным и почему вам нужно добавить 1 дважды, а не один раз. ((6-1) + 1) + 1 ((макс - мин) + мин) + мин.
Вот что я придумал
import java.util.Random;
public class main {
public static int Dice() {
return (int) (Math.random() * 6.0) + 1;
}
public static void main(String[] args) {
Random rand = new Random();
int trials = 0;
int twoTimes = 0;
do {
int d1 = rand.nextInt(25) + 1;
int d2 = rand.nextInt(25) + 1;
trials++;
if (d1 > d2) {
twoTimes++;
System.out.printf("%s time greater\nd1 was " + d1 + "\nd2 was " + d2 + "\n-------\n", twoTimes);
}
}
while (twoTimes != 2);
System.out.printf("\nIt took %s times", trials);
}
}
почему вы используете для этого цикл на 100 000 отсчетов? было бы предпочтительнее простой счетчик управления циклом while до тех пор, пока вы не получите на 2 d1 больше, чем d2, и цикл завершится, когда ваше условие будет выполнено, и не продолжит работу.