7 votos

¿Cómo calcular las probabilidades para un mecánico de eliminación de tres piscina?

He estado luchando para conseguir mi cabeza alrededor de esta reserva de dados mecánico, ya sea en anydice o incluso un programa a medida.

Hay 3 piscinas de d6, llamar a, B Y C:

A: ad6
B: bd6 
C: cd6

Cualquier dados en las piscinas de a y B que coinciden con los dados en el grupo C son removidos de sus respectivos piscina.

El resultado es el más alto no eliminado dados en el grupo a o B (+0.1 si más de 1) y necesitamos saber el número total de dados (no sus valores) de los no eliminados dados en el grupo B.

Por ejemplo:

A: 3d6
B: 2d6
C: 4d6

Example 1
A: {6,2,6}  -> {6,2,6}
B: {2,1}    -> {2,1} 
C: {3,3,5,4}
Result: 6.1,2

Example 2
A: {5,1,6}  -> {5,x,x}
B: {1,4}    -> {x,x}
C: {1,6,6,4}
Result: 5,0

Example 3
A: {3,2,6}  -> {3,x,6}
B: {5,4}    -> {5,x}
C: {4,1,4,2}
Result: 6,1

Example 4
A: {6,5,5}  -> {x,5,5}
B: {1,4}    -> {x,4}
C: {6,3,1,3}
Result: 5.1,1

El mecánico es de Technoir.

¿Cómo puedo modelo de esto?

6voto

Aissen Puntos 131

Es (todavía) no se exactamente lo que estás pidiendo, pero he aquí un AnyDice programa que devuelve el mayor en un rollo de los dados de la piscina, con exclusión de cualquier dados lanzados en otro grupo:

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]

Utiliza algunos bastante complicado, AnyDice de la sintaxis, así que permítanme explicar algunos de los detalles:

  • Cuando se pasa de una matriz a de un AnyDice función que espera una secuencia (como EXCL:s por encima de), AnyDice se ejecuta la función para cada posible rollo de los dadosy sumar los resultados (ponderado por la probabilidad de cada uno de los rollos). Esto es básicamente una aproximación de fuerza bruta, y fácilmente se puede tiempo de espera para dados grandes piscinas, pero es muy versátil cuando se trabaja. Esta es la forma en que yo soy el manejo de la exclusión mecánico de aquí.

  • #DICE da el número de dados en la piscina, DICEy {1@DICE} da los valores posibles de una sola morir en la piscina. Es decir, si DICE = 3d6, a continuación, #DICE = 3 y {1@DICE} = {1, 2, 3, 4, 5, 6}.

  • Cuando usted compara un número de secuencia (como en I = EXCL), el resultado será verdadero (distinto de cero) si la comparación es verdadera para cualquier elemento de la secuencia. Que es, if I = EXCL básicamente comprueba si I pertenece a la secuencia EXCL.

Así que lo que el bucle dentro de la función que hace es construir una costumbre de morir NEW que se ve como uno de los dados en DICE, pero con cualquiera de los lados coincidentes EXCL sustituye por 0. A continuación, POOL: (#DICE) d NEW crea una nueva costumbre de reserva de dados que consiste en que muchos de esos personalizado dados como el que había en la piscina original, DICE, y el final de la línea devuelve el resultado más alto en la piscina.


Llegar un poco más cerca, aquí está una versión que añade el bono para múltiples igual más alto de los dados:

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]

Desde AnyDice no admite los números fraccionarios, estoy multiplicando el resultado de la tirada por 10, de modo que, por ejemplo, un resultado de 5.1 (= 5 + 0.1 bono) es representado como 51.

El código anterior es exactamente el mismo como el primer programa anterior, excepto que he reemplace 1@POOL con una llamada a una función auxiliar que añade la bonificación si el más alto del rollo se produce varias veces (y no es cero). La función auxiliar se utiliza el mismo truco de tomar el rollo en una secuencia con :s, por lo que se pone automáticamente itera sobre cada posible resultado de la tirada.


Finalmente, he aquí un programa que calcula el número de los no excluidos dados en el grupo 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]

Es el mismo que el primer programa, excepto que ahora estamos etiquetado de los lados de nuestro sistema personalizado de dados con 0 si están en la lista de exclusión, y 1 de otro modo, y tomando luego la suma de la bobina como el resultado.

El problema es combinar estos programas, para tener en cuenta el hecho de que ambos grupos a y B dependen de la piscina C simultáneamente. El problema es que AnyDice realmente no manejar dos dimensiones de salida bien, pero podemos usar el mismo truco que usamos para manejar el 0.1 bono anterior, multiplicando el resultado de la piscina Un adicional del 10 antes de añadir el resultado del grupo B, como este:

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"

Aquí, la salida se compone de un número de tres dígitos PQR, donde P es el más alto de no excluye rollo en el grupo A, Q es 1 si la máxima de no excluye rodar en grupo es múltiple, y R es el número de los no excluidos los rollos en el grupo B.


Oh, espera! Usted dijo que quería el más alto del rollo en las piscinas a y B juntos, no sólo el más alto en Un rollo? Bueno, yo puedo hacer eso, demasiado, aunque sí requiere un poco de reorganización, ya que la mayor roll ya no es independiente del número de los no excluidos los rollos en el grupo 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]

0voto

Rob Mensching Puntos 20732

Anydice no, en realidad rollo de los dados, de modo que no puede crear las piscinas (a menos que me equivoque) pero una vez que las piscinas esto puede ser lo que usted necesita.

Usted tendrá que introducir manualmente a,B y C (en la parte superior) y, a continuación, calcular, seleccionar "Rodillo" y el rollo de las dos salidas.

PS : no hay 0,1 Anydice , por lo que si el número está presente dos veces se añaden 100 en su 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".

JugonesTop.com

Jugonestop es una comunidad para amantes del gaming. Puedes hacer tus propias preguntas o resolver las de los demás.

Powered by:

X