Sie können für dieses Problem die negative Binomialverteilung verwenden.

Wenn X als NegBin (n, w) verteilt ist, ist X die Anzahl der Spiele, die der Spieler verliert, bevor er n davon gewinnt, wenn die Wahrscheinlichkeit, ein bestimmtes Spiel zu gewinnen, w ist.

dnbinom (q = 2, size = 2, prob = w) ist die Wahrscheinlichkeit, dass der Spieler insgesamt 2 Spiele verliert, bevor er 2 gewinnt.

Dann ist pnbinom (q = 2, Größe = 3, prob = w) die Wahrscheinlichkeit, dass der Spieler 2 oder weniger verliert, bevor er 3 Spiele gewinnt. Dies entspricht der Wahrscheinlichkeit, eine 3 von 5 Serien zu gewinnen.

Im Allgemeinen kann die Wahrscheinlichkeit, eine beste n-aus-(2n-1) -Serie zu gewinnen, mit pnbinom (q = n-1, Größe = n, prob = w) code berechnet werden >.

  ## w ist die Wahrscheinlichkeit, ein einzelnes Spiel zu gewinnen
## k ist die Anzahl der Siege, die benötigt werden, um die Serie zu gewinnen (3 in einer besten 3 von 5 Serie)
win <- Funktion (w, k) {
  return (pnbinom (q = k - 1, Größe = k, prob = w))
}}

gewinnen (0,9, 3)
## 0,99144
 

Eigentlich sind Sie fast da, aber Sie sollten sich der Fälle bewusst sein, in denen vier und fünf Spiele zu gewinnen sind.

  gewinnt die <-Funktion (w) dbinom (3,3, w) + w * dbinom (2,3, w) + w * dbinom (2,4, w)
 

oder eine kompakte Lösung

  win <- Funktion (w) w * sum (Mapply (dbinom, 2,2: 4, w))
 

so dass

  > gewinnt (0,9)
[1] 0,99144
 

Explanation: Da die Anzahl der Spiele, die zum Gewinnen der Serie benötigt werden, vom letzten Gewinn abhängt:

• Wenn 3 Spiele benötigt werden: Die ersten beiden sollten beide gewinnen, so dass der Prob. ist w ** 3 (äquivalent dbinom (3,3, w) oder dbinom (2,2, w) * w )

• Wenn 4 Spiele benötigt werden: Unter den vorherigen drei Spielen sollte es 2 Siege und 1 Niederlage geben, so dass der Prob. ist wähle (4,2) * w ** 2 * (1-w) * w (äquivalent dbinom (2,4, w) * w )

• Wenn 5 Spiele benötigt werden: Unter den vorherigen vier Spielen sollten sowohl 2 Siege als auch 2 Niederlagen liegen, so dass der Prob. ist wähle (4,2) * w ** 2 * (1-w) ** 2 * w (äquivalent dbinom (2,4, w) * w )

Update: Verallgemeinerung von win

In Bezug auf jedes N (entweder gerade oder ungerade) kann eine verallgemeinerte Funktion win wie folgt definiert werden

  win <- Funktion (w, N) w * sum (Mapply (dbinom, Decke ((N-1) / 2), Decke ((N-1) / 2) :( N-1) , w))
 

Das obige ist jedoch für große N nicht so effizient. Stattdessen wird das von @RyanFrost erwähnte negative Binomialverteilungsverfahren für Fälle mit großen N s bevorzugt, d. H.

  gewinnt die <-Funktion (w, N) pnbinom (Boden ((N-1) / 2), Decke ((N + 1) / 2), w)
 

Example

  > gewinnt (0,9,5) # benötigt bei 3 Siegen aus 5 Spielen
[1] 0,99144

> gewinnt (0,9,6) # braucht bei 4 Siegen aus 6 Spielen
[1] 0,98415
 

Das ist interessant. Lassen Sie uns mit n = 3 demonstrieren, wo 2 Siege erforderlich sind, um der Gewinner zu sein. Wir können zuerst bestimmen, welche Kombinationen verfügbar sind

  n = 3L
lst = replizieren (n, 0: 1, vereinfachen = 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
 

Wie Sie bereits bemerkt haben, sind einige dieser Kombinationen nicht möglich. Wir sind besonders interessiert, wenn die rowSums () gleich 2 sind. Auf diese Weise können wir herausfinden, welche Kombinationen tatsächlich möglich sind.

  Möglich_Kombos = Combos [rowSums (Combos) == Decke (n / 2),]
mögliche_combos

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

Unser letzter Schritt besteht darin, jeden Beitrag aus unseren möglichen Beiträgen zu berechnen. Wir wissen, dass w ^ 2 in jeder Berechnung enthalten sein wird. Der Teil l ist komplizierter. In unserer ersten möglichen Kombination trägt der l nichts bei. Wir können max.col (..., tie.method = "last") verwenden, um herauszufinden, wie viele l s aufgetreten sind:

  loss = max.col (mögliche_combos, tie.method = "last") - Obergrenze (n / 2)
Verluste
# [1] 0 1 1

w = 0,9
l = 1 - w
gewinnt_p = w ^ Decke (n / 2)
Verluste_p = ifelse (Verluste == 0L, 1, l ^ Verluste)

p = Summe (Gewinne_p * Verluste_p)
p
# [1] 0,972
 

Um dies zu verallgemeinern, können wir dies als eine Funktion verwenden, die auf n und w basiert:

  right = Funktion (n, w) {
  lst = replizieren (n, 0: 1, vereinfachen = FALSE)
  combos = do.call (expand.grid, lst)
  Möglich_Combos = Combos [rowSums (Combos) == Decke (n / 2),]
  Verluste = max.col (mögliche_Combos, Bindungen.method = "letzte") - Decke (n / 2)

  l = 1 - w
  gewinnt_p = w ^ Decke (n / 2)
  Verluste_p = ifelse (Verluste == 0L, 1, l ^ Verluste)

  Summe (Gewinne_p * Verluste_p)
}}

rechts (5, 0,9)
# [1] 0,99144
rechts (5, 0,9) + rechts (5, 0,1)
# [1] 1

 

Es handelt sich um eine Binomialverteilung:

  dbinom (3,5,0,9) + dbinom (4,5,0,9) + dbinom (5,5,0,9) = 0,99144
 

Der Grund dafür ist folgender: Sie müssen nur über den gesamten Speicherplatz nachdenken, auch wenn es bereits 3 oder 4 Siege gibt. Stellen Sie sich vor, das Ereignis geht weiter und wir können die möglichen Ereignisse wie folgt schreiben:

  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
 

Und so weiter ..

Und diejenigen, die zum Beispiel geschrieben haben, dass sie 3 Siege enthalten (w.w.l.w.l), werden Teil von 5 sein und 3 in einem Binomial auswählen.

Von der Gesamtfläche von W / L über 5 Events benötigen wir 3 Siege, 4 Siege und 5 Siege, um alle Events einzuschließen, die zum Sieg des Teams führen können (obwohl im wirklichen Leben das 4. oder das 4.)5. Spiel findet nicht statt)

Hier ist eine Funktion win , die die Wahrscheinlichkeit berechnet, k aus n Spielen zu gewinnen, mit der Wahrscheinlichkeit, jedes Spiel zu gewinnenw .Es implementiert die Idee von diesem Math.SE-Beitrag.

  win <- Funktion (w, n = 5, k = 3) {
  lose <-Funktion (w, n, k) {
    l <-1 - w
    m <n - k
    s <-seq_len (n - 1) [- seq_len (m - 1)]
    ch <-sapply (s, Funktion (x) wähle (x, m))
    w <- w ^ (seq_along (s) - 1)
    l ^ m * sum (w * ch)
  }}
  if (k > = Decke (n / 2)) {
    1 - lose (w, n, k) * (1 - w)
  }sonst{
    stop ("eine Minderheit kann nicht gewinnen.")
  }}
}}
gewinnen (0,9)
# [1] 0,99144

gewinnen (0.1)
# [1] 0,00856

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

Was Sie fragen, ist ein einfaches mathematisches Problem. Ich werde versuchen, die Mathematik Schritt für Schritt zu erklären, dann werden wir unsere Codes dazu schreiben.

Mathe

Combination
In der Mathematik ist eine -Kombination eine Auswahl von Elementen aus einer Sammlung und wird wie folgt definiert.



Wobei ! der Fakultätsoperator ist. Nehmen wir zum Beispiel an, wir haben vier Runden und Sie möchten drei Siege (oder einen Verlust) auswählen. Wir haben:



Welches sind: w-w-w-l, w-w-l-w, w-l-w-w, l-w-w-w
Aber wie Sie erwähnt haben, ist w-w-w-l nicht akzeptabel, da das Spiel beendet ist, wenn 3 Siege erzielt wurden! Schauen Sie sich also diesen Punkt genau an:

Wenn unsere Runden mehr als 3 (Best of 5) dauern, muss die letzte gewonnen werden, wenn die Berechnung der Gewinnwahrscheinlichkeit gewünscht wird!

Um meine Berechnungen zu korrigieren, sollte ich zuerst die letzte Runde als Gewinn auswählen und 2 andere Punkte (von den verbleibenden Punkten) für den Gewinn auswählen. Oder



Und wenn wir mit w die Gewinnwahrscheinlichkeit zeigen und mit l verlieren, ist die Wahrscheinlichkeit, dass dieser Zustand eintritt

Javascript

Nachdem Sie das Konzept kennen, können Sie mit dem Codieren beginnen!
Zuerst brauche ich eine Funktion, um die Fakultät von n ( n! ) zu berechnen.

  let f = (n) = >
{
    sei o = 1;
    für (i = 1; i< = n; i ++)
    {
        o * = i;
    }}
    Rückkehr o;
}}
 

Um die Vorgehensweise besser zu verstehen, schreibe ich meine Codes Schritt für Schritt. Der nächste Schritt besteht also darin, die Kombinationsfunktion zu definieren.

  sei c = (n, r) = >
{
    Rückgabe f (n) / (f (r) * f (n-r));
}}
 

Und jetzt ist es Zeit, die Gewinnwahrscheinlichkeit von r in einem p -Rundenspiel mit einer Gewinnwahrscheinlichkeit von w zu berechnen.

  let _w = (p, r, w) = >
{
    sei o = 1;
    // Auswahl der Gewinnpositionen
    o * = c (1,1) * c (p-1, r-1);
    // Berechnungswahrscheinlichkeit
o * = Math.pow (w, r) * Math.pow (1-w, p-r);

    Rückkehr o;
}}
 

Jetzt können wir die Funktion BO (Best Of) mit N Runden und K Siegen ausführen.

  sei BO = (N, K, w) = >
{
    // P ist was wir finden wollen!
    sei P = 0;
    für (j = K; j< = N; j ++)
    {
        P + = _w (j, K, w);
    }}
    return P;
}}
 

Und einige Beispiele:

  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