Planteamiento del problema

Pólya está jugando de nuevo con su urna y quiere que lo ayudes a calcular algunas probabilidades.

En este experimento de urna, Pólya tiene una urna que inicialmente contiene 1 cuenta roja y 1 cuenta azul.

Para cada iteración, alcanza y recupera una cuenta, luego inspecciona el color y coloca la cuenta nuevamente en la urna.

Luego lanza una moneda justa, si la moneda aterriza caras, insertará una cantidad justa de 6 caras del mismo color en la urna, si aterriza colas, eliminará la mitad del número de la misma cuenta de color de la urna ( Uso de la división de enteros, por lo que si el número de cuentas del color seleccionado es impar, eliminará (c-1)/2donde c es el número de cuentas de ese color)

Dado un número entero n ≥ 0 y un decimal r> 0, dé la probabilidad a 2 decimales de que la relación entre los colores de las cuentas después de n iteraciones es mayor o igual que r en el menor número de bytes.

Un conjunto de ejemplos de iteraciones:

Deje que (x, y) defina la urna de modo que contenga x cuentas rojas e y cuentas azules.

Iteration    Urn       Ratio
0            (1,1)     1
1            (5,1)     5        //Red bead retrieved, coin flip heads, die roll 4
2            (5,1)     5        //Blue bead retrieved, coin flip tails
3            (3,1)     3        //Red bead retrieved, coin flip tails
4            (3,4)     1.333... //Blue bead retrieved, coin flip heads, die roll 3

Como se puede ver, la relación r es siempre ≥ 1 (por lo que es el mayor de rojo o azul dividido por el menor)

Casos de prueba:

Deje que F (n, r) defina la aplicación de la función para n iteraciones y una relación de r

F(0,5) = 0.00
F(1,2) = 0.50
F(1,3) = 0.42
F(5,5) = 0.28
F(10,4) = 0.31
F(40,6.25) = 0.14

Este es el código de golf, por lo que gana la solución más corta en bytes.

JavaScript (ES7),  145 ...  129124 123 bytes

Toma entrada como (r)(n). Esta es una solución ingenua que realmente realiza la simulación completa.

r=>g=(n,B=s=0,R=0,h=d=>++d<7?h(d,[0,d].map(b=>g(n,B/-~!!b,R/-~!b)&g(n,B+b,R+d-b))):s/24**-~n)=>n--?h``:s+=~B<=r*~R|~R<=r*~B

Pruébalo en línea!

Demasiado lento para los últimos 2 casos de prueba.

Comentado

r =>                    // r = target ratio
g = (                   // g is a recursive function taking:
  n,                    //   n = number of iterations
  B =                   //   B = number of blue beads, minus 1
  s = 0,                //   s = number of times the target ratio was reached
  R = 0,                //   R = number of red beads, minus 1
  h = d =>              //   h = recursive function taking d = 6-sided die value
    ++d < 7 ?           // increment d; if d is less than or equal to 6:
      h(                //   do a recursive call to h:
        d,              //     using the new value of d
        [0, d].map(b => //     for b = 0 and b = d:
          g(            //       do a first recursive call to g:
            n,          //         leave n unchanged
            B / -~!!b,  //         divide B by 2 if b is not equal to 0
            R / -~!b    //         divide R by 2 if b is equal to 0
          ) & g(        //       do a second recursive call to g:
            n,          //         leave n unchanged
            B + b,      //         add b blue beads
            R + d - b   //         add d - b red beads
          )             //       end of recursive calls to g
        )               //     end of map()
      )                 //   end of recursive call to h
    :                   // else (d > 6):
      s / 24 ** -~n     //   stop recursion and return s / (24 ** (n + 1))
) =>                    // body of g:
  n-- ?                 //   decrement n; if n was not equal to 0:
    h``                 //     invoke h with d = [''] (coerced to 0)
  :                     //   else:
    s +=                //     increment s if:
      ~B <= r * ~R |    //       either (-B-1) <= r*(-R-1), i.e. (B+1)/(R+1) >= r
      ~R <= r * ~B      //       or     (-R-1) <= r*(-B-1), i.e. (R+1)/(B+1) >= r

Wolfram Language (Mathematica) , 133 bytes

Length@Select[#2/#&@@@(r=Nest[Sort/@Flatten[Table[{{k,0}+#,⌈#/{1,2}⌉},{k,6}]&/@Join[#,Reverse/@#],2]&,{{1,1}},x]),#>=y&]/Length@r

Al usar N[F,2], la salida debe imprimir 2 dígitos decimales pero TIO imprime más ...

Pruébalo en línea!