9.1 Midtveis-simulering: 20 flervalg
Komplett midtveis-simulering etter det reelle formatet: 20 flervalgsspørsmål, ingen kodeskriving, med fullstendige sporingsløsninger.
| Det reelle settet | Denne simuleringen |
|---|---|
| 20 spørsmål | 20 spørsmål |
| Maks 25 poeng | Maks 25 poeng |
| Cirka 2 timer effektiv tid | 120 minutter |
| «select one» à 1 poeng, pluss 4–6 «match the values»-tabeller à 0,5 poeng per rad | 14 «select one» (14 poeng) + 6 matche-tabeller (11 poeng) |
| 100 % flervalg, ingen kodeskriving | 100 % flervalg |
To uttrykk du møter i Inspera: «select one» betyr at du krysser av på ett av alternativene, og «match the values» — på norsk matche-tabell — betyr at du parer hver rad i en tabell med ett svar fra en nummerert liste. Hver rad er verdt 0,5 poeng, så en tabell med fire rader gir 2 poeng. Du får poeng for hver rad du treffer, uavhengig av de andre radene.
Kryss alltid av. Blankt og feil gir det samme — 0 poeng — og fra 2024/2025 er negativ uttelling fjernet fra midtveissettet. Det koster deg ingenting å gjette på det siste spørsmålet før tiden går ut.
Fem sjangre går igjen på midtveis, og alle fem er med her. Bokas sjangerkoder står som en liten merkelapp foran hver oppgave, og de er forklart i klarspråk der de brukes: sjanger A — kodesporing, altså «hva skriver dette programmet ut?»; sjanger B — matche-tabell der du regner ut indekserings- og slicing-uttrykk; sjanger C — matche-tabell der du avgjør hvilken feil programmet utløser først; sjanger D — matche-tabell om løkketerminering og «hvilke kodealternativer er riktige»; sjanger E — «hvilken linje mangler / hvilket funksjonskall er riktig».
Denne simuleringen er nyskrevet av Skolesaga. Den er ikke et offisielt UiO-sett, og den forutsier ikke hva som kommer på din eksamen.
- kap. 1.1 — variabler, uttrykk og operatorpresedens
- kap. 1.2 — lister, indeksering og slicing
- kap. 1.3 — løkker, range, zip og nøstede løkker
- kap. 1.4 — strenger, f-strenger og formatert utskrift
- kap. 1.5 — dictionaries og nøstede dictionaries
- kap. 1.6 — funksjoner, scope og lambda
- kap. 1.7 — sporingsmetoden: hvordan du fører en tavle over variablene
- kap. 2.1 og kap. 2.2 — kommandolinje, sys.argv og feilhåndtering
- kap. 4.1 — NumPy-arrays og forskjellen mellom liste og array
- kap. 8.1 — fillesing til dictionary (to av spørsmålene leser en fil)
Har du ikke lest Del 8 ennå, kan du ta simuleringen likevel: de to fillesings-spørsmålene viser filinnholdet i oppgaveteksten, og alt du trenger å kunne er split, strip og float.
Slik tar du simuleringen
Sett av 120 minutter og en klokke. Skriv svarene på papir, i to kolonner: spørsmålsnummer og bokstav (eller radpar for matche-tabellene). Åpne først løsningen når du er ferdig med alt.
Ikke kjør koden. Det er hele poenget: i oktober har du bare hodet og papiret. Skal du bare øve på én ting i dette kapitlet, øv på å føre en sporingstavle for hånd — metoden står i kap. 1.7.
| Blokk | Spørsmål | Poeng | Tid |
|---|---|---|---|
| 1 | 1–5 | 5 | ~25 min |
| 2 | 6–10 | 7,5 | ~30 min |
| 3 | 11–15 | 6,5 | ~35 min |
| 4 | 16–20 | 6 | ~30 min |
| Sum | 20 spørsmål | 25 poeng | 120 min |
Blokkene er bare en tidsplan, ikke en del av det reelle settet. Tar du simuleringen som eksamenstrening, sitter du de 120 minuttene sammenhengende. Tar du den som lesetrening, er blokkgrensene naturlige pausepunkter — én blokk per kveld går helt fint.
Ett råd om disponering: matche-tabellene (spørsmål 6, 10, 14, 15, 19 og 20) er de dyreste enkeltspørsmålene, men også de mest mekaniske. Sitter du fast på en sporing, hopp videre og kom tilbake — et halvt poeng du henter i en tabell er verdt like mye som et halvt poeng du kjemper for i en nøstet løkke.
Blokk 1 — spørsmål 1–5
~25 minutter · 5 poeng · fem «select one» à 1 poeng.
Alle fem er kodesporing. Skriv utskriften på papir før du velger alternativ — det er den ferdigheten som blir målt, ikke evnen til å kjenne igjen et alternativ.
Hva skriver programmet ut?
total = 0
for k in range(2, 11, 3):
total += k
print(total)a) 26
b) 15
c) 18
d) 8
Programmet skriver ut én linje. Hvilken?
for i in range(1, 4):
for j in range(i):
print(i + j, end=' ')
print()a) 1 2 3 4 5 6
b) 1 3 5
c) 1 2 3 3 4 5
d) 2 3 4 4 5 6
Hva skriver programmet ut?
tall = [4, 9, 16, 25, 36]
print(tall[-2], tall[1:4])a) 25 [9, 16, 25]
b) 36 [9, 16, 25]
c) 25 [9, 16, 25, 36]
d) 16 [4, 9, 16]
Fire utgravningsruter er registrert, men bare tre av dem er ferdig opptelt. Hva skriver programmet ut?
rute = ['R1', 'R2', 'R3', 'R4']
funn = [4, 9, 2]
s = 0
for navn, antall in zip(rute, funn):
s += antall
print(len(rute), s)a) 3 15
b) 4 20
c) 3 20
d) 4 15
En radioaktiv prøve halveres i hver runde. Hva skriver programmet ut?
masse = 80.0
halveringer = 0
while masse > 5:
masse = masse / 2
halveringer += 1
print(masse, halveringer)a) 2.5 5
b) 5.0 4
c) 5 4
d) 10.0 3
— naturlig pausepunkt —
Blokk 2 — spørsmål 6–10
~30 minutter · 7,5 poeng. Én matche-tabell om indeksering (2 poeng), tre «select one» (3 poeng) og én matche-tabell om feilhåndtering (2,5 poeng).
I matche-tabellene skal hver rad pares med ett nummer fra alternativlista. Samme nummer kan brukes flere ganger, og noen numre brukes ikke. Hver rad er 0,5 poeng.
Gitt
x = [2, 0, 3]
y = [[5, 8, 13], [21, 34, 55], [89, 144, 233]]Par hvert uttrykk med verdien det har.
| Rad | Uttrykk |
|---|---|
| 1 | y[x[1]][x[0]] |
| 2 | y[x[0]][x[-1]:] |
| 3 | y[1][x[1]:x[2]] |
| 4 | x[y[0][0] - 3] |
Alternativer:
1.
[]2.
33.
[13]4.
135. [21, 34, 55]
6. 89
7. 2
8. [89, 144, 233]
Hva skriver programmet ut?
print(-11 // 4, 2 ** 2 ** 3, 8 / 4)a) -2 256 2.0
b) -3 64 2
c) -2 64 2.0
d) -3 256 2.0
Hva skriver programmet ut?
import numpy as np
maling = [2, 3]
vektor = np.array([2, 3])
print(maling + maling, vektor + vektor)a) [4, 6] [4 6]
b) [2, 3, 2, 3] [2, 3, 2, 3]
c) [2, 3, 2, 3] [4 6]
d) [4, 6] [2 3 2 3]
Hva skriver programmet ut? Alternativene står mellom fnutter så mellomrommene blir synlige.
tid = 3.14159
nummer = 7
print(f'{tid:6.2f}|{nummer:03d}')a) ' 3.14|007'
b) '3.14|007'
c) ' 3.14|7'
d) ' 3.142|007'
En exception er en feil som avbryter programmet. Filen analyse.py inneholder:
import sys
maling = [8.0, 0.0, 2.5]
i = int(sys.argv[1])
faktor = float(sys.argv[2])
print(maling[i] / (faktor * maling[i - 1]))Par hver kommandolinje med det som skjer.
| Rad | Kommandolinje |
|---|---|
| 1 | python analyse.py 2 1.5 |
| 2 | python analyse.py 1 |
| 3 | python analyse.py to 1.5 |
| 4 | python analyse.py 1 2 |
| 5 | python analyse.py 5 1.5 |
Alternativer:
1.
ValueError2.
IndexError3. Ingen feil — programmet skriver et tall
4.
ZeroDivisionError5.
TypeError— naturlig pausepunkt —
Blokk 3 — spørsmål 11–15
~35 minutter · 6,5 poeng. Tre «select one» (3 poeng) og to matche-tabeller (2 + 1,5 poeng). Her kommer dictionaries, fillesing og løkketerminering.
Programmet skriver ut to linjer. Hvilket alternativ har begge riktig? Linjeskiftet er markert med /.
celle = {'A1': {'spenning': 4, 'strom': 7}, 'B2': {'spenning': 9}}
celle['B2']['strom'] = 3
print(len(celle), celle['A1']['strom'] + celle['B2']['strom'])
print('strom' in celle, 'A1' in celle)a) 2 10 / True True
b) 2 12 / False True
c) 3 10 / False True
d) 2 10 / False True
Filen rystelser.txt inneholder registrerte jordskjelvstyrker:
dato;styrke
2026-03-02;2.4
2026-03-05;3.1
2026-03-11;1.7Hva skriver programmet ut?
sum_styrke = 0
with open('rystelser.txt') as infile:
infile.readline()
for linje in infile:
felt = linje.split(';')
sum_styrke += float(felt[1])
print(sum_styrke)a) 4.8
b) 7.2
c) 7
d) Programmet stopper med ValueError
En linje fra en semikolonseparert datafil er lest inn med linjeskiftet på. Hva skriver programmet ut?
linje = 'prove-7; 12.5 ;3\n'
felt = linje.split(';')
print(len(felt), repr(felt[-1]))a) 2 '3'
b) 3 '3'
c) 3 '3\n'
d) 2 ' 12.5 '
Avgjør for hver løkke om den terminerer eller går uendelig. Alle variabler er satt slik det står.
| Rad | Løkke |
|---|---|
| 1 | x = 10 og while x > 0: x = x - 3 |
| 2 | k = 5 og while k != 0: k = k - 2 |
| 3 | n = 1 og while n < 100: n = n * 2 |
| 4 | s = 0.0 og while s != 1.0: s = s + 0.1 |
Alternativer:
1. Terminerer
2. Går uendelig
Oppgaven kodebitene skal løse: finn den største verdien i lista verdier, som er ikke-tom og kan inneholde negative tall. Etterpå skal storst inneholde svaret.
| Rad | Kodebit |
|---|---|
| 1 | storst = verdier[0] og for v in verdier: if v > storst: storst = v |
| 2 | storst = 0 og for v in verdier: if v > storst: storst = v |
| 3 | storst = verdier[0] og for i in range(1, len(verdier)): if verdier[i] > storst: storst = verdier[i] |
Alternativer:
1. Løser oppgaven
2. Løser den ikke
— naturlig pausepunkt —
Blokk 4 — spørsmål 16–20
~30 minutter · 6 poeng. Tre «select one» (3 poeng), én matche-tabell om slicing (1,5 poeng) og én om feilhåndtering (1,5 poeng). Dette er de siste seks poengene — husk at du skal krysse av på alt før tiden går ut.
Hva skriver programmet ut?
def juster(verdi):
verdi = verdi + 10
return verdi
verdi = 5
ny = juster(verdi)
print(verdi, ny)a) 5 15
b) 15 15
c) 5 5
d) 15 5
Hva skriver programmet ut?
tekst = 'nord-sor-ost'
deler = tekst.split('-')
print(deler[1], '+'.join(deler[:2]), tekst.index('sor'))a) sor nord+sor 4
b) sor nord+sor+ost 5
c) nord nord+sor 5
d) sor nord+sor 5
Funksjonen under regner ut den numeriske deriverte av en funksjon g i punktet x:
def derivert(g, x, h=1e-5):
return (g(x + h) - g(x - h)) / (2 * h)Hvilken linje skriver ut en tilnærming til den deriverte av i (den eksakte verdien er 12)?
a) print(derivert(x**3, 2))
b) print(derivert(lambda x: x**3, 2))
c) print(derivert('x**3', 2))
d) print(derivert(x**3, 2, 1e-5))
Gitt t = [0.0, 0.5, 1.0, 1.5, 2.0]. Par hvert uttrykk med verdien.
| Rad | Uttrykk |
|---|---|
| 1 | t[-1] |
| 2 | t[:2] |
| 3 | t[1:4:2] |
Alternativer:
1.
[0.5, 1.5]2.
2.03.
[0.0, 0.5]4. [2.0]
5. [0.5, 1.0]
6. 1.5
Gitt funksjonen
def middel(verdier):
assert len(verdier) > 0, 'tom liste'
return sum(verdier) / len(verdier)Par hvert kall med det som skjer.
| Rad | Kall |
|---|---|
| 1 | middel([]) |
| 2 | middel([2, 'tre']) |
| 3 | middel([4, 6]) |
Alternativer:
1.
TypeError2. Ingen feil — funksjonen returnerer et tall
3.
AssertionError4. ValueError
5. ZeroDivisionError
Rett deg selv
Ett poeng per «select one», 0,5 poeng per rad i matche-tabellene. Maks 25 poeng, akkurat som på det reelle settet.
| Spørsmål | Sjanger | Riktig svar | Poeng |
|---|---|---|---|
| 1 | A | b | 1 |
| 2 | A | c | 1 |
| 3 | A | a | 1 |
| 4 | A | d | 1 |
| 5 | A | b | 1 |
| 6 | B | rad 1→4, 2→1, 3→5, 4→2 | 2 |
| 7 | A | d | 1 |
| 8 | A | c | 1 |
| 9 | A | a | 1 |
| 10 | C | rad 1→4, 2→2, 3→1, 4→3, 5→2 | 2,5 |
| 11 | A | d | 1 |
| 12 | A | b | 1 |
| 13 | A | c | 1 |
| 14 | D | rad 1→1, 2→2, 3→1, 4→2 | 2 |
| 15 | D | rad 1→1, 2→2, 3→1 | 1,5 |
| 16 | A | a | 1 |
| 17 | A | d | 1 |
| 18 | E | b | 1 |
| 19 | B | rad 1→2, 2→3, 3→1 | 1,5 |
| 20 | C | rad 1→3, 2→1, 3→2 | 1,5 |
| Sum | 25 |
Hva sier summen? Ikke les den som en karakter. Midtveiseksamen teller 25 %, og karakteren A–F settes samlet til slutt sammen med den avsluttende eksamenen. Bruk summen som et kart over hva du skal lese om igjen, ikke som en spådom. Og husk at C er en god og vanlig karakter i IN1900 — målet er å skrive kode som virker og har riktig struktur, ikke å være plettfri.
Selvdiagnose — kryss av det du faktisk gjorde:
- ☐ Telte du iterasjonene i
range(start, stop, step) uten å ta med stop? (Bommet du: kap. 1.3)- ☐ Husket du at
end=' ' fjerner linjeskiftet, og at det legger igjen et mellomrom helt til slutt? (kap. 1.4)- ☐ Skilte du element (indeksering) fra liste (slicing), og husket du at slutten er eksklusiv? (kap. 1.2)
- ☐ Stoppet
zip ved den korteste sekvensen i sporingen din? (kap. 1.3)- ☐ Ga
+ deg skjøting på lister og elementvis sum på arrayer? (kap. 4.1)- ☐ Fant du hvilken feil som kom først, og husket du at
sys.argv[0] er filnavnet? (kap. 2.2)- ☐ Avgjorde du løkketerminering ved å spørre om betingelsen kan bli usann? (kap. 1.3)
- ☐ Holdt du den lokale og den globale variabelen fra hverandre? (kap. 1.6)
- ☐ Skrev du utskriften med riktig antall desimaler og riktige mellomrom, ikke bare riktig tall? (kap. 1.4)
- ☐ Krysset du av på alle 20 spørsmålene?
Er det ett punkt du skal ta med deg videre, er det det siste tekniske: over halvparten av poengene på midtveis avgjøres av utskriftsdetaljer, ikke av regnestykker.
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.
Skolesaga er en uavhengig læringsressurs og er ikke tilknyttet eller godkjent av Universitetet i Oslo. Dette er ikke offisielt studiemateriell. Les mer.