Frage:
Wahrscheinlichkeit, einen Wettbewerb zu gewinnen K-Spiele Best of Series of N Games
Nitro
2020-04-06 00:00:27 UTC
view on stackexchange narkive permalink

Betrachten Sie eine "Best of 5" -Serie im Sport / Wettbewerb, bei der die erste Mannschaft, die 3 Spiele gewinnt, die Serie gewinnt. Also N = 5, K = 3. Wobei Wahrscheinlichkeit w = p (Team A-Gewinnspiel) und l = p (Team A-Verlustspiel) . Angenommen, diese Wahrscheinlichkeiten ändern sich während der Serie nicht.

Als ich zum ersten Mal darüber nachdachte, habe ich fälschlicherweise versucht, die einzelnen Wahrscheinlichkeiten für den Gewinn von 3/3, 3/4 und 3/5 Spielen hinzuzufügen:

  false = Funktion (w) {
  p = dbinom (3,3, w) + dbinom (3,4, w) + dbinom (3,5, w)
  return (p)
}}

falsch (.9)
# 1.0935
 

Offensichtlich besteht das Problem darin, dass es Redundanz gibt, da 3 Siege in Folge erzielt werden. W-W-W macht alle Ergebnisse von Spiel 4 und 5 überflüssig. d.h. W-W-W-L-W und W-W-W-W-L sind nicht möglich.

Nach dem Entfernen von Redundanzen sind dies die möglichen Permutationen:

  win = function (w) {
  l = 1-w
  p = w * w * w +
    w * w * l * w + w * l * w * w + l * w * w * w +
    l * l * w * w * w + l * w * l * w * w + l * w * w * l * w +
    w * l * l * w * w + w * l * w * l * w +
    w * w * l * l * w

  return (p)
}}

gewinnen (.9)
# 0.99144

win (.9) + win (.1)
# 1
 

Das manuelle Eingeben der Permutationen gerät bei längeren Serien schnell außer Kontrolle, dh wenn Sie eine N = 7-Spieleserie, 9 Spielserien usw. gewinnen. Wie muss im Allgemeinen die Funktion false () geändert werden? die richtige Wahrscheinlichkeit bekommen?

Siehe [vorhandene Fragen zu Math.SE zu * probabiltiy win series *] (https://math.stackexchange.com/search?q=probability+win+series+votes%3A5)
Die in den Antworten unter https://stats.stackexchange.com/questions/329521 vorgestellten Methoden machen diese Frage, die eine vereinfachte Version dieser Frage ist, kurz.
Sechs antworten:
#1
+7
RyanFrost
2020-04-06 00:11:22 UTC
view on stackexchange narkive permalink

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
 
Schöne Lösung mit negativer Binomialverteilung, +1!Übrigens, für die Allgemeinheit, d. H. Gerade oder ungerade "N", ermöglicht das Anwenden von "win_needed <- Decke ((N + 1) / 2)" eine generische Funktion "win"
Vielen Dank für den Hinweis @ThomasIsCoding - in diesem Fall sollte N immer ungerade sein, da eine Serie mit gerader Länge enden kann
Ich stimme jedoch zu, dass die Parametrisierung von "win" in Bezug auf N die Tür zur Eingabe einer Reihe mit gerader Länge öffnet.Ich habe es in k geändert, die Gewinne, die benötigt werden, um das anzugehen.Nochmals vielen Dank für den Hinweis
Wenn "N" gerade ist, benötigen Sie "Obergrenze ((N + 1) / 2)", um die Serie zu gewinnen, z. B. 4 von 6. In diesem Fall wird Ihre generische Funktion "gewinnen" in Bezug auf "N"`kann definiert werden als` win <- Funktion (w, N) pnbinom (Boden ((N-1) / 2), Decke ((N + 1) / 2), w) `,, die entweder ungerade oder ungerade behandeln kannsogar `N`
#2
+6
ThomasIsCoding
2020-04-06 01:51:26 UTC
view on stackexchange narkive permalink

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
 
#3
+6
Cole
2020-04-06 01:08:29 UTC
view on stackexchange narkive permalink

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

 
#4
+4
StupidWolf
2020-04-06 01:18:47 UTC
view on stackexchange narkive permalink

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)

Danke auch für die Bearbeitung!
Ja, natürlich würde pbinom funktionieren.Ich habe gerade die Summe geschrieben, um klar zu sein.Danke, dass du darauf hingewiesen hast. Ich denke, keine sehr gute Erklärung, lol
Diese Summe kann auch als "pbinom (5-3, 5, 1-0.9)" oder "1 - pbinom (5-3, 5, 0.9)" geschrieben werden
#5
+2
Rui Barradas
2020-04-06 01:08:42 UTC
view on stackexchange narkive permalink

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
 
#6
+1
Mohsen Nemati
2020-04-06 13:16:14 UTC
view on stackexchange narkive permalink

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.

enter image description here

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:

enter image description here

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

enter image description here

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

enter image description here

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
 


Diese Fragen und Antworten wurden automatisch aus der englischen Sprache übersetzt.Der ursprüngliche Inhalt ist auf stackexchange verfügbar. Wir danken ihm für die cc by-sa 4.0-Lizenz, unter der er vertrieben wird.
Loading...