11

Scrivi un programma o una funzione, che data una probabilità di successo p , un numero n e un numero di prove m restituisce la possibilità di almeno n successi su m prove.

La tua risposta deve essere precisa di almeno 5 cifre dopo il decimale.

Casi test:

 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

code-golf math probability-theory

— orlp
fonte

3

Ti andrebbe di includere una formula per quelli di noi che non hanno studiato la distribuzione binomiale?

— Leaky Nun,

2

@KennyLau Siamo spiacenti, fa parte della sfida.

— orlp,

3

Gelatina , 15 14 byte

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

Letture m , n e p (in questo ordine) come argomenti della riga di comando. Provalo online!

Si noti che questo approccio richiede tempo di O (2 ^m ) e memoria, quindi non è abbastanza efficiente per i casi di test in cui m = 100 . Sulla mia macchina, il test case (m, n, p) = (20, 13, 0,5) richiede circa 100 secondi. Richiede troppa memoria per l'interprete online.

Come funziona

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.

— Dennis
fonte

9

Mathematica, 29 byte

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

Accetta input nell'ordine n,m,p. Mathematica è così buona che ti dà persino il golf:

inserisci qui la descrizione dell'immagine

BetaRegularizedè la funzione beta incompleta regolarizzata .

— SP3000
fonte

6

R, 32 31 byte

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

modifica - 1 byte che passa alla distribuzione beta (sulla falsariga di @ Sp3000 Mathematica Answer)

— mnel
fonte

3

Python, 57 byte

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 formula ricorsiva per i coefficienti binomiali, ad eccezione del caso base, m==0indica se il numero rimanente di successi richiesti nnon è negativo, con True/Falsefor1/0 . A causa del suo albero di ricorsione esponenziale, questo si blocca su input di grandi dimensioni.

— XNOR
fonte

Per provare questa risposta per casi di grandi dimensioni, aggiungere la memorizzazione nella cache utilizzando from functools import lru_cache; f = lru_cache(None)(f).

— orlp,

@orlp Grazie, ho confermato i casi di test di grandi dimensioni.

— xnor

3

Haskell, 73 byte

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

— Damien
fonte

3

MATLAB, 78 71 byte

Risparmiato 7 byte grazie 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 funzione arrayfun non è divertente, ma non ho trovato il modo di liberarmene ...

— Stewie Griffin
fonte

1

Pyth, 26 byte

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

Provalo online!

Utilizza la distribuzione binomiale cumulativa standard.

— Perdente Suora
fonte

1

Pyth, 20 byte

JEKEcsmgsm<O0QKJCGCG

Provalo online!

Nota: CG è un numero molto grande che l'interprete non può gestire. Pertanto, il numero di prove è stato ridotto a ^ T3 che è mille. Pertanto, il collegamento produce un risultato impreciso.

Utilizza un approccio probabilistico puro.

— Perdente Suora
fonte

Non credo che un approccio probabilistico sarebbe valido per questa domanda, ma dovremmo chiedere a @orlp

— Sp3000,

È necessario nell'ordine di 1 / c ^ 2 prove per ottenere l'accuratezza c con alta probabilità, quindi sarebbe ~ 10 ^ 10 per cinque cifre decimali.

— xnor

CG è un numero molto grande. In effetti, è la stringa "abc ... z" convertita da base-256 a decimale.

— Leaky Nun,

2

Se "probabilstic" significa random, non è possibile garantire un valore preciso, indipendentemente da quante realizzazioni si media. In effetti, il risultato è diverso ogni volta.

— Luis Mendo,

2

Esiste sempre una probabilità diversa da zero che il risultato non sia accurato con 5 cifre decimali. Pertanto non soddisfa i requisiti La tua risposta deve essere precisa per almeno 5 cifre

— Luis Mendo,

1

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)

Salvato 1 byte usando reduce! Spiegazione:

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

— Neil
fonte

1

Ottava, 26 byte

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

Questa è una funzione anonima. Per usarlo, assegnalo a una variabile.

Provalo qui .

— Luis Mendo
fonte

1

MATL , 23 byte

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

Gli ingressi sono in ordine m, n, p.

Provalo online!

Questo esegue un calcolo diretto sommando i termini da na mdella funzione di probabilità binomiale (massa) .

— Luis Mendo
fonte

1

Gelatina , 18 17 byte

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

Legge n , m e p (in quell'ordine) come argomenti della riga di comando. Provalo online!

— Dennis
fonte

0

TI-Basic, 17 byte

Preciso a 10 decimali, può essere regolato ovunque da 0-14 decimali con più codice.

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

— Timtech
fonte

0

Haskell, 54 byte

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

Definisce una funzione (%). Chiamalo come (%) 0.4 2 3.