Kansspel wielrennen

[Anteros]

Dag allen,

Heeft iemand een idee hoe ik zo'n accuraat mogelijk inschatting kan maken van het volgende:

Er zijn 5 wielrenners, met de volgende kansen om 1e te worden:

1. 30%
2. 25%
3. 20%
4. 15%
5. 10%

Nu is de vraag of op een manier te beredeneren is hoe groot de kans is dat bijvoorbeeld renner 1 2e wordt, of wat de kans is dat renner 5 3e wordt.

Alvast bedankt!

Met vriendelijke groet,
Anteros

[CoenCo]

Als renner 2 wint, dan houden de overige 4 een wedstrijdje voor de tweede plaats. Hoe groot is de kans dat renner 1 dat wedstrijdje wint?

Dit sommetje doe je voor elke winnaar (teken de kansboom), en daarmee reken je de totale kans uit. Dat renner 1 de tweede plaats krijgt.

[EvilBro]

Nu is de vraag of op een manier te beredeneren is hoe groot de kans is dat bijvoorbeeld renner 1 2e wordt, of wat de kans is dat renner 5 3e wordt.

Die is er niet.

Stel dat renner Henkie als strategie heeft om keihard weg te gaan en dan wel te zien of ie het red. Stel dat hij dit in 30% van de gevallen red en in 70% van de gevallen volledig instort en 5e wordt.
Stel dat renner Benno een zeer goede volger is. Hij klamt aan bij elke koploper en blijft doorpeddelen. In 30% van de gevallen lukt het hem om op het laatst de koploper voorbij te gaan. In de overige 70% wordt hij tweede.
Zowel Benno als Henkie hebben 30% kans om eerste te worden. Hun kansen op de overige plekken is echter totaal anders.

[wnvl1]

Misschien veronderstellen dat het een tijdrit is, dan spelen de argumenten van EvilBro in mindere mate.

[wnvl1]

Als renner 1 30% kans heeft om te winnen en renner 2 25% kans om te winnen, dan is de aannemelijkheid dat renner 1 vóór renner 2 eindigt in de uitslag 30/(30+25). Zo zou voor elke mogelijke uitslag de aannemelijkheid berekend kunnen worden. Van daaruit zou de de kans berkend kunnen worden voor elke mogelijke uitslag. En dan heb je ook de kans dat een bepaalde renner bvb tweede wordt.

[wnvl1]

Hier de kansen voor de verschillende renners op elke uitslag.

Code: Selecteer alles

import itertools
import matplotlib.pyplot as plt

dictKansenRenners = {
    "renner 1": 0.3,
    "renner 2": 0.25,
    "renner 3": 0.20,
    "renner 4": 0.15,
    "renner 5": 0.10
}

listUitslagen = []

for i in list(itertools.permutations(["renner 1", "renner 2", "renner 3", "renner 4", "renner 5"])):
    kans = dictKansenRenners[i[0]] / (dictKansenRenners[i[0]]+dictKansenRenners[i[1]]+dictKansenRenners[i[2]]+dictKansenRenners[i[3]]+dictKansenRenners[i[4]]) * \
           dictKansenRenners[i[1]] / (dictKansenRenners[i[1]]+dictKansenRenners[i[2]]+dictKansenRenners[i[3]]+dictKansenRenners[i[4]]) * \
           dictKansenRenners[i[2]] / (dictKansenRenners[i[2]]+dictKansenRenners[i[3]]+dictKansenRenners[i[4]]) * \
           dictKansenRenners[i[3]] / (dictKansenRenners[i[3]]+dictKansenRenners[i[4]])
    listUitslagen.append([i, kans])


uitslagenRenner = [0, 0, 0, 0, 0]

fig, axs = plt.subplots(5)

for index, renner in enumerate(["renner 1", "renner 2", "renner 3", "renner 4", "renner 5"]):
    for i in listUitslagen:
        if i[0][0] == renner:
            uitslagenRenner[0] += i[1]
        if i[0][1] == renner:
            uitslagenRenner[1] += i[1]
        if i[0][2] == renner:
            uitslagenRenner[2] += i[1]
        if i[0][3] == renner:
            uitslagenRenner[3] += i[1]
        if i[0][4] == renner:
            uitslagenRenner[4] += i[1]
    print(uitslagenRenner)

    # creating the bar plot
    axs[index].bar([1,2,3,4,5], uitslagenRenner, color='orange',
            width=0.4)

    axs[index].set_title(renner)

    uitslagenRenner = [0, 0, 0, 0, 0]

plt.show()

[Anteros]

@CoenCo Het is me gelukt om de nummers twee uit te werken in Excel. Echter lukt het me niet om dit ook voor de nummers drie te krijgen. Sowieso moet dit denk ik wel in Python, want anders krijg je wel zo'n enorm lange onoverzichtelijke code. In ieder geval bedankt!

[Anteros]

@wnvl1 Fantastisch, dit is precies wat ik zocht. Hoe makkelijk is het om dit te schalen? Zelf werk ik momenteel in Excel, maar heb wel iets ervaring met Python. Moet ik hem handmatig uitbreiden naar 50 of 100 renners? Uitbreiden naar 6 lukt namelijk prima, of is er een makkelijkere manier waardoor hij wat meer schaalbaar wordt?

[wnvl1]

Met een tweetal extra "for" lussen kan deze Python code perfect geschaald worden naar 100 renners. Dat is echt niet veel werk.

Je wil ze gebruiken om op basis van resultaten uit het verleden toekomstige resultaten in te schatten? Je moet jezelf dan wel beperken tot bepaalde types wedstrijden. Of hoe bepaal je de kans om te winnen? Resultaten van Parijs-roubaix lijken mij niet extrapoleerbaar naar LBL of Lombardije. Het type wedstrijd is een meer significante predictor dan algemene resultaten behaald in het verleden.

[Anteros]

Het idee is om een hele ruwe inschatting te kunnen maken van de kans dat een renner een andere positie haalt dan eerste, de bookmakers maken namelijk enkel inschattingen over deze eerste plek. Zoals EvilBro al eerder aangaf zal dit nooit een hele goeie inschatting worden door de verschillende type renners, maar het is meer op een soort ballpark idee te krijgen.

Ik ben bekend met de "for loops", echter weet ik niet precies wat je bedoeld met het maken van een tweetal extra for loops om zo 100 renners te kunnen meenemen.

[wnvl1]

Ik bedoel dat je dit

Code: Selecteer alles

kans = dictKansenRenners[i[0]] / (dictKansenRenners[i[0]]+dictKansenRenners[i[1]]+dictKansenRenners[i[2]]+dictKansenRenners[i[3]]+dictKansenRenners[i[4]]) * \
           dictKansenRenners[i[1]] / (dictKansenRenners[i[1]]+dictKansenRenners[i[2]]+dictKansenRenners[i[3]]+dictKansenRenners[i[4]]) * \
           dictKansenRenners[i[2]] / (dictKansenRenners[i[2]]+dictKansenRenners[i[3]]+dictKansenRenners[i[4]]) * \
           dictKansenRenners[i[3]] / (dictKansenRenners[i[3]]+dictKansenRenners[i[4]])

en dit

Code: Selecteer alles

        if i[0][0] == renner:
            uitslagenRenner[0] += i[1]
        if i[0][1] == renner:
            uitslagenRenner[1] += i[1]
        if i[0][2] == renner:
            uitslagenRenner[2] += i[1]
        if i[0][3] == renner:
            uitslagenRenner[3] += i[1]
        if i[0][4] == renner:
            uitslagenRenner[4] += i[1]

nog in een for loop moet stoppen en dan kan je de code ook voor 100 renners laten werken met weinig werk.

[wnvl1]

Ik maak mij wel de bedenking dat in geval van 100 renners de code wel een lange looptijd gaat hebben. In dat opzicht zullen er wel een paar optimalisaties moeten gebeuren. 100! (het aantal permutaties) is een groot getal.

[Anteros]

@wnvl1 Ik kom er toch niet helemaal uit, ik neem aan dat je die 5 renners in een loop moet zetten van 20. Om zo tot het gewenste aantal van 100 te komen. Maar nu snap ik zeker bij het bovenste stukje code niet helemaal hoe ik dit vorm zou kunnen geven.

[EvilBro]

Zoals EvilBro al eerder aangaf zal dit nooit een hele goeie inschatting worden door de verschillende type renners, maar het is meer op een soort ballpark idee te krijgen.

Dan ben ik toch niet helemaal duidelijk geweest: het punt is dat er in de percentages voor de eerste plek geen informatie zit over de andere plekken. Doen alsof dit wel zo is, is jezelf bedriegen.

Stel dat 4 vrienden tegen elkaar gaan races op een parkour waarover ze allemaal ongeveer 10 minuten doen ( = 600 seconden). Het enige waarin deze vrienden van elkaar verschillen is de mate waarin hun eindtijd van keer tot keer fluctueert rond deze 10 minuten. Bekijk de volgende simulatie-code (javascript):

Code: Selecteer alles

function fietsRace(renner) {
  return {
    naam: renner.naam,
    eindtijd: (renner.s * (Math.random() - 0.5)) + renner.m
  }
}

const renners = [  
  { naam: 'Benno', m: 600, s: 40 },
  { naam: 'Wilbur', m: 600, s: 30 },
  { naam: 'Henkie', m: 600, s: 20 },
  { naam: 'Indurain', m: 600, s: 10 }
]

const aantalRaces = 100000
const resultaten = {}
for (const renner of renners) {
  resultaten[renner.naam] = 0
}

for (let raceNr = 1; raceNr <= aantalRaces; raceNr += 1) {
  const result = renners.map(fietsRace)
  const winnaar = result.reduce((w, r) => { return ((r.eindtijd < w.eindtijd) ? r : w) }, result[0])
  resultaten[winnaar.naam] += 1
}
console.log(resultaten)

Hierin doen de vrienden 100000 races. De resultaten zijn: { Benno: 36107, Wilbur: 29047, Henkie: 20772, Indurain: 14074 }
Het is duidelijk dat Benno veel meer races wint dan Indurain.
Stel nu dat Wilbur en Henkie een weekend niet kunnen racen. Benno en Indurain besluiten alleen tegen elkaar te gaan racen. Als je nu doet alsof de bovenstaande resultaten ook iets zeggen over deze race dan zou je misschien verwachten dat Benno gaat winnen. Als we echter de simulatie met alleen deze twee renners runnen dan krijgen we: { Benno: 49918, Indurain: 50082 }. De winkansen zijn nu 50-50.

[Anteros]

@EvilBro In deze hypothetische situatie heb je gelijk dat er inderdaad geen enkele informatie in verstopt zit. Echter was dat niet mijn vraag, maar snap de verwarring aangezien ik het voorleg als een soort kansspel, daar had ik duidelijker in moeten zijn. Maar stel je hebt de volgende kansverdeling in een vlakke etappe van de Tour de France:

van Aert: 15%
Jakobsen: 13%
Groenewegen: 12%
Rest van het peleton: 0.5%

Indien van Aert de sprint wint is het waarschijnlijk dat dan wel Jakobsen dan wel Groenewegen tweede wordt aangezien zij de grootste concurrenten zijn voor van Aert in een sprintetappe. Dit is geen garantie, stel van Aert rijd weg met een kopgroep van 5 dan zullen Jakobsen en Groenewegen hier niet inzitten. Maar zelfs dan is het waarschijnlijk dat Jakobsen en Groenewegen zullen strijden voor de plekken 6 en 7.