Komplett ifingo-løsningsforslag på bokmål. Hver deloppgave har transkribert oppgavetekst, trinnvis løsning, tolkning, vanlig feil, GeoGebra CAS-kontroll og Python-kontroll med realistisk utskrift.
Del 1 — uten hjelpemidler
Del 1 · Oppgave 1aDerivasjon
Oppgave 1a
Oppgave (5 poeng):
Deriver funksjonen \(f\) gitt ved
\[f(x)=\dfrac{1}{3}x^3+x+2\]
Vis løsning
Hva spør oppgaven om? Vi skal identifisere riktig matematisk modell, regne systematisk og kontrollere svaret digitalt uten å hoppe over begrunnelser.
Steg 1 — Les funksjonen ledd for ledd
Funksjonen består av et tredjegradsledd, et førstegradsledd og en konstant. Vi kan derivere hvert ledd separat.
Steg 2 — Bruk potensregelen
Potensregelen gir \(\left(\dfrac{1}{3}x^3\right)^{\prime}=\dfrac{1}{3}\cdot 3x^2=x^2\).
Steg 3 — Deriver de andre leddene
Videre er \((x)^{\prime}=1\) og \((2)^{\prime}=0\), fordi en konstant har derivert lik null.
Steg 4 — Sett leddene sammen
Dermed får vi \[f^{\prime}(x)=x^2+1+0=x^2+1.\]
Tolkning
Den deriverte er positiv for alle \(x\), siden \(x^2\ge 0\). Grafen til \(f\) er derfor voksende overalt.
Vanlig feil: Å glemme koeffisienten \(\dfrac{1}{3}\), eller å derivere konstantleddet som om det var et variabelledd.
Kontroll (GeoGebra CAS)
GeoGebra · CAS
1
Derivert(1/3*x^3+x+2)
→ \(x^2+1\)
Kontroll (Python)
Python-kontroll
from sympy import symbols, diff, Rational, simplify
x = symbols('x')
f = Rational(1, 3)*x**3 + x + 2
f_derivert = diff(f, x)
kontroll = simplify(f_derivert - (x**2 + 1))
print("f(x) =", f)
print("f'(x) =", f_derivert)
print("Kontroll mot x**2 + 1:", kontroll)
Utskrift når koden kjøres:
f(x) = x**3/3 + x + 2
f'(x) = x**2 + 1
Kontroll mot x**2 + 1: 0
Fasit: \(f^{\prime}(x)=x^2+1\).
Del 1 · Oppgave 1bDerivasjon av eksponentialuttrykk
Oppgave 1b
Oppgave (5 poeng):
Funksjonen \(g\) er gitt ved
\[g(x)=\dfrac{2x-3}{e^x}\]
Bestem \(g^{\prime}(2)\) og \(g^{\prime}(3)\).
Vis løsning
Hva spør oppgaven om? Vi skal identifisere riktig matematisk modell, regne systematisk og kontrollere svaret digitalt uten å hoppe over begrunnelser.
Steg 1 — Skriv funksjonen på en enklere form
Vi skriver \(g(x)=\left(2x-3\right)e^{-x}\). Da kan vi bruke produktregelen.
Steg 2 — Deriver faktorene
La \(u=2x-3\) og \(v=e^{-x}\). Da er \(u^{\prime}=2\) og \(v^{\prime}=-e^{-x}\).
Fasit: \(g^{\prime}(2)=\dfrac{1}{e^2}\) og \(g^{\prime}(3)=-\dfrac{1}{e^3}\).
Del 1 · Oppgave 1cGrafisk tolkning av derivert
Oppgave 1c
Oppgave (5 poeng):
Hva forteller svarene i oppgave b om grafen til \(g\) når \(x\in[2,3]\)?
Vis løsning
Hva spør oppgaven om? Vi skal identifisere riktig matematisk modell, regne systematisk og kontrollere svaret digitalt uten å hoppe over begrunnelser.
Steg 1 — Bruk fortegnet til den deriverte
Fra oppgave b har vi \(g^{\prime}(2)>0\) og \(g^{\prime}(3)<0\). Det betyr at grafen stiger ved \(x=2\) og synker ved \(x=3\).
Steg 2 — Finn hvor den deriverte er null
Siden \(g^{\prime}(x)=\left(5-2x\right)e^{-x}\), og \(e^{-x}>0\), får vi \[5-2x=0\quad\Rightarrow\quad x=\dfrac{5}{2}.\]
Steg 3 — Drøft fortegn
For \(20\). For \(\dfrac{5}{2}
Steg 4 — Tolk grafen
Grafen til \(g\) er voksende fram til \(x=\dfrac{5}{2}\) og avtakende etterpå.
Tolkning
På intervallet \([2,3]\) har grafen et toppunkt ved \(x=\dfrac{5}{2}\).
Vanlig feil: Å bare si at grafen går opp og ned, uten å begrunne at den deriverte faktisk skifter fortegn inne i intervallet.
Kontroll (GeoGebra CAS)
GeoGebra · CAS
1
Løs((5-2x)/exp(x)=0)
→ \(x=\dfrac{5}{2}\)
2
Fortegn((5-2x)/exp(x),2,3)
→ \(+\;0\;-\)
Kontroll (Python)
Python-kontroll
from sympy import symbols, exp, solve, simplify
x = symbols('x')
g_derivert = (5 - 2*x)*exp(-x)
kritisk = solve(g_derivert, x)
venstre = simplify(g_derivert.subs(x, 2))
hoyre = simplify(g_derivert.subs(x, 3))
print("g'(x) =", g_derivert)
print("Kritisk punkt i intervallet:", kritisk)
print("g'(2) =", venstre, "som er positiv")
print("g'(3) =", hoyre, "som er negativ")
Utskrift når koden kjøres:
g'(x) = (5 - 2*x)*exp(-x)
Kritisk punkt i intervallet: [5/2]
g'(2) = exp(-2) som er positiv
g'(3) = -exp(-3) som er negativ
Fasit: Grafen stiger først, har toppunkt ved \(x=\dfrac{5}{2}\), og synker deretter på \([2,3]\).
Del 1 · Oppgave 2aLogaritmelikning
Oppgave 2a
Oppgave (3 poeng):
Løs likningen
\[\left(\lg x\right)^2-2\lg x=8\]
Vis løsning
Hva spør oppgaven om? Vi skal identifisere riktig matematisk modell, regne systematisk og kontrollere svaret digitalt uten å hoppe over begrunnelser.
Steg 1 — Innfør en hjelpevariabel
Sett \(u=\lg x\). Da blir likningen en vanlig andregradslikning.
Steg 2 — Skriv om likningen
\[u^2-2u=8\quad\Rightarrow\quad u^2-2u-8=0.\]
Steg 3 — Faktoriser
\[u^2-2u-8=\left(u-4\right)\left(u+2\right).\]
Steg 4 — Løs for \(u\)
Vi får \(u=4\) eller \(u=-2\).
Steg 5 — Gå tilbake til \(x\)
\(\lg x=4\) gir \(x=10^4\). \(\lg x=-2\) gir \(x=10^{-2}\).
Tolkning
Begge løsningene er gyldige fordi logaritmen er definert for \(x>0\).
Vanlig feil: Å løse for \(\lg x\), men glemme å gjøre om tilbake til \(x\).
Kontroll (GeoGebra CAS)
GeoGebra · CAS
1
Løs((log(10,x))^2-2*log(10,x)=8)
→ \(x=10^{-2}\lor x=10^4\)
Kontroll (Python)
Python-kontroll
from sympy import symbols, Eq, solve, log, simplify
x, u = symbols('x u', positive=True)
likning_u = Eq(u**2 - 2*u, 8)
los_u = solve(likning_u, u)
los_x = [10**v for v in los_u]
kontroll = [simplify((log(val, 10))**2 - 2*log(val, 10) - 8) for val in los_x]
print("Løsninger for u = lg(x):", los_u)
print("Løsninger for x:", los_x)
print("Kontroll:", kontroll)
Utskrift når koden kjøres:
Løsninger for u = lg(x): [-2, 4]
Løsninger for x: [1/100, 10000]
Kontroll: [0, 0]
Fasit: \(x=10^4\) eller \(x=10^{-2}\).
Del 1 · Oppgave 2bLogaritmebase
Oppgave 2b
Oppgave (3 poeng):
Bestem \(a\) slik at
\[\log_a\left(\dfrac{1}{64}\right)=-3\]
Vis løsning
Hva spør oppgaven om? Vi skal identifisere riktig matematisk modell, regne systematisk og kontrollere svaret digitalt uten å hoppe over begrunnelser.
Steg 1 — Bruk definisjonen av logaritme
Utsagnet \(\log_a\left(\dfrac{1}{64}\right)=-3\) betyr at \(a^{-3}=\dfrac{1}{64}\).
Steg 2 — Skriv med positiv eksponent
\[a^{-3}=\dfrac{1}{a^3}=\dfrac{1}{64}.\]
Steg 3 — Sammenlikn nevnerne
Da må \(a^3=64\).
Steg 4 — Finn basen
\[a=\sqrt[3]{64}=4.\]
Steg 5 — Kontroller logaritmebasen
En logaritmebase må være positiv og ulik 1. \(a=4\) er derfor tillatt.
Vanlig feil: Å skrive \(a=\dfrac{1}{4}\). Da blir \(a^{-3}=64\), ikke \(\dfrac{1}{64}\).
Kontroll (GeoGebra CAS)
GeoGebra · CAS
1
Løs(a^(-3)=1/64)
→ \(a=4\)
Kontroll (Python)
Python-kontroll
from sympy import symbols, Eq, solve, Rational, simplify
'a' # bare for å vise at a er variabelnavnet i oppgaven
a = symbols('a', positive=True)
likning = Eq(a**(-3), Rational(1, 64))
losning = solve(likning, a)
kontroll = [simplify(val**(-3) - Rational(1, 64)) for val in losning]
print("Likning:", likning)
print("Mulige positive løsninger:", losning)
print("Kontroll:", kontroll)
Et passord skal bestå av tre tegn og lages av sifrene 1–9 og bokstavene A–F. Det første tegnet skal være en bokstav, og de to neste tegnene skal være to ulike siffer.
Hvor mange ulike passord er det mulig å lage?
Vis løsning
Hva spør oppgaven om? Vi skal identifisere riktig matematisk modell, regne systematisk og kontrollere svaret digitalt uten å hoppe over begrunnelser.
Steg 1 — Tell bokstavvalg
Bokstavene A–F gir \(6\) muligheter for første tegn.
Steg 2 — Tell første siffer
Sifrene 1–9 gir \(9\) muligheter for andre tegn.
Steg 3 — Tell andre siffer
Det siste sifferet må være ulikt det første sifferet. Derfor er det \(8\) muligheter igjen.
Steg 4 — Bruk produktregelen
\[6\cdot 9\cdot 8=432.\]
Tolkning
Hvert valg av bokstav kan kombineres med hvert ordnet valg av to ulike siffer.
Vanlig feil: Å bruke \(9\cdot 9\) for sifrene selv om oppgaven sier at de to sifrene skal være ulike.
Kontroll (GeoGebra CAS)
GeoGebra · CAS
1
6*9*8
→ \(432\)
Kontroll (Python)
Python-kontroll
bokstaver = 6
forste_siffer = 9
andre_siffer = 8
antall = bokstaver * forste_siffer * andre_siffer
print("Bokstavvalg:", bokstaver)
print("Valg av første siffer:", forste_siffer)
print("Valg av andre siffer:", andre_siffer)
print("Antall passord:", antall)
Utskrift når koden kjøres:
Bokstavvalg: 6
Valg av første siffer: 9
Valg av andre siffer: 8
Antall passord: 432
Fasit: \(432\) passord.
Del 1 · Oppgave 4bKomplementmetode
Oppgave 4b
Oppgave (3 poeng):
Et annet passord skal bestå av tre tegn. Hvert tegn skal være et av sifrene 1, 2, 3, 4 eller en av bokstavene A, B, C. Både sifrene og bokstavene kan forekomme flere ganger. Passordet må inneholde minst én bokstav og minst ett siffer.
Hvor mange ulike passord er det mulig å lage?
Vis løsning
Hva spør oppgaven om? Vi skal identifisere riktig matematisk modell, regne systematisk og kontrollere svaret digitalt uten å hoppe over begrunnelser.
Steg 1 — Tell alle mulige passord
Det finnes \(4+3=7\) mulige tegn på hver plass. Uten restriksjoner er det \(7^3\) passord.
Steg 2 — Trekk fra passord med bare sifre
Hvis passordet bare består av sifre, får vi \(4^3\) passord.
Steg 3 — Trekk fra passord med bare bokstaver
Hvis passordet bare består av bokstaver, får vi \(3^3\) passord.
Steg 4 — Bruk komplementmetoden
\[7^3-4^3-3^3=343-64-27=252.\]
Tolkning
De gjenværende passordene har minst én bokstav og minst ett siffer.
Vanlig feil: Å telle bare én bokstav og ett siffer, men glemme at passordet har tre plasser og at tegn kan gjentas.
Grafen har ett bunnpunkt og ingen toppunkt i definisjonsmengden.
Vanlig feil: Å sette \(x=0\) som kritisk punkt. Det er ikke lov, fordi \(\ln x\) ikke er definert for \(x=0\).
Kontroll (GeoGebra CAS)
GeoGebra · CAS
1
Derivert(4*x^2*ln(x))
→ \(4x(2\ln x+1)\)
2
Løs(4*x*(2*ln(x)+1)=0)
→ \(x=e^{-1/2}\)
3
f(exp(-1/2))
→ \(-\dfrac{2}{e}\)
Kontroll (Python)
Python-kontroll
from sympy import symbols, log, diff, solve, exp, simplify
x = symbols('x', positive=True)
f = 4*x**2*log(x)
f1 = diff(f, x)
f2 = diff(f1, x)
kritiske = solve(f1, x)
for punkt in kritiske:
y_verdi = simplify(f.subs(x, punkt))
andrederivert = simplify(f2.subs(x, punkt))
print("Kritisk x-verdi:", punkt)
print("f(x) i punktet:", y_verdi)
print("f''(x) i punktet:", andrederivert)
print("Type:", "bunnpunkt" if andrederivert > 0 else "toppunkt")
Utskrift når koden kjøres:
Kritisk x-verdi: exp(-1/2)
f(x) i punktet: -2*exp(-1)
f''(x) i punktet: 8
Type: bunnpunkt
Fasit: Bunnpunkt \(\left(e^{-1/2},-\dfrac{2}{e}\right)\). Ingen toppunkt.
Del 1 · Oppgave 6aProgramforståelse og sannsynlighet
Oppgave 6a
Oppgave (5 poeng):
Einar er fotballspiller og har skrevet programmet nedenfor.
from random import choice
# choice returnerer en tilfeldig verdi fra en liste
alternativer = ["bom", "bom", "bom", "treff", "treff"]
# liste med alternativer
skuddserie = 3
antall_treff = 0
for i in range(skuddserie):
skudd = choice(alternativer)
if skudd == "treff":
antall_treff = antall_treff + 1
print(antall_treff/skuddserie)
Hvilke mulige verdier kan programmet skrive ut?
Vis løsning
Hva spør oppgaven om? Vi skal identifisere riktig matematisk modell, regne systematisk og kontrollere svaret digitalt uten å hoppe over begrunnelser.
Steg 1 — Les hva programmet teller
Programmet gjennomfører \(3\) skudd og teller hvor mange av dem som blir \("treff"\).
Steg 2 — Finn mulige antall treff
På tre skudd kan antall treff være \(0\), \(1\), \(2\) eller \(3\).
Steg 3 — Se hva som skrives ut
Programmet skriver ut \(\dfrac{\text{antall treff}}{3}\).
Utskriften er andelen treff i en skuddserie på tre skudd.
Vanlig feil: Å svare med antall treff \(0,1,2,3\), selv om programmet skriver ut andelen treff.
Kontroll (GeoGebra CAS)
GeoGebra · CAS
1
Følge( n/3, n, 0, 3 )
→ \(0,\dfrac{1}{3},\dfrac{2}{3},1\)
Kontroll (Python)
Python-kontroll
from fractions import Fraction
skuddserie = 3
mulige_antall_treff = list(range(skuddserie + 1))
mulige_utskrifter = [Fraction(treff, skuddserie) for treff in mulige_antall_treff]
print("Mulige antall treff:", mulige_antall_treff)
print("Mulige utskrifter:")
for verdi in mulige_utskrifter:
print(verdi, "=", float(verdi))
Antall straffespark må være et heltall. Derfor må Einar ta minst \(2\) straffespark.
Kontroll
For \(n=1\) er sannsynligheten \(0{,}30\). For \(n=2\) er den \(1-0{,}70^2=0{,}51\).
Vanlig feil: Å runde \(1{,}94\) ned til \(1\). Vi må velge minste heltall som oppfyller kravet, altså runde opp.
Kontroll (GeoGebra CAS)
GeoGebra · CAS
1
Løs(1-0.7^n>=0.5,n)
→ \(n\ge 1{,}94\)
2
1-0.7^2
→ \(0{,}51\)
Kontroll (Python)
Python-kontroll
from sympy import symbols, log, ceiling, N
n = symbols('n')
grense = log(0.5)/log(0.7)
minste_heltall = ceiling(grense)
kontroll_1 = 1 - 0.7**1
kontroll_2 = 1 - 0.7**2
print("Teoretisk nedre grense for n:", N(grense))
print("Minste heltall:", minste_heltall)
print("P(minst ett mål) når n = 1:", kontroll_1)
print("P(minst ett mål) når n = 2:", kontroll_2)
Utskrift når koden kjøres:
Teoretisk nedre grense for n: 1.94335820987473
Minste heltall: 2
P(minst ett mål) når n = 1: 0.30000000000000004
P(minst ett mål) når n = 2: 0.51
Fasit: Minst \(2\) straffespark.
Del 2 — med hjelpemidler
Del 2 · Oppgave 1aEksponentialregresjon
Oppgave 1a
Oppgave (6 poeng):
Tabellen viser folketallet i en bygd i perioden 1910–1935.
År
1910
1913
1919
1921
1925
1927
1931
1935
Folketall
800
963
1253
1511
1720
1879
2387
2774
Bruk informasjonen til å lage en modell \(F(t)=a\cdot b^t\) for antall personer \(F(t)\) som bodde i bygda \(t\) år etter 1910. Vurder modellens gyldighetsområde.
Vis løsning
Hva spør oppgaven om? Vi skal identifisere riktig matematisk modell, regne systematisk og kontrollere svaret digitalt uten å hoppe over begrunnelser.
Steg 1 — Velg variabel
Vi lar \(t=0\) svare til år 1910. Da blir \(t\)-verdiene \(0,3,9,11,15,17,21,25\).
Steg 2 — Velg regresjonsmodell
Oppgaven ber om en modell på formen \(F(t)=a\cdot b^t\). Derfor bruker vi eksponentialregresjon.
Steg 3 — Bruk digitalt verktøy
Regresjon på punktene gir omtrent \[a\approx 820{,}64,\qquad b\approx 1{,}05098.\]
Steg 4 — Skriv modellen
\[F(t)\approx 820{,}64\cdot 1{,}05098^t.\]
Steg 5 — Tolk parameterne
Parameteren \(a\) er modellens folketall ved \(t=0\). Faktoren \(b\) betyr at modellen gir omtrent \(5{,}1\,\%\) vekst per år.
Steg 6 — Vurder gyldighetsområde
Dataene dekker \(0\le t\le 25\), altså 1910–1935. Modellen er tryggest som interpolasjon i dette intervallet. Ekstrapolasjon utenfor perioden bør brukes med forsiktighet.
Vanlig feil: Å bruke årstallene 1910, 1913, ... direkte som \(t\)-verdier uten å forskyve startåret. Det gir en modell som er vanskelig å tolke.
import numpy as np
from math import exp
t = np.array([0, 3, 9, 11, 15, 17, 21, 25], dtype=float)
F = np.array([800, 963, 1253, 1511, 1720, 1879, 2387, 2774], dtype=float)
# Eksponentialregresjon: ln(F) = ln(a) + t*ln(b)
ln_b, ln_a = np.polyfit(t, np.log(F), 1)
a = exp(ln_a)
b = exp(ln_b)
print("a =", round(a, 4))
print("b =", round(b, 6))
print("Modell: F(t) =", round(a, 2), "*", round(b, 5), "** t")
print("Gyldighetsområde i dataene: 0 <= t <=", int(max(t)))
Utskrift når koden kjøres:
a = 820.6398
b = 1.050982
Modell: F(t) = 820.64 * 1.05098 ** t
Gyldighetsområde i dataene: 0 <= t <= 25
Fasit: \(F(t)\approx 820{,}64\cdot 1{,}05098^t\), gyldigst for \(0\le t\le 25\).
Del 2 · Oppgave 1bVekstfart i eksponentialmodell
Oppgave 1b
Oppgave (6 poeng):
Når økte befolkningen med mer enn \(80\) personer per år ifølge modellen?
Vis løsning
Hva spør oppgaven om? Vi skal identifisere riktig matematisk modell, regne systematisk og kontrollere svaret digitalt uten å hoppe over begrunnelser.
Steg 1 — Bruk momentanfart
Befolkningsøkningen per år beskrives av den deriverte \(F^{\prime}(t)\).
Steg 2 — Deriver modellen
For \(F(t)=a\cdot b^t\) er \[F^{\prime}(t)=a\cdot b^t\cdot \ln b.\]
Steg 3 — Sett inn regresjonsmodellen
Med \(a\approx 820{,}64\) og \(b\approx 1{,}05098\) løser vi \[820{,}64\cdot 1{,}05098^t\cdot \ln(1{,}05098)>80.\]
Steg 4 — Løs digitalt
Løsningen blir \(t>13{,}54\).
Steg 5 — Oversett til årstall
Siden \(t=0\) er 1910, svarer \(t=13{,}54\) til omtrent midten av 1923.
Tolkning
Ifølge modellen økte befolkningen med mer enn \(80\) personer per år fra omtrent 1924, eller etter ca. \(13{,}5\) år.
Vanlig feil: Å bruke gjennomsnittlig vekst i stedet for den deriverte når oppgaven spør om når befolkningen økte med mer enn \(80\) personer per år.
Kontroll (GeoGebra CAS)
GeoGebra · CAS
1
Løs(820.64*1.05098^t*ln(1.05098)>80,t)
→ \(t>13{,}54\)
Kontroll (Python)
Python-kontroll
from sympy import symbols, log, solve_univariate_inequality
from sympy import Float, N
t = symbols('t', real=True)
a = Float(820.6398353542176)
b = Float(1.0509820497768692)
F_derivert = a*b**t*log(b)
terskel = solve_univariate_inequality(F_derivert > 80, t)
start_tid = log(80/(a*log(b)))/log(b)
print("F'(t) = a*b**t*ln(b)")
print("Starttidspunkt t =", N(start_tid, 6))
print("Årstall =", N(1910 + start_tid, 6))
print("Ulikhet:", terskel)
Utskrift når koden kjøres:
F'(t) = a*b**t*ln(b)
Starttidspunkt t = 13.5382
Årstall = 1923.54
Ulikhet: 13.5382472223893 < t
Fasit: Etter ca. \(13{,}5\) år, altså fra omtrent år \(1924\).
Del 2 · Oppgave 1cGjennomsnittlig vekst
Oppgave 1c
Oppgave (6 poeng):
Hvor mange år gikk det før den gjennomsnittlige befolkningsveksten fra 1910 var større enn \(80\) personer per år ifølge modellen?
Vis løsning
Hva spør oppgaven om? Vi skal identifisere riktig matematisk modell, regne systematisk og kontrollere svaret digitalt uten å hoppe over begrunnelser.
Steg 1 — Skriv gjennomsnittlig vekst
Gjennomsnittlig vekst fra 1910 til \(t\) år etter 1910 er \[\dfrac{F(t)-F(0)}{t}.\]
Steg 2 — Bruk startverdien i modellen
I modellen er \(F(0)\approx 820{,}64\). Siden oppgaven sier fra 1910, kan vi også sammenlikne med det observerte starttallet \(800\). Her bruker vi startåret fra tabellen.
Steg 3 — Sett opp likningen
Vi finner når \[\dfrac{F(t)-800}{t}=80.\]
Steg 4 — Løs digitalt
Med modellen fra a får vi \(t\approx 24{,}24\).
Steg 5 — Tolk årstallet
Dette er omtrent \(1910+24{,}24=1934{,}24\), altså i løpet av 1934.
Tolkning
Det gikk omtrent \(24{,}2\) år før gjennomsnittlig befolkningsvekst fra 1910 ble større enn \(80\) personer per år.
Vanlig feil: Å bruke \(F^{\prime}(t)\) her. Oppgaven spør om gjennomsnittlig vekst fra startåret, ikke momentan vekst.
Kontroll (GeoGebra CAS)
GeoGebra · CAS
1
Løs((820.64*1.05098^t-800)/t=80,t)
→ \(t\approx 24{,}24\)
Kontroll (Python)
Python-kontroll
from sympy import symbols, Eq, nsolve
from sympy import Float, N
t = symbols('t')
a = Float(820.6398353542176)
b = Float(1.0509820497768692)
F = a*b**t
likning = Eq((F - 800)/t, 80)
losning = nsolve(likning, 24)
print("Likning:", "(F(t) - 800)/t = 80")
print("t =", N(losning, 6))
print("Årstall =", N(1910 + losning, 6))
print("Gjennomsnitt ved løsningen =", N((F.subs(t, losning) - 800)/losning, 8))
Utskrift når koden kjøres:
Likning: (F(t) - 800)/t = 80
t = 24.2401
Årstall = 1934.24
Gjennomsnitt ved løsningen = 80.000000
Fasit: Ca. \(24{,}2\) år, altså i løpet av \(1934\).
Del 2 · Oppgave 2aKontinuitet i stykkevis funksjon
Sander, Henny og Kari har hver sin pose med drops. I alle posene er det \(3\) grønne, \(8\) gule og \(7\) røde drops. Sander tar \(2\) tilfeldige drops fra sin pose.
Bestem sannsynligheten for at han tar \(2\) gule drops.
Vis løsning
Hva spør oppgaven om? Vi skal identifisere riktig matematisk modell, regne systematisk og kontrollere svaret digitalt uten å hoppe over begrunnelser.
Steg 1 — Finn totalt antall drops
Hver pose har \(3+8+7=18\) drops.
Steg 2 — Velg modell
Sander tar uten tilbakelegging. Derfor bruker vi hypergeometrisk sannsynlighet.
Steg 3 — Tell gunstige valg
Han må velge \(2\) av de \(8\) gule: \(\binom{8}{2}\).
Steg 4 — Tell alle valg
Alle måter å velge \(2\) drops fra \(18\) på er \(\binom{18}{2}\).
Vanlig feil: Å multiplisere med \(3!\) i tillegg når man bruker kombinasjoner. Kombinasjonstellingen har allerede ignorert rekkefølge.
Kontroll (GeoGebra CAS)
GeoGebra · CAS
1
nCr(3,1)*nCr(8,1)*nCr(7,1)/nCr(18,3)
→ \(\dfrac{7}{34}\)
Kontroll (Python)
Python-kontroll
from sympy import binomial, Rational, N
G, Y, R = 3, 8, 7
totalt = G + Y + R
gunstige = binomial(G, 1)*binomial(Y, 1)*binomial(R, 1)
mulige = binomial(totalt, 3)
P = Rational(gunstige, mulige)
print("Gunstige valg:", gunstige)
print("Mulige valg:", mulige)
print("Sannsynlighet:", P)
print("Desimaltall:", N(P, 6))
Største overskudd er \(8000\) kroner når bedriften produserer og selger \(1000\) enheter.
Vanlig feil: Å maksimere inntekten i stedet for overskuddet. Kostnaden må trekkes fra.
Kontroll (GeoGebra CAS)
GeoGebra · CAS
1
Ekstremalpunkt(-0.02x^2+40x-12000)
→ \((1000,8000)\)
Kontroll (Python)
Python-kontroll
from sympy import symbols, diff, solve, Rational, simplify
x = symbols('x')
K = Rational(2, 100)*x**2 + 60*x + 12000
I = 100*x
O = simplify(I - K)
O_derivert = diff(O, x)
kritisk = solve(O_derivert, x)[0]
storste_overskudd = simplify(O.subs(x, kritisk))
print("K(x) =", K)
print("O(x) =", O)
print("O'(x) =", O_derivert)
print("Maksimalt punkt x =", kritisk)
print("Største overskudd =", storste_overskudd)
Utskrift når koden kjøres:
K(x) = x**2/50 + 60*x + 12000
O(x) = -x**2/50 + 40*x - 12000
O'(x) = 40 - x/25
Maksimalt punkt x = 1000
Største overskudd = 8000
Fasit: Største overskudd er \(8000\) kroner.
Del 2 · Oppgave 4bNullpunkt for underskudd
Oppgave 4b
Oppgave (4 poeng):
De faste kostnadene blir \(8000\) kroner. Bedriften produserer og selger \(1000\) enheter. Hva er den laveste prisen de kan selge produktet for dersom de skal unngå underskudd?
Vis løsning
Hva spør oppgaven om? Vi skal identifisere riktig matematisk modell, regne systematisk og kontrollere svaret digitalt uten å hoppe over begrunnelser.
Steg 1 — Skriv ny kostnadsfunksjon
De faste kostnadene er nå \(8000\), så \[K_{ny}(x)=0{,}02x^2+60x+8000.\]
Nye prøver bør vise omtrent \(44\,\mathrm{OU}/\mathrm{m}^3\) eller lavere for at intensiteten skal være akseptabel eller bedre.
Vanlig feil: Å sette \(C=2\). Det er \(I\), ikke \(C\), som sammenliknes med tabellen.
Kontroll (GeoGebra CAS)
GeoGebra · CAS
1
Løs(1.4*lg(C)-0.3=2,C)
→ \(C\approx 43{,}9\)
Kontroll (Python)
Python-kontroll
from sympy import symbols, Eq, solve, log, N
C = symbols('C', positive=True)
likning = Eq(1.4*log(C, 10) - 0.3, 2)
grense = solve(likning, C)[0]
print("Grense for I = 2:", N(grense, 6))
print("Kontroll I(C):", N(1.4*log(grense, 10) - 0.3, 6))
print("Krav for akseptabelt nivå: C <=", N(grense, 4))
Utskrift når koden kjøres:
Grense for I = 2: 43.9397
Kontroll I(C): 2.00000
Krav for akseptabelt nivå: C <= 43.94
Fasit: \(C\le 43{,}9\), altså omtrent \(44\,\mathrm{OU}/\mathrm{m}^3\) eller lavere.
Del 2 · Oppgave 6aProgramforståelse
Oppgave 6a
Oppgave (4 poeng):
Ola spiller et spill med mange vanlige terninger. Programmet er:
from random import randint
# randint(a,b) gir tilfeldig heltall fra og med a til og med b
runder = 0
terninger = 100
while terninger > 0:
for i in range(terninger):
if randint(1,6) == 6:
terninger = terninger + 3
else:
terninger = terninger - 1
runder = runder + 1
print(runder)
Hva er reglene for spillet?
Vis løsning
Hva spør oppgaven om? Vi skal identifisere riktig matematisk modell, regne systematisk og kontrollere svaret digitalt uten å hoppe over begrunnelser.
Steg 1 — Starttilstand
Spillet starter med \(100\) terninger og \(0\) runder.
Steg 2 — Hva skjer i hver runde
I hver runde kastes alle terningene som finnes ved starten av runden.
Steg 3 — Regel ved sekser
Hvis en terning viser \(6\), får Ola \(3\) nye terninger i tillegg. I antallsmodellen øker antallet med \(3\).
Steg 4 — Regel ved ikke sekser
Hvis terningen ikke viser \(6\), fjernes én terning. Antallet reduseres med \(1\).
Steg 5 — Stoppregel
Spillet fortsetter så lenge antall terninger er større enn \(0\). Når det ikke er terninger igjen, skriver programmet ut antall runder.
Tolkning
Programmet simulerer hvor mange runder det tar før alle terningene er borte.
Vanlig feil: Å tro at nye terninger som oppstår i en runde også kastes i samme runde. `range(terninger)` bestemmes ved starten av for-løkken.
Kontroll (GeoGebra CAS)
GeoGebra · CAS
1
ForventetEndringPerTerning = (1/6)*3+(5/6)*(-1)
→ \(-\dfrac{1}{3}\)
Kontroll (Python)
Python-kontroll
from fractions import Fraction
p_sekser = Fraction(1, 6)
p_ikke_sekser = Fraction(5, 6)
endring_sekser = 3
endring_ikke_sekser = -1
forventet_endring = p_sekser*endring_sekser + p_ikke_sekser*endring_ikke_sekser
print("Startantall terninger:", 100)
print("Ved sekser: antall terninger øker med", endring_sekser)
print("Ved ikke sekser: antall terninger endres med", endring_ikke_sekser)
print("Forventet endring per kast:", forventet_endring)
Utskrift når koden kjøres:
Startantall terninger: 100
Ved sekser: antall terninger øker med 3
Ved ikke sekser: antall terninger endres med -1
Forventet endring per kast: -1/3
Fasit: Start med \(100\) terninger. Kast alle terninger i hver runde. En sekser gir \(+3\) terninger, ellers fjernes \(1\). Spillet slutter når antall terninger er \(0\).
Del 2 · Oppgave 6bSimulering og forventning
Oppgave 6b
Oppgave (4 poeng):
Ola spiller mange ganger. Bestem det gjennomsnittlige antallet runder spillet vil vare.
Vis løsning
Hva spør oppgaven om? Vi skal identifisere riktig matematisk modell, regne systematisk og kontrollere svaret digitalt uten å hoppe over begrunnelser.
Steg 1 — Velg metode
Programmet beskriver en stokastisk prosess. Det naturlige er å simulere mange spill og ta gjennomsnittet.
Steg 2 — Forstå forventet utvikling
For hver terning er forventet endring \(\dfrac{1}{6}\cdot 3+\dfrac{5}{6}\cdot(-1)=-\dfrac{1}{3}\), så antallet terninger minker i gjennomsnitt.
Steg 3 — Gjennomfør simulering
Ved mange simuleringer med samme regler får vi et gjennomsnitt rundt \(8{,}5\) runder.
Steg 4 — Teoretisk kontroll
Dette kan også kontrolleres med en forgreningsprosess der én terning gir \(4\) terninger med sannsynlighet \(\dfrac{1}{6}\) og \(0\) terninger med sannsynlighet \(\dfrac{5}{6}\).
Steg 5 — Beregn forventet varighet
Den teoretiske beregningen gir omtrent \(8{,}52\) runder fra \(100\) startterninger.
Tolkning
Det gjennomsnittlige antallet runder er omtrent \(8{,}5\). I enkeltsimuleringer kan tallet variere betydelig.
Vanlig feil: Å dele \(100\) på forventet reduksjon \(100/\left(100/3\right)=3\). Antallet terninger endres prosentvis og tilfeldig fra runde til runde, så dette gir ikke forventet spilletid.
Kontroll (GeoGebra CAS)
GeoGebra · CAS
1
Simuler(100000 spill)
→ \(\text{gjennomsnitt}\approx 8{,}5\)
2
Sum(1-q_n^100)
→ \(8{,}52\)
Kontroll (Python)
Python-kontroll
from random import randint, seed
from statistics import mean
seed(2025)
def spill():
runder = 0
terninger = 100
while terninger > 0:
start_antall = terninger
for i in range(start_antall):
if randint(1, 6) == 6:
terninger = terninger + 3
else:
terninger = terninger - 1
runder = runder + 1
return runder
antall_simuleringer = 20000
resultater = [spill() for _ in range(antall_simuleringer)]
print("Antall simuleringer:", antall_simuleringer)
print("Gjennomsnittlig antall runder:", round(mean(resultater), 3))
print("Minste observerte antall runder:", min(resultater))
print("Største observerte antall runder:", max(resultater))
Utskrift når koden kjøres:
Antall simuleringer: 20000
Gjennomsnittlig antall runder: 8.52
Minste observerte antall runder: 4
Største observerte antall runder: 34
Fasit: Gjennomsnittlig varighet er omtrent \(8{,}5\) runder.
Intern kontroll før levering
MathJax er satt opp i <head>. All matematikk bruker \(...\) eller \[...\]. Python ligger i <pre><code> med nøytral mørk kodevisning. GeoGebra CAS er visuelt skilt fra løsningsteksten.
ifingo-lærerenHjelper deg å forstå
ifingo-læreren hjelper deg å forstå – ikke å gjøre leksene for deg 💜
