Escriba un programa o función, que dada una probabilidad de éxito p , un número ny una cantidad de intentos m devuelve la posibilidad de al menos n éxitos de m intentos.

Su respuesta debe ser precisa al menos 5 dígitos después del decimal.

Casos de prueba:

 0.1, 10, 100 -> 0.54871
 0.2, 10, 100 -> 0.99767
 0.5, 13,  20 -> 0.13159
 0.5,  4,   4 -> 0.06250
0.45, 50, 100 -> 0.18273
 0.4, 50, 100 -> 0.02710
   1,  1,   2 -> 1.00000
   1,  2,   1 -> 0.00000
   0,  0,   1 -> 1.00000
   0,  0,   0 -> 1.00000
   0,  1,   1 -> 0.00000
   1,  1,   0 -> 0.00000

Jalea , 15 14 bytes

2ṗ’S<¥ÐḟCạ⁵P€S

Lee m , n y p (en ese orden) como argumentos de línea de comandos. Pruébalo en línea!

Tenga en cuenta que este enfoque requiere O (2 ^m ) de tiempo y memoria, por lo que no es lo suficientemente eficiente para los casos de prueba donde m = 100 . En mi máquina, el caso de prueba (m, n, p) = (20, 13, 0.5) toma aproximadamente 100 segundos. Requiere demasiada memoria para el intérprete en línea.

Cómo funciona

2ṗ              Cartesian product; yield all vectors of {1, 2}^n.
  ’             Decrement, yielding all vectors of {0, 1}^n.
      Ðḟ        Filter; keep elements for which the link to the left yields False.
     ¥          Combine the two links to the left into a dyadic chain.
   S              Sum, counting the number of ones.
    <             Compare the count with n. 
        C       Complement; map z to 1 - z.
         ạ⁵     Compute the absolute difference with p.
           P€   Compute the product of each list.
             S  Compute the sum of all products.

Mathematica, 29 bytes

BetaRegularized[#3,#,1+#2-#]&

Toma entrada en el orden n,m,p. Mathematica es tan bueno que incluso te muestra el código:

BetaRegularizedes la función beta incompleta regularizada .

R, 32 31 bytes

function(p,n,m)pbeta(p,m,1+n-m)

edit - 1 byte cambiando a distribución beta (en la línea de @ Sp3000 Mathematica Answer)

Python, 57 bytes

f=lambda p,n,m:m and(1-p)*f(p,n,m-1)+p*f(p,n-1,m-1)or n<1

La fórmula recursiva para los coeficientes binomiales, excepto el caso base m==0indica si el número restante de éxitos requeridos nno es negativo, con True/Falsefor1/0 . Debido a su árbol de recursión exponencial, esto se detiene en entradas grandes.

Haskell, 73 bytes

g x=product[1..x];f p n m=sum[g m/g k/g(m-k)*p**k*(1-p)**(m-k)|k<-[n..m]]

MATLAB, 78 71 bytes

¡Guardado 7 bytes gracias a Luis Mendo!

@(m,k,p)sum(arrayfun(@(t)prod((1:m)./[1:t 1:m-t])*p^t*(1-p)^(m-t),k:m))

ans(100,10,0.1)
0.5487

La función arrayfun no es divertida, pero no he encontrado una manera de deshacerme de ella ...

Pyth, 26 bytes

AQJEsm**.cHd^Jd^-1J-HdrGhH

Pruébalo en línea!

Utiliza distribución binomial acumulativa estándar.

Pyth, 20 bytes

JEKEcsmgsm<O0QKJCGCG

Pruébalo en línea!

Nota: CG es un número muy grande que el intérprete no puede manejar. Por lo tanto, el número de pruebas se ha reducido a ^ T3, que es mil. Por lo tanto, el enlace produce un resultado inexacto.

Utiliza un enfoque probabilístico puro.

JavaScript (ES7), 82 bytes

(p,n,m)=>[...Array(++m)].reduce((r,_,i)=>r+(b=!i||b*m/i)*p**i*(1-p)**--m*(i>=n),0)

¡Guardado 1 byte usando reduce! Explicación:

(p,n,m)=>               Parameters
 [...Array(++m)].       m+1 terms
  reduce((r,_,i)=>r+    Sum
   (b=!i||b*m/i)*       Binomial coefficient
   p**i*(1-p)**--m*     Probability
   (i>=n),              Ignore first n terms
   0)

Octava, 26 bytes

@(p,n,m)1-binocdf(n-1,m,p)

Esta es una función anónima. Para usarlo, asígnelo a una variable.

Pruébalo aquí .

MATL , 23 bytes

y2$:Xni5M^1IG-lG7M-^**s

Las entradas están en el orden m, n, p.

Pruébalo en línea!

Esto hace un cálculo directo sumando los términos de na mde la función binomial de probabilidad (masa) .

Jalea , 18 17 bytes

⁵C*ạ×⁵*¥×c@
R’çSC

Lee n , m y p (en ese orden) como argumentos de línea de comandos. Pruébalo en línea!

TI-Basic, 17 bytes

Preciso a 10 decimales, se puede ajustar en cualquier lugar de 0-14 decimales con más código.

Prompt P,N,M:1-binomcdf(M,P,N-1

Haskell, 54 bytes

(p%n)m|m<1=sum[1|n<1]|d<-m-1=(1-p)*(p%n)d+p*(p%(n-1))d

Define una función (%). Llámalo como (%) 0.4 2 3.

Mathematica, 48 bytes

Sum[s^k(1-s)^(#3-k)#3~Binomial~k,{k,##2}]/.s->#&

Utiliza la fórmula probabilidad de distribución binomial para calcular la probabilidad de k éxitos para k de n a m . Maneja los casos límite utilizando una suma simbólica donde s es una variable simbólica para la probabilidad que luego se reemplaza con el valor real p . (Dado que s ⁰ = 1 pero 0 ⁰ es indeterminado).