Escreva um programa ou função que, com uma probabilidade de sucesso p , um número n e um número de tentativas m retorne a chance de pelo menos n sucessos de m tentativas.

Sua resposta deve ser precisa com pelo menos 5 dígitos após o decimal.

Casos de teste:

 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

Geléia , 15 14 bytes

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

Lê m , n e p (nessa ordem) como argumentos da linha de comando. Experimente online!

Observe que essa abordagem requer tempo e memória de O (2 ^m ) , portanto, não é suficientemente eficiente para os casos de teste em que m = 100 . Na minha máquina, o caso de teste (m, n, p) = (20, 13, 0,5) leva aproximadamente 100 segundos. Requer muita memória para o intérprete online.

Como 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-#]&

Recebe entrada na ordem n,m,p. O Mathematica é tão bom que até aplica seu código para você:

BetaRegularizedé a função beta incompleta regularizada .

R, 32 31 bytes

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

editar - 1 byte alternando para a distribuição beta (nas linhas da resposta do @ Sp3000 Mathematica)

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

A fórmula recursiva para os coeficientes binomiais, exceto o caso base, m==0indica se o número restante de sucessos necessários né não-negativo, com True/Falsepara1/0 . Por causa de sua árvore de recursão exponencial, isso interrompe grandes entradas.

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 graças 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

A função arrayfun não é divertida, mas não encontrei uma maneira de me livrar dela ...

Pitão, 26 bytes

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

Experimente online!

Usa distribuição binomial cumulativa padrão.

Pitão, 20 bytes

JEKEcsmgsm<O0QKJCGCG

Experimente online!

Nota: CG é um número muito grande que o intérprete não pode manipular. Portanto, o número de tentativas foi reduzido para ^ T3, que é mil. Portanto, o link produz um resultado impreciso.

Usa abordagem probabilística pura.

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)

Salvo 1 byte usando reduce! Explicação:

(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)

Oitava, 26 bytes

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

Esta é uma função anônima. Para usá-lo, atribua-o a uma variável.

Experimente aqui .

MATL , 23 bytes

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

Entradas estão na ordem m, n, p.

Experimente online!

Isso faz um cálculo direto somando os termos de na mda função de probabilidade binomial (massa) .

Geléia , 18 17 bytes

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

Lê n , m e p (nessa ordem) como argumentos da linha de comando. Experimente online!

TI-Basic, 17 bytes

Precisas para 10 decimais, podem ser ajustadas de 0 a 14 decimais com mais 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 uma função (%). Chame assim (%) 0.4 2 3.

Mathematica, 48 bytes

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

Usa a fórmula de probabilidade de distribuição binomial para calcular a chance de k sucessos de k de n a m . Manipula os casos de borda usando uma soma simbólica em que s é uma variável simbólica para a probabilidade que é posteriormente substituída pelo valor real p . (Como s ⁰ = 1, mas 0 ⁰ é indeterminado.)