TDT4110 · NTNU

Studieguide for TDT4110 Informasjonsteknologi grunnkurs

Komplett pensumoversikt for informasjonsteknologi grunnkurs ved NTNU — med forklaringer, sentrale begreper, eksamenstips og vanlige fallgruver. Eksamensoptimalisert basert på tidligere eksamener.

Introduksjon

TDT4110 Informasjonsteknologi, grunnkurs er innføringen i prosedyreorientert programmering i Python ved NTNU. Eksamen er en 4 timers skriftlig skoleeksamen i Inspera med hjelpemiddelkode D: ingen trykte eller håndskrevne hjelpemidler, bare en bestemt enkel kalkulator. Settet har som regel et vedlegg med nyttige funksjoner og metoder (innebygde funksjoner, strenger, lister, mengder, ordbøker, filer, random, math, numpy og matplotlib.pyplot), men det manglet i begge H2025-settene. Neste eksamen er 14. desember 2026: ordinær eksamen kl. 09 og ny eksamen kl. 15, for hver sin kandidatgruppe.

Guiden er bygd på 24 eksamenssett: 7 Inspera-sett fra H2023 til H2025 (8.12.2025), fordelt på 5 eksamensdager med to sett både i H2024 og H2025, og 17 papirsett fra 2011–2019, med NTNUs løsningsforslag. Hver deloppgave er talt. Prosentene under er temaets andel av poengene i snitt over de 7 Inspera-settene, og de 13 stofftemaene summerer til 100 %.

Hva eksamen faktisk tester

NumPy og Matplotlib er største tema: med i 7 av 7 sett og 21,9 % av poengene, og 38–39 % i begge H2025-settene.
Lister og 2D-lister (14,9 %), strenger med formatering (9,2 %), algoritmer og programlogikk (7,5 %), filer (7,3 %), ordbøker (6,3 %), funksjoner (6,0 %) og datatyper og operatorer (6,0 %) er hovedtema i 5–7 av 7 sett.
Kontrollstrukturer (5,4 %), tallrepresentasjon (4,8 %), moduler og tilfeldige tall (4,3 %) og unntak (3,6 %) gir færre poeng som hovedtema, men løkker trengs i de fleste oppgaver. Tabellen «eksakt eller ikke eksakt flyttall» står i 6 av 7 sett.
Mengder (2,7 %) er nytt: med i begge H2025-settene (20 poeng), ikke i eldre sett.

Kodeforståelse er ikke et eget stofftema, men en oppgaveform oppå de andre: «hva skrives ut» eller «hva returneres» står i alle 7 settene og gir 8,1 % av poengene, talt inn i temaene over.

Teoriblokken fra papirtida (maskinvare, nettverk, tallsystemer, sikkerhet, systemutvikling, 20–29 % av hvert sett fram til 2019) og rekursjon (hovedtema i 12 av 17 papirsett) er med i 0 av 7 Inspera-sett. Rekursjon står kort i funksjonsseksjonen; resten er utelatt.

Slik er settet bygd

17–24 oppgaver på 2–12 % hver, i tre former: lukkede oppgaver (tabeller med datatype eller ERROR, eksakt/ikke eksakt, riktig/feil, «hva skrives ut», flervalg), ferdig kode med hull der du velger i nedtrekksmenyer eller trekker kodelinjer på plass, og fritt skrevne funksjoner. Den midterste formen har vokst fra 19 % av poengene i H2023 til 52–53 % i H2025. Tretten av seksjonene har ett eksempel i hver av de tre formene, med nummererte steg og svaret til slutt; seksjonen om kodeforståelse trener den lukkede formen, som er hele poenget der.

Fra studieåret 2026/2027 nevner emnebeskrivelsen også bruk av KI i programmering. Ingen av de 24 settene har hatt KI-oppgaver, og eksamen er fortsatt uten hjelpemidler.

Variabler, datatyper og operatorer

Eksamensrelevant

Typereglene for / og //, + og * på strenger og lister, hva and/or returnerer og hvilke typer som er muterbare. Temaet sto i 7 av 7 Inspera-sett, oftest som tabellen «datatype eller ERROR» (4 av 7 sett).

Oversikt

Python bestemmer typen til et uttrykk ut fra operandene og operatoren.

Slik testes dette på eksamen. Temaet er hovedtema i 7 av 7 Inspera-sett (H2023–H2025) og gir 6,0 % av poengene i snitt. Tabellen «kryss av datatype eller ERROR» sto i 4 av 7 sett (K2024, begge H2025-settene og K2025), til sammen 19 poeng, og H2023 hadde en tilsvarende tabell der du krysset av verdien (8 poeng). «Skriv verdien slik print ville vist den» sto i 3 av 7 sett (begge H2024-settene og K2025), til sammen 9 poeng, og H2024 hadde et flervalg om muterbarhet.

Typereglene du trenger

/ gir alltid float, også når svaret går opp: 9 / 3 * 2 gir 6.0.
// og % mellom to int gir int. Er én operand float, blir svaret float.
str * int og list * int gjentar sekvensen. str + int, list + int og str * float gir TypeError.
Indeks utenfor sekvensen gir IndexError, indeks av typen float gir TypeError.
print(...) skriver ut, men verdien av uttrykket er None (typen NoneType).
not x gir alltid bool. x and y og x or y gir en av operandene.

Regnerekkefølge og «skriv verdien»

Fra sterkest til svakest: **, fortegn (-x), * / // %, + -, sammenligninger, not, and, or. ** grupperes fra høyre. Uttrykk og verdi:

8 - 2 * 3 ** 2   -> -10
-3 ** 2          -> -9
(-3) ** 2        -> 9
2 ** 3 ** 2      -> 512
0 or "" or "x"   -> 'x'
3 and 0          -> 0
4 and 5          -> 5
2 < 5 < 4        -> False
not 0 == 1       -> True

or returnerer den første sanne operanden, and den første usanne; finnes ingen, den siste. 2 < 5 < 4 er en kjede og betyr 2 < 5 and 5 < 4. I en «skriv verdien»-boks skriver du 6.0, ikke 6, og x uten fnutter, slik print viser det.

`//` og `%` med negative tall

// runder nedover (mot minus uendelig), og resten får samme fortegn som divisoren. Sammenhengen (a // b) * b + a % b == a gjelder alltid:

  17 //  5 =   3     17 %  5 =   2
 -17 //  5 =  -4    -17 %  5 =   3
  17 // -5 =  -4     17 % -5 =  -3
 -17 // -5 =   3    -17 % -5 =  -2
int(-3.7) = -3   -3.7 // 1 = -4.0

int() kutter mot null, // runder nedover. De er like bare for positive tall.

Muterbarhet

Lister, ordbøker og mengder er muterbare. int, float, str, bool og tuple er det ikke. To navn på samme liste ser samme endring:

a = [1, 2]
b = a
b.append(3)      # a = [1, 2, 3], a is b: True
p = (1, 2)
p[0] = 5

Siste linje gir TypeError: 'tuple' object does not support item assignment. Kopi: a[:].

Eksempel 1: Type eller ERROR (form: avkryssingstabell)

Gitt m = 6, v = 1.5, by = 'Oslo' og rute = [3, 'buss', 7]. Kryss av for typen til hvert uttrykk, eller ERROR.

Uttrykk	Svar	Uttrykk	Svar
`m // 4`	int	`v * m`	float
`m / 3`	float	`rute[1] * v`	ERROR
`by * 2`	string	`m > v and by`	string
`by[m]`	ERROR	`not rute`	bool
`rute * 2`	list	`print(m)`	NoneType
`by + m`	ERROR	`len(by) % m`	int

m // 4 og len(by) % m har bare int-operander og gir int (1 og 4).
m / 3 bruker / og gir 2.0. v * m har en float-operand og gir 9.0.
by * 2 og rute * 2 gjentar sekvensen: 'OsloOslo' og en liste med seks elementer.
by[m] ber om indeks 6 i en streng med fire tegn: IndexError.
by + m blander str og int: TypeError. rute[1] * v er 'buss' * 1.5, og en sekvens kan bare ganges med int: TypeError.
m > v er True, så and returnerer høyre operand, strengen 'Oslo'.
not gir alltid bool; en ikke-tom liste er sann, så svaret er False. print(m) har verdien None.

Svar: int, float, string, ERROR, list, ERROR, float, ERROR, string, bool, NoneType, int (i rekkefølgen fra m // 4 til len(by) % m, kolonne for kolonne).

Eksempel 2: Side og plass i fotoalbumet (form: ferdig kode med hull)

Bildene i et album er nummerert fra 0, og det er per_side bilder per side. Funksjonen skal returnere side og plass på siden, begge talt fra 1, som heltall.

def plassering(bildenr, per_side):
    side = ___1___ + 1
    plass = ___2___ + 1
    ___3___

Hull 1: bildenr / per_side · bildenr // per_side · bildenr % per_side. Hull 2: per_side % bildenr · bildenr % per_side · bildenr - per_side. Hull 3: print(side, plass) · return side, plass · return side + plass.

Hull 1: antall fulle sider foran bildet er heltallskvotienten. / ville gitt 3.1666666666666665 for bilde 13, altså en float. Velg bildenr // per_side.
Hull 2: plassen er resten etter de fulle sidene. per_side % bildenr har operandene i feil rekkefølge og gir ZeroDivisionError for bilde 0. Velg bildenr % per_side.
Hull 3: oppgaven sier «returnere». print gir None tilbake, og en sum mister informasjon. Velg return side, plass.
Kontroll med seks per side: bilde 6 gir (2, 1) og bilde 13 gir (3, 2).

Svar: hull 1 bildenr // per_side, hull 2 bildenr % per_side, hull 3 return side, plass.

Eksempel 3: Ukedag fram og tilbake i tid (form: skriv funksjonen selv)

Skriv ukedag(dag_nr, forskyvning). dag_nr er 0 for mandag og 6 for søndag, og forskyvning er et antall dager, også negativt. Returner forkortelsen for ukedagen det blir.

DAGER = ['man', 'tir', 'ons', 'tor', 'fre',
         'lør', 'søn']

def ukedag(dag_nr, forskyvning):
    return DAGER[(dag_nr + forskyvning) % 7]

Ukedagene gjentar seg med periode 7, så indeksen er summen redusert med % 7.
For negativ forskyvning er % i Python allerede riktig: (5 - 9) % 7 gir 3, ikke −4, fordi resten får samme fortegn som divisoren 7.
Resultatet ligger alltid i 0–6, så indekseringen kan ikke gi IndexError, heller ikke for forskyvning = 700.
Utskrift: ukedag(5, -9) gir 'tor', ukedag(2, -2) gir 'man' og ukedag(6, 700) gir 'søn'.

Lista DAGER med sju celler, man til søn, og indeksene 0 til 6 under. Cellen lør (indeks 5) er markert med pila «start: lør (5)», og cellen tor (indeks 3) er markert med pila «(5 - 9) % 7 = 3»: ni dager før lørdag er torsdag.

Figuren viser hvor (5 - 9) % 7 havner i DAGER.

Svar: return DAGER[(dag_nr + forskyvning) % 7]. Én linje holder, og den håndterer negative forskyvninger uten if.

Nøkkelformler

•/ gir alltid float; // og % mellom to int gir int
•// runder nedover: -7 // 2 er -4; int(-3.7) er -3
•(a // b) * b + a % b == a; resten har samme fortegn som b
•str * int og list * int gjentar; str + int gir TypeError
•x or y gir første sanne operand, x and y første usanne
•Rekkefølge: **, fortegn, * / // %, + -, sammenligning, not, and, or
•Muterbare: list, dict, set. Ikke muterbare: int, float, str, bool, tuple

Vanlige feil

⚠️Skriver 6 der svaret er 6.0: / gir alltid flyttall, også når divisjonen går opp
⚠️Krysser av bool for m > v and by, men and returnerer operanden by, altså en streng
⚠️Krysser av string for print(m): verdien av uttrykket er None, typen NoneType
⚠️Tror -3 ** 2 er 9; ** binder sterkere enn fortegnet, så svaret er -9
⚠️Tror -7 % 3 er -1; resten følger fortegnet til divisoren og blir 2
⚠️Tror 'buss' * 1.5 virker; en sekvens kan bare ganges med int

Eksamenstips

💡Tabellen «datatype eller ERROR» sto i 4 av 7 Inspera-sett: gå radvis og spør først om uttrykket i det hele tatt er lov
💡Ingen minuspoeng på tabellene: kryss av på hver rad, også der du er usikker
💡I «skriv verdien»-bokser skriver du nøyaktig det print viser: 6.0, True, x uten fnutter
💡Se etter and/or med ikke-boolske operander; da er svaret en av operandene, ikke True/False
💡I nedtrekkshull: velg // når svaret skal være et heltall, og return når oppgaven sier «returnere»

Laster...

Laster…