Vous pouvez utiliser la distribution binomiale négative pour ce problème.

Si X est distribué sous la forme NegBin (n, w), alors X est le nombre de parties que le joueur perd avant d'en gagner n, si la probabilité de gagner une partie donnée est w.

Donc, dnbinom (q = 2, size = 2, prob = w) est la probabilité que le joueur perd un total de 2 parties avant de gagner 2.

Ensuite, pnbinom (q = 2, size = 3, prob = w) est la probabilité que le joueur en perde 2 ou moins avant de gagner 3 parties. Ceci est égal à la probabilité de gagner une série 3 sur 5.

En général, la probabilité de gagner une meilleure série n-sur- (2n-1) peut être calculée avec pnbinom (q = n-1, size = n, prob = w) .

  ## w est la probabilité de gagner une partie individuelle
## k est le nombre de victoires nécessaires pour remporter la série (3 dans les 3 meilleures des 5 séries)
win <- fonction (w, k) {
  retour (pnbinom (q = k - 1, taille = k, prob = w))
}

gagner (0.9, 3)
## 0.99144
 

En fait, vous y êtes presque, mais vous devez être conscient des cas avec quatre et cinq matchs à gagner.

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

ou une solution compacte

  win <- fonction (w) w * somme (mapply (dbinom, 2,2: 4, w))
 

tel que

  > win (0.9)
[1] 0.99144
 

Explication: Étant donné que le nombre de parties nécessaires pour gagner la série dépend de la dernière victoire:

• Si 3 jeux sont nécessaires: les deux premiers devraient tous les deux gagner, de sorte que le prob. est w ** 3 (de manière équivalente dbinom (3,3, w) ou dbinom (2,2, w) * w )

• Si 4 parties sont nécessaires: parmi les trois parties précédentes, il devrait y avoir 2 victoires et 1 défaite, de sorte que le prob. est choose (4,2) * w ** 2 * (1-w) * w (de manière équivalente dbinom (2,4, w) * w )

• Si 5 parties sont nécessaires: parmi les quatre parties précédentes, il devrait y avoir à la fois 2 victoires et 2 défaites, de sorte que le prob. est choose (4,2) * w ** 2 * (1-w) ** 2 * w (de manière équivalente dbinom (2,4, w) * w )

Update: Généralisation de win

Par rapport à tout N (pair ou impair), une fonction généralisée win peut être définie comme ci-dessous

  win <- fonction (w, N) w * somme (mapply (dbinom, plafond ((N-1) / 2), plafond ((N-1) / 2) :( N-1) , w))
 

Cependant, ci-dessus n'est pas aussi efficace pour les grands N s. Au lieu de cela, la méthode de distribution binomiale négative mentionnée par @RyanFrost est préférée pour les cas avec de grands N s, c'est-à-dire

  win <- fonction (w, N) pnbinom (plancher ((N-1) / 2), plafond ((N + 1) / 2), w)
 

Example

  > win (0.9,5) # besoins à 3 victoires sur 5 matchs
[1] 0.99144

> gagne (0.9,6) # besoins à 4 victoires sur 6 matchs
[1] 0,98415
 

C'est intéressant. Démontrons en utilisant n = 3 où il faut 2 victoires pour être le gagnant. Nous pouvons d'abord déterminer quelles combinaisons sont disponibles

  n = 3L
lst = répliquer (n, 0: 1, simplifier = FALSE)
combos = do.call (expand.grid, lst)
combos

  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
 

Comme vous l'avez noté, certaines de ces combinaisons ne sont pas possibles. Nous sommes particulièrement intéressés lorsque les rowSums () sont égaux à 2. En utilisant cela, nous pouvons déterminer quelles combinaisons sont réellement possibles.

  possible_combos = combos [rowSums (combos) == plafond (n / 2),]
possible_combos

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

Notre dernière étape consiste à calculer chaque contribution à partir de nos contributions possibles. Nous savons que w ^ 2 sera dans chaque calcul. La partie l est plus compliquée. Dans notre première combinaison possible, le l n'apporte rien. Nous pouvons utiliser max.col (..., ties.method = "last") pour déterminer combien de l s se sont produits:

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

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

p = somme (wins_p * pertes_p)
p
# [1] 0,972
 

Pour généraliser cela, nous pouvons l'utiliser comme une fonction basée sur n et w :

  droite = fonction (n, w) {
  lst = répliquer (n, 0: 1, simplifier = FALSE)
  combos = do.call (expand.grid, lst)
  possible_combos = combos [rowSums (combos) == plafond (n / 2),]
  pertes = max.col (possible_combos, tie.method = "last") - plafond (n / 2)

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

  somme (wins_p * pertes_p)
}

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

 

C'est une distribution binomiale:

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

La raison est la suivante, il vous suffit de penser à l'espace total, même s'il y a déjà 3 victoires ou 4 victoires, imaginons que l'événement continue et nous pouvons écrire les événements possibles à inclure comme suit:

  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
 

Et ainsi de suite ..

Et ceux qui ont écrit comme contenant 3 victoires par exemple (w.w.l.w.l) feront partie de 5 choisissent 3 dans un binôme.

Sur l'espace total de W / L sur 5 événements, nous avons besoin de 3 victoires, 4 victoires et 5 victoires pour inclure tous les événements qui peuvent amener l'équipe à gagner (même si dans la vraie vie, le 4e ouLe cinquième match n'aura pas lieu)

Voici une fonction win qui calcule la probabilité de gagner k sur n parties avec une probabilité de gagner chaque partie w .Il met en œuvre l'idée de ce message Math.SE.

  win <- fonction (w, n = 5, k = 3) {
  lâche fonction <- (w, n, k) {
    l <- 1 - w
    m <- n - k
    s <- seq_len (n - 1) [- seq_len (m - 1)]
    ch <- sapply (s, fonction (x) choisir (x, m))
    w <- w ^ (seq_along (s) - 1)
    l ^ m * somme (w * ch)
  }
  if (k > = plafond (n / 2)) {
    1 - lâche (w, n, k) * (1 - w)
  }autre{
    stop ("une minorité ne peut pas gagner.")
  }
}
gagner (0,9)
# [1] 0.99144

gagner (0,1)
# [1] 0,00856

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

Ce que vous demandez, c'est un simple problème de mathématiques. J'essaierai d'expliquer les mathématiques étape par étape, puis nous écrirons nos codes en conséquence.

Mathématiques

Combination
En mathématiques, une combinaison est une sélection d'éléments d'une collection et se définit comme suit.



Où ! est l'opérateur factoriel. Par exemple, supposons que nous ayons quatre tours et que vous vouliez sélectionner trois victoires (ou une perdue). Nous avons:



Qui sont: w-w-w-l, w-w-l-w, w-l-w-w, l-w-w-w
Mais comme vous l'avez mentionné, w-w-w-l n'est pas acceptable car le jeu est terminé lorsque 3 victoires sont accomplies! Alors regardez bien ce point:

Si nos tours prennent plus de 3 (meilleur des 5), le dernier doit être gagnant si le calcul de la probabilité de gagner est souhaité!

Donc, pour corriger mes calculs, je dois d'abord sélectionner le dernier tour comme gagnant et sélectionner 2 autres places (parmi les places restantes) pour gagner. Ou



Et si nous montrons la probabilité de gagner avec w et de perdre avec l , la probabilité que cet état se produise est

Javascript

Maintenant que vous connaissez le concept, commençons à coder!
J'ai d'abord besoin d'une fonction pour calculer la factorielle de n ( n! ).

  let f = (n) = >
{
    soit o = 1;
    pour (i = 1; i< = n; i ++)
    {
        o * = i;
    }
    retour o;
}
 

Pour mieux comprendre la procédure, j'écrirai mes codes étape par étape. L'étape suivante consiste donc à définir la fonction de combinaison.

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

Et maintenant, il est temps de calculer la probabilité de gains de r dans un jeu à tour de p avec une probabilité de victoire de w .

  let _w = (p, r, w) = >
{
    soit o = 1;
    // Sélection des positions gagnantes
    o * = c (1,1) * c (p-1, r-1);
    // Probabilité de calcul
o * = Math.pow (w, r) * Math.pow (1-w, p-r);

    retour o;
}
 

Nous sommes maintenant prêts à faire la fonction BO (Best Of) avec N tours et K victoires.

  let BO = (N, K, w) = >
{
    // P est ce que nous souhaitons trouver!
    soit P = 0;
    pour (j = K; j< = N; j ++)
    {
        P + = _w (j, K, w);
    }
    return P;
}
 

Et quelques exemples:

  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