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 sannsynligheten for å slå to seksere med to terninger. Du kan beregne det teoretisk, men du kan også simulere forsøket med et dataprogram! Ved å la datamaskinen «kaste terningene» mange tusen ganger, kan vi estimere sannsynligheten.

Denne metoden kalles simulering, og den er spesielt nyttig når det er vanskelig å beregne sannsynligheten teoretisk. Datamaskiner er perfekte til dette — de kan gjøre millioner av forsøk på sekunder.

I dette kapittelet skal du lære:

- Hvordan du bruker random-modulen i Python til å lage tilfeldige tall
- Hvordan du simulerer myntkast, terningkast og andre forsøk
- Hvordan du sammenligner simulert og teoretisk sannsynlighet
- Hva store talls lov betyr i praksis

random-modulen

Pythons random -modul lar oss generere tilfeldige tall. For å bruke den skriver vi import random øverst i programmet. Nyttige funksjoner: import random # Tilfeldig heltall mellom a og b (inkludert begge) terning = random.randint(1, 6) # Tilfeldig desimaltall mellom 0 og 1 x = random.random() # Velge tilfeldig fra en liste farger = ["rød", "blå", "grønn"] valg = random.choice(farger) Hver gang du kjører programmet, får du (sannsynligvis) forskjellige tall. Det er dette som gjør simulering mulig — vi kan gjøre et tilfeldig forsøk mange ganger.

Simulering og sannsynlighet

n

✏️Eksempel: Simulere terningkast

Skriv et Python-program som simulerer 10 000 kast med en vanlig terning og finner den simulerte sannsynligheten for å slå en sekser.

Løsning:

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 ikke eksakt lik. Kjører vi programmet igjen, får vi et litt annet svar. Med flere kast (f.eks. 1 000 000) kommer vi enda nærmere.

✏️Eksempel: Simulere myntkast

Skriv et Python-program som simulerer myntkast og finner den simulerte sannsynligheten for å få mynt (krone). Sammenlign med ulike antall kast: 100, 1000, 10 000 og 100 000.

Løsning:

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 den simulerte sannsynligheten svinger rundt 0,5, men svingningene blir mindre jo flere kast vi gjør. Dette er et eksempel på store talls lov: Med mange nok forsøk nærmer den simulerte sannsynligheten seg den teoretiske.

Store talls lov

n

Sammensatte forsøk

Simulering er spesielt nyttig for sammensatte forsøk, der vi kombinerer flere tilfeldige hendelser. For eksempel:

- Kaste to terninger og finne summen
- Trekke kuler fra en bolle uten tilbakelegging
- Spille et spill med flere runder

For slike problemer kan det være vanskelig å beregne sannsynligheten teoretisk, men simuleringen er enkel: Vi programmerer forsøket og gjentar det mange ganger!

✏️Eksempel: Sannsynligheten for å slå summen 7 med to terninger

Skriv et Python-program som simulerer kast med to terninger og finner den simulerte sannsynligheten for at summen blir 7.

Løsning:

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 beregning: Det er 6 gunstige utfall som gir summen 7: $(1,6), (2,5), (3,4), (4,3), (5,2), (6,1)$ . Med $6 \times 6 = 36$ mulige utfall totalt, er sannsynligheten:

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

Simuleringen bekrefter dette!

📝Oppgave 1

Skriv et Python-program som simulerer 1000 terningkast og teller hvor mange ganger du slår hvert av tallene 1 til 6. Skriv ut resultatet.

📝Oppgave 2

Skriv et Python-program som simulerer 10 000 myntkast (der 0 = krone og 1 = mynt). Beregn og skriv ut den simulerte sannsynligheten for mynt. Sammenlign med den teoretiske sannsynligheten $P(\text{mynt}) = 0{,}5$ .

📝Oppgave 3

Skriv et Python-program som simulerer kast med to terninger 100 000 ganger, og finner den simulerte sannsynligheten for at:
a) Summen er 2 (slangøyne)
b) Summen er 12 (to seksere)
c) Summen er 7

Sammenlign med de teoretiske sannsynlighetene.

📝Oppgave 4

I en bolle ligger det 5 røde og 3 blå kuler. Du trekker to kuler uten tilbakelegging. Skriv et Python-program som simulerer dette forsøket 100 000 ganger og finner den simulerte sannsynligheten for å trekke to røde kuler.

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

📝Oppgave 5

Store talls lov i praksis: Skriv et program som simulerer terningkast med ulike antall forsøk: 10, 100, 1000, 10 000 og 100 000. For hvert antall, finn den simulerte sannsynligheten for å slå en sekser. Vis at den simulerte verdien nærmer seg

\displaystyle \frac{1}{6}

jo flere forsøk du gjør.

📝Oppgave 6

Bursdagsparadokset: I en klasse med 23 elever, hva er sannsynligheten for at minst to elever har bursdag på samme dag? Skriv et Python-program som simulerer dette forsøket 100 000 ganger.

Hint: Generer 23 tilfeldige tall mellom 1 og 365 (bursdager). Sjekk om noen tall er like.

📝Oppgave 7

Monty Hall-problemet: I et TV-show er det tre dører. Bak én dør er det en premie, bak de to andre er det ingenting. Du velger en dør. Programlederen (som vet hva som er bak dørene) åpner en av de andre dørene som IKKE har premien. Du får velge: Vil du bytte dør eller beholde valget ditt?

Skriv et Python-program som simulerer 100 000 runder av Monty Hall-spillet og finner sannsynligheten for å vinne:
a) Hvis du alltid beholder valget
b) Hvis du alltid bytter dør

📝Oppgave F1

Finn feilen! Marius vil simulere 1000 terningkast og telle hvor mange ganger han får en sekser:

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 kjører programmet, får han alltid 0 seksere. Finn feilen og forklar hva som gikk galt.

📝Oppgave S1

Sant eller usant?

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

📝Oppgave D1

Drøftingsoppgave: Noen sannsynlighetsproblemer kan løses eksakt med formler, mens andre er vanskelige å beregne for hånd. Drøft når det er nyttig å bruke simulering i stedet for eksakt sannsynlighetsberegning. Gi minst to eksempler — ett der eksakt beregning er enklest, og ett der simulering er mer hensiktsmessig.

Oppsummering

I dette kapittelet har du lært:

- random-modulen: Å bruke random.randint(), random.random() og random.choice() for å generere tilfeldige tall i Python
- Simulering: Å gjenta et tilfeldig forsøk mange ganger med en datamaskin for å estimere sannsynligheter
- Store talls lov: At den simulerte sannsynligheten nærmer seg den teoretiske når antall forsøk øker
- Sammensatte forsøk: Å simulere komplekse situasjoner som to terninger, kuletrekking uten tilbakelegging og Monty Hall-problemet

Nøkkelbegreper

Begrep	Forklaring
`random.randint(a, b)`	Genererer et tilfeldig heltall mellom $a$ og $b$ (inkludert begge)
Simulering	Å bruke en datamaskin til å gjenta et tilfeldig forsøk mange ganger
Simulert sannsynlighet	Antall gunstige utfall delt på totalt antall forsøk: $\displaystyle P(A) \approx \frac{k}{n}$
Store talls lov	Prinsippet om at simulert sannsynlighet nærmer seg den teoretiske ved mange forsøk
`random.sample()`	Trekker tilfeldige elementer fra en liste uten tilbakelegging
Bursdagsparadokset	Med 23 personer er det over 50 % sjanse for at to deler bursdag

Repetisjonsoppgaver

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.