11.2 Simulering av tilfeldige forsøk | Matematikk 9. klasse

Bruk programmering til å simulere tilfeldige hendelser og estimere sannsynligheter.

55 min

8 oppgaver

SimuleringTilfeldige forsøkSannsynlighetStore talls lov

Du leser den tradisjonelle versjonen

Din fremgang i kapitlet

0 / 8 oppgaver

Simulering av tilfeldige forsøk

Tenk deg at du vil finne ut sannsynet for å slå to seksarar med to terningar. Du kan rekne det ut teoretisk, men du kan òg simulere forsøket med eit dataprogram! Ved å la datamaskinen «kaste terningane» mange tusen gonger, kan vi estimere sannsynet.

Denne metoden vert kalla simulering, og ho er spesielt nyttig når det er vanskeleg å rekne ut sannsynet teoretisk. Datamaskinar er perfekte til dette — dei kan gjere millionar av forsøk på sekund.

I dette kapittelet skal du lære:

- Korleis du bruker random-modulen i Python til å lage tilfeldige tal
- Korleis du simulerer myntkast, terningkast og andre forsøk
- Korleis du samanliknar simulert og teoretisk sannsyn
- Kva lova om store tal tyder i praksis

random-modulen

Pythons random -modul lèt oss generere tilfeldige tal. For å bruke han skriv vi import random øvst i programmet. Nyttige funksjonar: import random # Tilfeldig heiltal mellom a og b (inkludert begge) terning = random.randint(1, 6) # Tilfeldig desimaltal mellom 0 og 1 x = random.random() # Velje tilfeldig frå ei liste farger = ["rød", "blå", "grønn"] valg = random.choice(farger) Kvar gong du køyrer programmet, får du (sannsynlegvis) ulike tal. Det er dette som gjer simulering mogleg — vi kan gjere eit tilfeldig forsøk mange gonger.

Simulering og sannsyn

n

✏️Eksempel: Simulere terningkast

Skriv eit Python-program som simulerer 10 000 kast med ein vanleg terning og finn det simulerte sannsynet for å slå ein seksar.

Løysing:

import random

antall_kast = 10000
antall_seksere = 0

for i in range(antall_kast):
    kast = random.randint(1, 6)
    if kast == 6:
        antall_seksere = antall_seksere + 1

simulert = antall_seksere / antall_kast
teoretisk = 1 / 6

print(f"Antall seksere: {antall_seksere}")
print(f"Simulert sannsynlighet: {simulert:.4f}")
print(f"Teoretisk sannsynlighet: {teoretisk:.4f}")

Typisk resultat:

Antall seksere: 1648
Simulert sannsynlighet: 0.1648
Teoretisk sannsynlighet: 0.1667

Den simulerte verdien er nær den teoretiske $\displaystyle \frac{1}{6} \approx 0{,}1667$ , men ikkje eksakt lik. Køyrer vi programmet igjen, får vi eit litt anna svar. Med fleire kast (t.d. 1 000 000) kjem vi endå nærare.

✏️Eksempel: Simulere myntkast

Skriv eit Python-program som simulerer myntkast og finn det simulerte sannsynet for å få mynt (krone). Samanlikn med ulikt tal kast: 100, 1000, 10 000 og 100 000.

Løysing:

import random

for antall_kast in [100, 1000, 10000, 100000]:
    antall_mynt = 0
    for i in range(antall_kast):
        kast = random.randint(0, 1)  # 0 = krone, 1 = mynt
        if kast == 1:
            antall_mynt = antall_mynt + 1

    simulert = antall_mynt / antall_kast
    print(f"Kast: {antall_kast:>7}  |  P(mynt) = {simulert:.4f}")

print(f"Teoretisk:          |  P(mynt) = 0.5000")

Typisk resultat:

Kast:     100  |  P(mynt) = 0.4600
Kast:    1000  |  P(mynt) = 0.5130
Kast:   10000  |  P(mynt) = 0.4987
Kast:  100000  |  P(mynt) = 0.5003
Teoretisk:     |  P(mynt) = 0.5000

Legg merke til at det simulerte sannsynet svingar rundt 0,5, men svingingane vert mindre jo fleire kast vi gjer. Dette er eit døme på lova om store tal: Med mange nok forsøk nærmar det simulerte sannsynet seg det teoretiske.

Lova om store tal

n

Samansette forsøk

Simulering er spesielt nyttig for samansette forsøk, der vi kombinerer fleire tilfeldige hendingar. Til dømes:

- Kaste to terningar og finne summen
- Trekkje kuler frå ein bolle utan tilbakelegging
- Spele eit spel med fleire rundar

For slike problem kan det vere vanskeleg å rekne ut sannsynet teoretisk, men simuleringa er enkel: Vi programmerer forsøket og gjentek det mange gonger!

✏️Eksempel: Sannsynet for å slå summen 7 med to terningar

Skriv eit Python-program som simulerer kast med to terningar og finn det simulerte sannsynet for at summen vert 7.

Løysing:

import random

antall_forsok = 100000
antall_sju = 0

for i in range(antall_forsok):
    terning1 = random.randint(1, 6)
    terning2 = random.randint(1, 6)
    if terning1 + terning2 == 7:
        antall_sju = antall_sju + 1

simulert = antall_sju / antall_forsok
print(f"Simulert P(sum = 7): {simulert:.4f}")
print(f"Teoretisk P(sum = 7): {6/36:.4f}")

Typisk resultat:

Simulert P(sum = 7): 0.1664
Teoretisk P(sum = 7): 0.1667

Teoretisk utrekning: Det er 6 gunstige utfall som gjev summen 7: $(1,6), (2,5), (3,4), (4,3), (5,2), (6,1)$ . Med $6 \times 6 = 36$ moglege utfall totalt, er sannsynet:

$P(\text{sum} = 7) = \frac{6}{36} = \frac{1}{6} \approx 0{,}1667$

Simuleringa stadfestar dette!

📝Oppgave 1

Skriv eit Python-program som simulerer 1000 terningkast og tel kor mange gonger du slår kvart av tala 1 til 6. Skriv ut resultatet.

📝Oppgave 2

Skriv eit Python-program som simulerer 10 000 myntkast (der 0 = krone og 1 = mynt). Rekn ut og skriv ut det simulerte sannsynet for mynt. Samanlikn med det teoretiske sannsynet $P(\text{mynt}) = 0{,}5$ .

📝Oppgave 3

Skriv eit Python-program som simulerer kast med to terningar 100 000 gonger, og finn det simulerte sannsynet for at:
a) Summen er 2 (slangeauge)
b) Summen er 12 (to seksarar)
c) Summen er 7

Samanlikn med dei teoretiske sannsyna.

📝Oppgave 4

I ein bolle ligg det 5 raude og 3 blå kuler. Du trekkjer to kuler utan tilbakelegging. Skriv eit Python-program som simulerer dette forsøket 100 000 gonger og finn det simulerte sannsynet for å trekkje to raude kuler.

Hint: Lag ei liste med kulene og bruk random.sample(kuler, 2) for å trekkje to tilfeldige kuler.

📝Oppgave 5

Lova om store tal i praksis: Skriv eit program som simulerer terningkast med ulikt tal forsøk: 10, 100, 1000, 10 000 og 100 000. For kvart tal, finn det simulerte sannsynet for å slå ein seksar. Vis at den simulerte verdien nærmar seg

\displaystyle \frac{1}{6}

jo fleire forsøk du gjer.

📝Oppgave 6

Bursdagsparadokset: I ein klasse med 23 elevar, kva er sannsynet for at minst to elevar har bursdag på same dag? Skriv eit Python-program som simulerer dette forsøket 100 000 gonger.

Hint: Generer 23 tilfeldige tal mellom 1 og 365 (bursdagar). Sjekk om nokon tal er like.

📝Oppgave 7

Monty Hall-problemet: I eit TV-show er det tre dører. Bak éi dør er det ein premie, bak dei to andre er det ingenting. Du vel ei dør. Programleiaren (som veit kva som er bak dørene) opnar ei av dei andre dørene som IKKJE har premien. Du får velje: Vil du byte dør eller behalde valet ditt?

Skriv eit Python-program som simulerer 100 000 rundar av Monty Hall-spelet og finn sannsynet for å vinne:
a) Viss du alltid behaldar valet
b) Viss du alltid byter dør

📝Oppgave F1

Finn feilen! Marius vil simulere 1000 terningkast og telje kor mange gonger han får ein seksar:

import random

antall_seksere = 0

for i in range(1000):
    terning = random.randint(1, 5)
    if terning == 6:
        antall_seksere += 1

print(f"Antall seksere: {antall_seksere}")
print(f"Andel: {antall_seksere / 1000}")

Når Marius køyrer programmet, får han alltid 0 seksarar. Finn feilen og forklar kva som gjekk gale.

📝Oppgave S1

Sant eller usant?

Viss du simulerer 100 myntkast i Python, vil du alltid få nøyaktig 50 mynt og 50 kron.

📝Oppgave D1

Drøftingsoppgåve: Nokre sannsynsproblem kan løysast eksakt med formlar, medan andre er vanskelege å rekne ut for hand. Drøft når det er nyttig å bruke simulering i staden for eksakt sannsynsutrekning. Gje minst to døme — eitt der eksakt utrekning er enklast, og eitt der simulering er meir føremålstenleg.

Oppsummering

I dette kapittelet har du lært:

- random-modulen: Å bruke random.randint(), random.random() og random.choice() for å generere tilfeldige tal i Python
- Simulering: Å gjenta eit tilfeldig forsøk mange gonger med ein datamaskin for å estimere sannsyn
- Lova om store tal: At det simulerte sannsynet nærmar seg det teoretiske når talet på forsøk aukar
- Samansette forsøk: Å simulere komplekse situasjonar som to terningar, kuletrekking utan tilbakelegging og Monty Hall-problemet

Nøkkelomgrep

Omgrep	Forklaring
`random.randint(a, b)`	Genererer eit tilfeldig heiltal mellom $a$ og $b$ (inkludert begge)
Simulering	Å bruke ein datamaskin til å gjenta eit tilfeldig forsøk mange gonger
Simulert sannsyn	Talet på gunstige utfall delt på totalt tal forsøk: $\displaystyle P(A) \approx \frac{k}{n}$
Lova om store tal	Prinsippet om at simulert sannsyn nærmar seg det teoretiske ved mange forsøk
`random.sample()`	Trekkjer tilfeldige element frå ei liste utan tilbakelegging
Bursdagsparadokset	Med 23 personar er det over 50 % sjanse for at to deler bursdag

Repetisjonsoppgåver

Din fremgang

0deloppgaver0 / 6 oppgaver

Dette kapitlet er skrevet av Anthropics toppmodeller (Claude Opus og Claude Fable) og er foreløpig ikke manuelt gjennomgått — kvalitetskontrollen gjøres av uavhengige KI-agenter, og innmeldte feil rettes fortløpende. Funnet en feil? Meld fra, så retter vi den. Les mer om hvordan innholdet lages.