Como calcular probabilidades para um mecanismo de eliminação de três conjuntos?

Não é (ainda) exatamente o que você está pedindo, mas aqui está um programa AnyDice que retorna o maior lance em um dados, excluindo qualquer dado lançado em outra mesa:

function: highest of DICE:d excluding EXCL:s {
  NEW: {}
  loop I over {1@DICE} {
    if I = EXCL { I: 0 }
    NEW: {NEW, I}
  }
  POOL: (#DICE) d NEW
  result: 1@POOL
}
output [highest of 3d6 excluding 4d6]

Ele usa uma sintaxe AnyDice bastante complicada, então deixe-me explicar alguns detalhes:

• Quando você passa um dado para uma função AnyDice esperando uma sequência (como EXCL:s acima), AnyDice executará a função para todos os rolos possíveis dos dados , e soma os resultados (ponderado pela probabilidade de cada rolo). Esta é basicamente uma abordagem de força bruta, e pode facilmente ter tempo para grandes paradas de dados, mas é muito versátil quando funciona. É assim que eu estou lidando com a mecânica de exclusão aqui.

• #DICE fornece o número de dados no pool DICE e {1@DICE} fornece os valores possíveis de um único dado no conjunto. Ou seja, se DICE = 3d6 , então #DICE = 3 e {1@DICE} = {1, 2, 3, 4, 5, 6} .

• Quando você compara um número a uma sequência (como em I = EXCL ), o resultado será verdadeiro (diferente de zero) se a comparação for verdadeira para qualquer elemento da sequência. Ou seja, if I = EXCL basicamente verifica se I pertence à sequência EXCL .

Então, o que o laço dentro da função faz é construir um dado NEW que se parece com um dos dados em DICE , mas com os lados correspondentes a EXCL substituído por 0 Em seguida, POOL: (#DICE) d NEW cria um novo conjunto de dados personalizado que consiste em quantos dados personalizados existirem no conjunto original DICE e a linha final retorna o maior resultado nesse conjunto.

Chegando um pouco mais perto, aqui está uma versão que adiciona o bônus para vários dados iguais e maiores :

function: highest of ROLL:s with bonus {
  MAX: 1@ROLL
  BONUS: MAX > 0 & (MAX = ROLL) > 1
  result: 10 * MAX + BONUS
}
function: highest of DICE:d excluding EXCL:s {
  NEW: {}
  loop I over {1@DICE} {
    if I = EXCL { I: 0 }
    NEW: {NEW, I}
  }
  POOL: (#DICE) d NEW
  result: [highest of POOL with bonus]
}
output [highest of 3d6 excluding 4d6]

Como AnyDice não suporta números fracionários, estou multiplicando o resultado da rolagem por 10, de modo que, digamos, um resultado de 5,1 (= 5 + 0,1 bônus) seja representado como 51.

O código acima é exatamente o mesmo que o primeiro programa acima, exceto que eu substituí 1@POOL com uma chamada para uma função auxiliar que adiciona o bônus se a rolagem mais alta ocorrer várias vezes (e não é zero). A função auxiliar usa o mesmo truque de inserir o rolo como uma sequência com :s , de modo que seja automaticamente iterado sobre cada resultado possível do teste.

Por fim, aqui está um programa que calcula o número de dados não excluídos no pool B:

function: number of DICE:d excluding EXCL:s {
  NEW: {}
  loop I over {1@DICE} {
    NEW: {NEW, !(I = EXCL)}
  }
  result: (#DICE) d NEW
}
output [number of 2d6 excluding 4d6]

É o mesmo que o primeiro programa, exceto que agora estamos rotulando os lados de nossos dados personalizados com 0 se estiverem na lista de exclusão, e 1 de outra forma, e tomando a soma do teste como resultado .

O problema restante é combinar esses programas, para levar em conta o fato de que os dois conjuntos A e B dependem do conjunto C simultaneamente. O problema é que o AnyDice realmente não manipula bem a saída bidimensional, mas podemos usar o mesmo truque usado para lidar com o bônus de 0,1 acima, multiplicando o resultado do pool A por 10 antes de adicionar o resultado do pool B, assim :

function: highest of ROLL:s with bonus {
  MAX: 1@ROLL
  BONUS: MAX > 0 & (MAX = ROLL) > 1
  result: 10 * MAX + BONUS
}
function: highest of A:d and count of B:d excluding EXCL:s {
  ANEW: {}
  loop I over {1@A} {
    if I = EXCL { I: 0 }
    ANEW: {ANEW, I}
  }
  BNEW: {}
  loop I over {1@B} {
    BNEW: {BNEW, !(I = EXCL)}
  }
  result: 10 * [highest of (#A) d ANEW with bonus] + (#B) d BNEW
}
output [highest of 3d6 and count of 2d6 excluding 4d6] named "A.A, B"

Aqui, a saída consiste em um número de três dígitos PQR , em que P é o maior rolo não excluído no conjunto A, Q é 1 se o maior lance não excluído no conjunto A for múltiplo e R é o número de rolos não excluídos no conjunto B.

Oh, espere! Você disse que queria a rolagem mais alta entre os grupos A e B juntos , não apenas o maior lance em A? Bem, eu posso fazer isso também , embora exija um pouco de reorganização, já que o maior lance não é mais independente o número de rolos não excluídos no conjunto B:

function: highest of A:s and B:s with bonus and count {
  MAX: [highest of 1@A and 1@B]
  BONUS: MAX > 0 & (MAX = A) + (MAX = B) > 1
  COUNT: B > 0
  result: 100 * MAX + 10 * BONUS + COUNT
}
function: SEQ:s excluding EXCL:s {
  NEW: {}
  loop I over SEQ {
    if I = EXCL { I: 0 }
    NEW: {NEW, I}
  }
  result: NEW
}
function: highest of A:d and B:d with bonus and count excluding EXCL:s {
  AX: (#A) d [{1@A} excluding EXCL]
  BX: (#B) d [{1@B} excluding EXCL]
  result: [highest of AX and BX with bonus and count]
}
output [highest of 3d6 and 2d6 with bonus and count excluding 4d6]

Anydice realmente não rola nenhum dado , então você não pode criar os pools (a menos que eu seja errado) mas depois de ter os pools isso pode ser o que você precisa.

Você precisará inserir manualmente A, B e C (na parte superior) e depois calcular, selecionar "Roller" e rolar as duas saídas.

PS: não há 0.1 no Anydice, então se o número estiver presente duas vezes, adicione 100 no lugar.

//the pools for the results of your dices
A:{6,5,5}
B:{1,4}
C:{6,3,1,3}

//a simple function returning the greater of 2 numbers
function: maxi A and B {
 if A>B {
  result:A
 }
 else {
  result:B
 }
}

//creation of the two maximums initialized at -1 to be sure it doesn't overlap 
//(0 is fine too)
MAXA:-1
MAXB:-1

//counters, number_of_time_maximum_seen -1
TWICEA:0
TWICEB:0

//#A stand for the size of A
//the first loop, go from 1 to the size of A (first pool)
loop P over {1..#A}
{
 //P@A stand for the P-th value of A
 if !(P@A = C) {
  //if the P-th value of A is inside C (last pool), check if this maximum has been seen or not and take the appropriate action
  if MAXA = P@A {
   TWICEA : 1 + TWICEA
  }
  else {
   MAXA : [maxi MAXA and P@A]
   TWICEA: 0
  }
 }
}

//the number of dice in B not in C
COUNT:#B
loop P over {1..#B} 
{
 if (P@B = C){
  //if the P-th value of B is in C the count decrease by 1
  COUNT : COUNT - 1
 }
 //if the P-th value of B isn't in C the same thing as A (see A loop)
 else {
 if MAXB = P@B {
   TWICEB: 1 + TWICEB
  }
  else {
   MAXB : [maxi MAXB and P@B]
   TWICEB: 0
  }
 }

 //if the two maximum are equals the highest is the one seen the more
 if (MAXA = MAXB) {
  output MAXA + 100 * ([maxi TWICEA and TWICEB]!=0)
 }
 //if the maximums are not equals the greater win
 else if (MAXA >MAXB) {
  output MAXA+100*(TWICEA!=0) named "highest non-eliminated dice"
 }
 else {
  output MAXB+100*(TWICEB!=0) named "highest non-eliminated dice"
 }
}
output COUNT named "non-eliminated dice count in pool B".