Puoi utilizzare la distribuzione binomiale negativa per questo problema.

Se X è distribuito come NegBin (n, w), allora X è il numero di partite che il giocatore perde prima di vincerne n, se la probabilità di vincere un dato gioco è w.

Quindi, dnbinom (q = 2, size = 2, prob = w) è la probabilità che il giocatore perda un totale di 2 partite prima di vincerne 2.

Quindi, pnbinom (q = 2, size = 3, prob = w) è la probabilità che il giocatore perda 2 o meno prima di vincere 3 partite. Questo è uguale alla probabilità di vincere una serie di 3 su 5.

In generale, la probabilità di vincere una migliore n-out-of- (2n-1) serie può essere calcolata con pnbinom (q = n-1, size = n, prob = w) .

  ## w è la probabilità di vincere una singola partita
## k è il numero di vittorie necessarie per vincere la serie (3 in un migliore 3 di 5 serie)
win <- funzione (w, k) {
  ritorno (pnbinom (q = k - 1, dimensione = k, prob = w))
}

vincere (0,9, 3)
## 0.99144
 

In realtà ci sei quasi, ma dovresti essere a conoscenza dei casi con quattro e cinque partite da vincere.

  win <- funzione (w) dbinom (3,3, w) + w * dbinom (2,3, w) + w * dbinom (2,4, w)
 

o una soluzione compatta

  win <- funzione (w) w * sum (mapply (dbinom, 2,2: 4, w))
 

tale che

  > win (0.9)
[1] 0.99144
 

Explanation: Dato che il numero di partite necessarie per vincere la serie dipende dall'ultima vittoria:

• Se sono necessarie 3 partite: le prime due dovrebbero entrambe vincere, in modo che il problema. è w ** 3 (equivalentemente dbinom (3,3, w) o dbinom (2,2, w) * w )

• Se sono necessarie 4 partite: tra le tre partite precedenti dovrebbero esserci 2 vittorie e 1 sconfitta, in modo tale che il prob. è scegli (4,2) * w ** 2 * (1-w) * w (equivalentemente dbinom (2,4, w) * w )

• Se sono necessarie 5 partite: tra le quattro partite precedenti dovrebbero esserci sia 2 vittorie che 2 sconfitte, in modo tale che il problema è scegli (4,2) * w ** 2 * (1-w) ** 2 * w (equivalentemente dbinom (2,4, w) * w )

Update: generalizzazione di win

Rispetto a qualsiasi N (pari o dispari), una funzione generalizzata win può essere definita come di seguito

  win <- funzione (w, N) w * sum (mapply (dbinom, soffitto ((N-1) / 2), soffitto ((N-1) / 2) :( N-1) , w))
 

Tuttavia, quanto sopra non è efficiente per i N grandi. Invece, il metodo di distribuzione binomiale negativo menzionato da @RyanFrost è preferito per i casi con N grandi, cioè

  win <- funzione (w, N) pnbinom (floor ((N-1) / 2), soffitto ((N + 1) / 2), w)
 

Example

  > win (0.9,5) # necessita di 3 vittorie su 5 partite
[1] 0.99144

> win (0.9,6) # necessita di 4 vittorie su 6 partite
[1] 0.98415
 

Questo è interessante. Dimostriamo di utilizzare n = 3 dove sono necessarie 2 vittorie per essere il vincitore. Possiamo prima determinare quali combinazioni sono disponibili

  n = 3L
lst = replicate (n, 0: 1, semplificare = FALSE)
combo = do.call (expand.grid, lst)
combo

  Var1 Var2 Var3
1 0 0 0
2 1 0 0
3 0 1 0
4 1 1 0
5 0 0 1
6 1 0 1
7 0 1 1
8 1 1 1
 

Come hai notato, alcune di queste combinazioni non sono possibili. Siamo particolarmente interessati quando rowSums () sono uguali a 2. Usando questo possiamo capire quali combinazioni sono effettivamente possibili.

  possible_combos = combo [rowSums (combo) == soffitto (n / 2),]
possibili_combo

  Var1 Var2 Var3
4 1 1 0
6 1 0 1
7 0 1 1
 

Il nostro ultimo passaggio consiste nel calcolare ogni contributo dai nostri possibili contributi. Sappiamo che w ^ 2 sarà in ogni calcolo. La parte l è più complicata. Nella nostra prima possibile combinazione, l non contribuisce a nulla. Possiamo usare max.col (..., ties.method = "last") per calcolare quanti l si sono verificati:

  loss = max.col (possible_combos, ties.method = "last") - soffitto (n / 2)
perdite
# [1] 0 1 1

w = 0,9
l = 1 - w
wins_p = w ^ soffitto (n / 2)
loss_p = ifelse (loss == 0L, 1, l ^ loss)

p = somma (wins_p * loss_p)
p
# [1] 0.972
 

Per generalizzare questo, possiamo usarlo come una funzione basata su n e w :

  right = function (n, w) {
  lst = replicate (n, 0: 1, semplificare = FALSE)
  combo = do.call (expand.grid, lst)
  possibili_combos = combo [rowSums (combo) == soffitto (n / 2),]
  perdite = max.col (possible_combos, ties.method = "last") - soffitto (n / 2)

  l = 1 - w
  wins_p = w ^ soffitto (n / 2)
  loss_p = ifelse (loss == 0L, 1, l ^ loss)

  somma (wins_p * loss_p)
}

destra (5, 0.9)
# [1] 0.99144
destra (5, 0,9) + destra (5, 0,1)
# [1] 1

 

È una distribuzione binomiale:

  dbinom (3,5,0.9) + dbinom (4,5,0.9) + dbinom (5,5,0.9) = 0.99144
 

Il motivo è questo, devi solo pensare allo spazio totale, anche se ci sono già 3 vittorie o 4 vittorie, immaginiamo che l'evento continui e possiamo scrivere i possibili eventi da includere come:

  w.w.w: w.w.w.w.k, w.w.w.k.k, w.w.w.k.w, w.w.w.w, w
w.w.l.w: w.w.l.w.l, w.w.w.l.w
l.w.w.w: l.w.w.w.1, l.w.w.w.w
 

E così via ..

E quelli che hanno scritto come contenenti 3 vittorie per esempio (w.w.l.w.l) faranno parte di 5 scegli 3 in un binomio.

Su uno spazio totale di V / P su 5 eventi, ciò di cui abbiamo bisogno sono 3 vittorie, 4 vittorie e 5 vittorie per includere tutti gli eventi che possono portare la squadra a vincere (anche se nella vita reale, il 4 ° oLa quinta corrispondenza non si verificherà)

Ecco una funzione win che calcola la probabilità di vincere k su n partite con una probabilità di vincere ogni partita w .Implementa l'idea di questo post di Math.SE.

  win <- funzione (w, n = 5, k = 3) {
  funzione di < sciolta (w, n, k) {
    l <- 1 - w
    m <- n - k
    s <- seq_len (n - 1) [- seq_len (m - 1)]
    ch <- sapply (s, funzione (x) scegli (x, m))
    w <- w ^ (seq_along (s) - 1)
    l ^ m * somma (w * ch)
  }
  if (k > = soffitto (n / 2)) {
    1 - sciolto (w, n, k) * (1 - w)
  }altro{
    stop ("una minoranza non può vincere.")
  }
}
vincere (0.9)
# [1] 0.99144

vincere (0,1)
# [1] 0.00856

vittoria (0,9) + vittoria (0,1)
# [1] 1
 

Quello che stai chiedendo è un semplice problema di matematica. Proverò a spiegare la matematica passo dopo passo, poi scriveremo i nostri codici rispettando questo.

Matematica

Combinazione
In matematica, una combinazione è una selezione di elementi da una raccolta ed è definita come segue.



Dove ! è l'operatore fattoriale. Ad esempio, supponiamo di avere quattro round e di voler selezionare tre vittorie (o una perdente). Abbiamo:



Quali sono: w-w-w-l, w-w-l-w, w-l-w-w, l-w-w-w
Ma come hai detto, w-w-w-l non è accettabile perché il gioco è finito quando si ottengono 3 vittorie! Quindi dai un'occhiata a questo punto:

Se i nostri round richiedono più di 3 (meglio di 5), l'ultimo deve essere vinto se si desidera il calcolo della probabilità di vincita!

Quindi, per correggere i miei calcoli, dovrei prima selezionare l'ultimo round come vittoria e selezionare altri 2 posti (dai posti rimanenti) per vincere. Oppure



E se mostriamo la probabilità di vincita con w e di perdere con l la probabilità che si verifichi questo stato è

Javascript

Ora che conosci il concetto, iniziamo a scrivere codice!
Per prima cosa ho bisogno di una funzione per calcolare il fattoriale di n ( n! ).

  let f = (n) = >
{
    sia o = 1;
    per (i = 1; i< = n; i ++)
    {
        o * = i;
    }
    return o;
}
 

Per capire meglio la procedura, scriverò i miei codici passo dopo passo. Quindi il passaggio successivo è definire la funzione di combinazione.

  let c = (n, r) = >
{
    ritorno f (n) / (f (r) * f (n-r));
}
 

E ora è il momento di calcolare la probabilità di vittoria di r in una partita di round p con probabilità di vittoria di w .

  let _w = (p, r, w) = >
{
    sia o = 1;
    // Selezione delle posizioni vincenti
    o * = c (1,1) * c (p-1, r-1);
    // Probabilità di calcolo
o * = Math.pow (w, r) * Math.pow (1-w, p-r);

    return o;
}
 

Ora siamo pronti per creare la funzione BO (Best Of) con N round e K vittorie.

  sia BO = (N, K, w) = >
{
    // P è ciò che desideriamo trovare!
    sia P = 0;
    for (j = K; j< = N; j ++)
    {
        P + = _w (j, K, w);
    }
    ritorno P;
}
 

E alcuni esempi:

  console.log (BO (5,3,0.9));// 0.9914400000000001
console.log (BO (7,4,0.9));// 0.997272
console.log (BO (9,5,0.9));// 0.99910908