Ainda é uma distribuição binomial ao jogar dados com probabilidades diferentes que devem ser atendidas para contar um sucesso?

Não, você não precisa do distribuição binomial

Apenas o regra de complemento e a regra da cadeia.

Seu sistema ficará lento ...

Deixando de lado a questão da probabilidade, levará mais tempo do que a maioria dos mecânicos de dados para passar do que está sendo mostrado na mesa para um "passe" ou "falha".

Rápido! Você lançou o 3, 10, 7, 4, 4, 6 - com quais regras você aprovou?

... e não intuitivo

Você, o designer do jogo, nos deu três metas para as quais você não pode calcular a probabilidade porque não possui habilidades matemáticas suficientes. Posso fazê-lo, mas levo pelo menos 10 minutos ou um computador a força bruta para responder.

Como você espera que os jogadores do jogo olhem para a regra e saibam se eles têm uma chance decente de ter sucesso ou não nos segundos do 30, leva-os a considerar o que eles querem que seu personagem faça?

Como calcular as probabilidades

Há uma simplificação direta que você pode usar aqui - existem maneiras 15 de fazer pares com dados 6 - \ $ {6 \ escolha 2} = 15 \ $.

Você precisa (1) descobrir a chance de isso acontecer em um único par, (2) ter a chance não acontecendo a partir da regra de complemento, (3) use a regra de multiplicação para descobrir a chance de isso não acontecer nos pares 15 e (4) use a regra de complemento novamente.

Por exemplo, para um 9 \ $ ({1 \ over 10}) \ $ e qualquer número ímpar menor que 9 \ $ ({4 \ over 10}) \ $ tem um \ $ {4 \ over 100} \ times 2 = {8 \ over 100} \ $ chance em um par de dados porque a ordem não importa. Então tem um \ $ 1- {8 \ over 100} = {92 \ over 100} \ $ of não acontecendo. Sobre os pares 15, possui um \ $ \ left ({92 \ over 10} \ right) ^ {15} \ approx0.2863 \ $ of não acontecendo ou um \ $ 0.7137 \ $ de acontecer.

A mesma técnica dá \ $ 0.7941 \ $ e \ $ 0.4579 \ $ para os próximos dois - tudo o que muda é a probabilidade original do par.

No final, para todas as probabilidades em dados 2 de 0 a 1 (em incrementos de 0.01), a probabilidade de seu pool é:

As probabilidades dos seus critérios de sucesso são bastante complexas

Alguns de seus critérios, como "9 em um dado, um número ímpar diferente no outro dado", são bastante simples, pois você pode calcular as probabilidades para os dois dados independentemente. Outros, como "número par X em um dado, X / 2 no outro dado", são mais complexos, pois a probabilidade de obter X / 2 no segundo dado depende do valor do primeiro (ou seja, a probabilidade é 1 / 10 se o primeiro dado for par e 0 se o primeiro dado for ímpar).

No entanto, mesmo para as condições simples, você tem o problema adicional de o jogador ter um conjunto de dados 6 dos quais pode escolher qualquer 2 para satisfazer a condição. Se a pontuação final do jogador para sua mão depende de várias posições no depósito (por exemplo, soma de todas as pontuações na posição), agora existe uma interdependência adicional entre as posições, já que alocar um dado a uma posição exclui se estiver alocado a qualquer outra posição, e isso complica ainda mais os cálculos de probabilidade.

Por fim, a solução mais conveniente pode ser escrever um programa como você sugeriu: enumere todos os milhões de rolos possíveis de 1d6 do 10 e avalie cada rolo com base nos seus critérios de pontuação. (Tecnicamente, alguns testes serão equivalentes, pois a ordem não importa, mas você não precisa se preocupar com isso.) Isso evita que você precise elaborar a teoria precisa das probabilidades por trás de cada critério de pontuação. Ou, em outras palavras, escrever o código para avaliar se uma determinada mão atende a cada critério é provavelmente mais fácil do que calcular manualmente as probabilidades para cada critério.

Eu escrevi um programa [inicial] em C ++ que pode lidar com a tarefa de encontrar todos os resultados possíveis para um rolo 6d10.

#include <map> #include <vector> #include <array> #include <iostream> #include <iomanip> #include <algorithm> usando arr_t = std :: array <int, 6>; std :: map <arr_t, int64_t> get_rolls () {std :: map <arr_t, int64_t> mapa; for (int i = 1; i <= 10; i ++) {// Intitalizamos com cada valor possível de um único d10. Os valores restantes // estão configurados para 11 para indicar rolos que ainda não ocorreram. Usamos o 11, para que ele não // interfira na classificação da matriz que fazemos mais tarde arr_t arr = {i, 11, 11, 11, 11, 11}; mapa [arr] ++; } // Nesse momento, o mapa se parece com isso: // {1,11,11,11,11,11}: 1 // {2,11,11,11,11,11}: 1 // {3,11,11,11,11,11}: 1 // {4,11,11,11,11,11}: 1 // {5,11,11,11,11,11}: 1 // {6,11,11,11,11,11}: 1 // {7,11,11,11,11,11}: 1 // {8,11,11,11,11,11}: 1 // {9,11,11,11,11,11}: 1 // {10,11,11,11,11,11}: 1 para (int i = 1; i <6; i ++) {// Inicializando o loop for com 1 para que entendamos que precisamos dos valores 6, // MAS já inicializamos o primeiro valor para cada rolo, portanto cada rolo // só tem o 5 mais para avaliar. std :: map <arr_t, int64_t> temp; for (auto const & [arr, trial]: map) {// Para cada conjunto de testes e seus testes associados no mapa ... para (int valor = 1; valor <= 10; valor ++) {// ... adicionamos o próximo rolo ao conjunto auto arr_copy = arr; arr_copy [i] = valor; std :: sort (arr_copy.begin (), arr_copy.end ()); temp [arr_copy] + = tentativas; }} mapa = temp; } // Nesse momento, o mapa se parece com isso: // {1,1,1,1,1,1}: 1 // {1,1,1,1,1,2}: 6 // {1,1,1,1,1,3}: 6 // ... // {1,1,1,1,2,2}: 30 // ... // {9,10,10,10,10,10}: 6 // {10,10,10,10,10,10}: mapa de retorno 1; } int get_largest_even (arr_t const & arr) {int ret = -1; for (int i: arr) {// O operador de módulo% retorna 0 se o número for igualmente divisível pelo número // sendo comparado e algum outro número, se não for. if (i% 2 == 0) {// Portanto, se é par (igualmente divisível por 2) if (auto it = std :: find (arr.begin (), arr.end (), i / 2)); ! = arr.end ()) // Isso é uma mágica do C ++ para encontrar o índice de um valor na matriz que seja // o valor exato dividido pelo 2 e, em seguida, validar se realmente encontramos um ou não. ret = i; } // Isso verifica através de uma matriz classificada, portanto, se encontrarmos um valor maior posteriormente, // substituirá o valor encontrado anterior} return ret; } filtros automáticos de filtros (std :: map <arr_t, int64_t> const e mapa) {std :: map <int, int64_t> new_map; for (auto const & [arr, trial]: map) {if (int maior_even = get_largest_even (arr); maior_even! = -1) {// Só mantemos a rolagem se ela contiver um par válido correspondente ao // "Any Even X; X / 2 ". // Também armazenamos apenas o maior valor par, pois não nos importamos mais com o que // os outros rolos de dado eram new_map [largest_even] + = tentativas; }} retornar new_map; } int main () {rolagens automáticas = get_rolls (); auto_rolls filtrados =_rolls de filtro (rolos); int64_t total_trials = 0; for (auto const & [largest_even, trial]: filter_rolls) {// Muita formatação de lixo. O TBH C ++ está um pouco atrasado com a forma como ele lida com esse std :: cout << "Maior Par" << std :: setw (2) << maior_even << "" << std :: setw (6) << avaliações < <"trial (" << std :: setw (6) << std :: setprecision (3) << std :: corrigido << (trial / 10'000.0) << "%) \ n"; total_trials + = tentativas; } std :: cout << "=== \ n"; std :: cout << "Total:" << std :: setw (6) << total_trials << "tentativas" << std :: setw (6) << (total_trials / 10'000.0) << "% \ n "; }

Estas são as partes importantes:

• get_rolls (): Isso cospe uma Mapa que relaciona cada permutação exclusiva de um rolo (independente de pedido) ao número de maneiras pelas quais a permutação pode ser rolada. Se tudo o que você deseja é uma lista de todos os lançamentos possíveis e sua probabilidade relativa, é tudo o que você precisa.
• filter_rolls (...): Tira o mapa da função anterior e remove todos os rolos que não precisamos. Nesse caso, eu o programei para manter apenas os rolos que satisfizessem a condição "Any Even X; X / 2", ou seja,
  • Ele mantém os rolos apenas se eles contiverem pelo menos um valor par E
  • O rolo também contém um valor exatamente igual à metade desse valor par
  • Se o rolo contiver vários pares (como 1,2,3,6,4,8), ele registrará o par mais alto encontrado, registrando seu valor maior (portanto, o par mais alto é 4,8 gravado como 8)
• Em seguida, imprimimos os resultados em principal. Isso contém apenas o código de exibição e não contém nenhuma lógica para criar ou filtrar os rolos.

Portanto, a saída deste programa é assim:

Maiores estudos Even 2 90002 (9.000%) Maiores estudos Even 4 90002 (9.000%) Maiores estudos Even 6 153662 (15.366%) Maiores ensaios Even 8 176102 (17.610%) Maiores ensaios Even 10 199262 (19.926%) Maiores ensaios Even 709030 70.903 (XNUMX%) Total dos ensaios Even XNUMX XNUMX (XNUMX%) === Total: Avaliações do XNUMX XNUMX%

Podemos aprender algumas coisas importantes com isso:

• Para a condição "Qualquer par X; X / 2", a pessoa que rola tem uma chance de 70.903% de atender a essa condição em um rolo 6d10. Portanto, se essa fosse a condição para uma habilidade, o rolo teria uma chance de sucesso de 71%.
• Também podemos ver as probabilidades de cada resultado possível e deduzir indutivamente a soma desse par (um Maior par de 2 teria uma soma de 3, porque seria emparelhado com um 1)

Se você quiser testar outros pares, precisará alterar a lógica do get_largest_even função, já que aquele está fazendo o trabalho de identificar os dados que estão sendo lançados (talvez renomeá-lo?).

Essa lógica deveria trabalhe em qualquer linguagem de programação que suporte os mesmos recursos básicos do C ++ (o que é mais; o C ++ possui uma Biblioteca de Recursos relativamente simples ...), desde que você aprenda como portá-lo. Portanto, se você estiver disposto a aprender uma linguagem de programação (e eu recomendo C ++!), Você poderá atualizar / revisar essa lógica para lidar com cada condição que deseja nomear para uso em seu sistema de produção em casa.

Alternativamente, me incomoda no chat e se eu tiver tempo livre, posso executar outras condições por esse código.

Este é um problema interessante em probabilidade. Só vou examinar a chance de sucesso nos dois primeiros dados da piscina. As complicações que surgem nesse cálculo ficarão mais complexas para as caixas posteriores.

Terminologia: vou me referir às condições que os dados precisam atender para ter sucesso como testes. Portanto, no seu exemplo do pool 6d10, um teste é 9 e o outro teste é ímpar menor que 9. Se estou entendendo o sistema, o bin terá êxito se cada dado passar em um teste diferente.

Foi uma grande ajuda reduzir o problema para algo gerenciável. Um pool de 3d5 possui apenas resultados possíveis no 125 e é grande o suficiente para cobrir as variações importantes. Em cada variação, há dois testes. O primeiro teste tem uma chance de sucesso do 3 / 5 em um único dado. O segundo tem uma chance de sucesso do 2 / 5 em um único dado. Eu brinquei com eles no Excel, analisando todas as possibilidades até ter um instinto para o que realmente estava acontecendo.

Para um pool, um teste é bem-sucedido se pelo menos um dado for bem-sucedido no teste. Isso é calculado como o complemento da chance de todos os dados falharem no teste. Então se \ $ P (T_k, 1) \ $ é a probabilidade de sucesso no teste k com um dado, então a probabilidade de sucesso no teste k com um conjunto de n dados é $$ P (T_k, n) = 1 - [1 - P (T_k, 1)] ^ n $$

Então, com meus testes específicos \ $ P (T_1,1) = \ frac {3} {5} \ $ rendimentos \ $ P (T_1,3) = 0.936 \ $ e \ $ P (T_2,1) = \ frac {2} {5} \ $ rendimentos \ $ P (T_2,3) = 0.784 \ $.

Agora vamos começar com um análogo ao seu exemplo. Seus dois testes não se sobrepuseram. Um dado pode gerar um 9 ou um número ímpar menor que o 9, ou pode falhar em executar um dado. Não pode fazer as duas coisas. O cálculo da probabilidade é o mais simples nesse caso. A lixeira é bem-sucedida se ambos os testes forem bem-sucedidos. Como os testes são exclusivos, eles devem ser aprovados por dados diferentes. Portanto, se os dois testes forem aprovados individualmente, não há possibilidade de a combinação falhar. A probabilidade de o bin ter êxito é mais fácil de ver como o complemento do bin falhar, o que, por sua vez, é apenas a probabilidade de falha do teste 1 ou falha do teste 2. $$ P (B) = 1 - [(1 - P (T_1)) + (1 - P (T_2))] $$ Um exemplo disso no meu problema de brinquedo 3d5 seria o teste 1 passar por um número ímpar e o teste 2 passar por um par. Conectando os números, você obtém \ $ P (B) = 0.72 \ $.

As coisas ficam mais complicadas se os testes não forem exclusivos. Existem duas maneiras de isso acontecer. Primeiro, um teste é um subconjunto do outro. Por exemplo, o teste 1 consegue números ímpares, enquanto o teste 2 obtém números ímpares menores que 5. Se um dado passa no teste 2, ele passa automaticamente no teste 1, embora o inverso obviamente não seja verdadeiro.

Agora, para enumerar a maneira como a lixeira falha. Temos que prestar atenção à sobreposição para não contarmos um caso com falha duas vezes. Primeiro, o teste 1 falha; isso implica automaticamente que o teste 2 falha. Segundo, o teste 2 falha, mas o teste 1 é bem-sucedido; isto é, os únicos números ímpares são 5. Finalmente, ambos os testes são bem-sucedidos, mas apenas em um dado; então um dado é um 1 ou 3 e os outros dois são iguais. A matemática para escrever isso como uma fórmula está ficando complicada a ponto de eu não achar que agitar a fórmula acrescente nada. De qualquer forma, isso reduz a probabilidade de obter uma posição bem-sucedida em \ $ P (B) = 0.592 \ $.

A última possibilidade é que dois testes tenham uma sobreposição parcial. Portanto, alguns resultados são bem-sucedidos para ambos os testes, mas alguns são bem-sucedidos para apenas um ou outro. Por exemplo, o teste 1 obtém êxito (mais uma vez) para números ímpares e o teste 2 obtém sucesso para quadrados perfeitos. Portanto, um rolo do 1 é bem-sucedido nos dois testes, o rolo do 3 e o 5 são bem-sucedidos no teste 1, o 4 somente no teste 2 e o 2 é reprovado nos dois testes.

Portanto, o compartimento falhará se (a) o teste 1 falhar (apenas números pares), (b) o teste 1 for bem-sucedido, mas o teste 2 falhar (apenas números não quadrados incluindo pelo menos um ímpar), (c) ambos os testes falharão (apenas mesmo não) - números quadrados, ou seja, 2) ou ambos os testes são bem-sucedidos em apenas um dado (role um 1 e o restante 2). Eu nem tentei descobrir a fórmula, mas apenas percorrer todas as possibilidades dá uma probabilidade de sucesso de \ $ P (B) = .704 \ $.

Ao examinar a possibilidade de obter sucesso em um segundo compartimento em um pool, você compõe os efeitos da sobreposição nos valores de sucesso do teste, para que fique bastante complicado.

Se você for fazer isso, aconselho a manter estritamente os testes não sobrepostos em uma única lixeira. Você pode, pelo menos, calcular as chances de um único par de testes no primeiro compartimento do pool. A probabilidade de sucesso em compartimentos posteriores do pool diminuirá de maneiras difíceis de prever, mas você pode pelo menos ter uma base de comparação.