Schreiben Sie ein Programm oder eine Funktion, die bei einer Erfolgswahrscheinlichkeit p , einer Zahl n und einer Anzahl von Versuchen m die Chance von mindestens n Erfolgen aus m Versuchen zurückgibt .

Ihre Antwort muss auf mindestens 5 Nachkommastellen genau sein.

Testfälle:

 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

Gelee , 15 14 Bytes

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

Liest m , n und p (in dieser Reihenfolge) als Befehlszeilenargumente. Probieren Sie es online aus!

Beachten Sie, dass dieser Ansatz erfordert O (2 ^m ) Zeit und Speicher, so dass es nicht ist ziemlich effizient genug für den Test Fälle , in denen m = 100 . Auf meiner Maschine dauert der Testfall (m, n, p) = (20, 13, 0,5) ungefähr 100 Sekunden. Der Online-Interpreter benötigt zu viel Speicher.

Wie es funktioniert

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

Nimmt Eingaben in der Reihenfolge vor n,m,p. Mathematica ist so gut, dass es sogar Ihren Code für Sie spielt:

BetaRegularizedist die regulierte unvollständige Beta-Funktion .

R, 32 31 Bytes

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

edit - 1 Byte Umschaltung auf Beta-Distribution (nach dem Vorbild von @ 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

Die rekursive Formel für Binomialkoeffizienten mit Ausnahme des Basisfalls m==0gibt an, ob die verbleibende Anzahl der erforderlichen Erfolge nicht nnegativ ist, mit True/Falsez1/0 . Aufgrund seines exponentiellen Rekursionsbaums bleibt dies bei großen Eingaben stehen.

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

7 Bytes dank Luis Mendo gespart!

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

Die Arrayfun-Funktion macht keinen Spaß, aber ich habe keinen Weg gefunden, sie loszuwerden ...

Pyth, 26 Bytes

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

Probieren Sie es online aus!

Verwendet die kumulative Binomialverteilung.

Pyth, 20 Bytes

JEKEcsmgsm<O0QKJCGCG

Probieren Sie es online aus!

Hinweis: CG ist eine sehr große Zahl, die der Interpreter nicht verarbeiten kann. Daher wurde die Anzahl der Versuche auf ^ T3 gesenkt, was eintausend ist. Daher führt die Verknüpfung zu einem ungenauen Ergebnis.

Verwendet einen rein probabilistischen Ansatz.

JavaScript (ES7), 82 Byte

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

1 Byte mit reduce! Gespeichert ! Erläuterung:

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

Oktave, 26 Bytes

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

Dies ist eine anonyme Funktion. Um es zu verwenden, weisen Sie es einer Variablen zu.

Probieren Sie es hier aus .

MATL , 23 Bytes

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

Die Eingänge sind in der Reihenfolge m, n, p.

Probieren Sie es online aus!

Dies führt eine direkte Berechnung durch, bei der die Terme von nbis mder Binomialwahrscheinlichkeits- (Massen-) Funktion summiert werden .

Gelee , 18 17 Bytes

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

Liest n , m und p (in dieser Reihenfolge) als Befehlszeilenargumente. Probieren Sie es online aus!

TI-Basic, 17 Bytes

Präzise bis 10 Dezimalstellen, können mit mehr Code zwischen 0 und 14 Dezimalstellen eingestellt werden.

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

Definiert eine Funktion (%). Nennen wir es wie (%) 0.4 2 3.

Mathematica, 48 Bytes

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

Verwendet die Binomialverteilungswahrscheinlichkeitsformel, um die Wahrscheinlichkeit von k Erfolgen für k von n bis m zu berechnen . Behandelt die Randfälle unter Verwendung einer symbolischen Summe, wobei s eine symbolische Variable für die Wahrscheinlichkeit ist, die später durch den tatsächlichen Wert p ersetzt wird . (Da s ⁰ = 1 ist, aber 0 ⁰ unbestimmt ist.)