Løsningsforslag – IT 2 Python Vår 2026

Eksamen: REA3049 Informasjonsteknologi 2 | Semester: Vår 2026 | Varighet: 5 timer | Språkvariant: Python | Tema: OOP-begreper, pseudokode og flytskjema, togsett-modellering, kjøretøydatasett, etikk (kameraovervåking), spillprogrammering

Oppgave 1 – Hva er hovedformålet med en konstruktør?

Begrunnelse: En konstruktør er en spesiell metode som kjøres automatisk når et nytt objekt (en instans) opprettes fra en klasse. Oppgaven dens er å initialisere objektets tilstand – altså gi attributtene sine startverdier. I Python heter konstruktøren __init__, og den mottar self pluss eventuelle argumenter:

class Elev:
    def __init__(self, navn, alder):
        self.navn = navn      # startverdi for attributt
        self.alder = alder    # startverdi for attributt

elev = Elev("Noah", 15)  # __init__ kjøres automatisk her

De andre alternativene beskriver andre mekanismer: å definere metodene gjøres i klassekroppen generelt; å opprette nye klasser basert på eksisterende er arv; og å styre kommunikasjon mellom objekter handler om meldingsutveksling/metodekall, ikke om initialisering.

Oppgave 2 – Hvordan fungerer arv?

Begrunnelse: Arv (generalisering/spesialisering) går fra superklasse til subklasse. Kjøretøy er superklassen (det generelle), mens Bil og Buss er subklasser (det spesialiserte). Subklassene arver alt som er definert i superklassen, og kan i tillegg legge til egne attributter og metoder eller overstyre arvede metoder.

class Kjoretoy:
    def __init__(self, hastighet):
        self.hastighet = hastighet

class Bil(Kjoretoy):        # arver fra Kjøretøy
    def __init__(self, hastighet, antall_dorer):
        super().__init__(hastighet)  # arvet attributt
        self.antall_dorer = antall_dorer  # egen attributt

Alternativet «Kjøretøy får tilgang til alt i Bil og Buss» snur arveretningen feil vei (superklassen kjenner ikke subklassene). At klassene skulle være «uavhengige» er også feil – de deler en generaliseringsrelasjon.

Oppgave 3 – Sorter pseudokoden

Begrunnelse: Vi trenger to variabler: en teller antall som starter på 0, og en løkketeller i som styrer at vi leser nøyaktig fem tall. Inne i løkka leses ett tall, det testes mot 10, telleren økes ved treff, og løkketelleren økes til slutt. Legg merke til at SET antall TO antall + 1 må ligge inne i IF … ENDIF, mens SET i TO i + 1 må ligge utenfor IF men inne i WHILE – ellers telles feil.

Tilsvarende Python-kode ser slik ut:

antall = 0
i = 1
while i <= 5:
    tall = int(input("Skriv et tall: "))
    if tall > 10:
        antall = antall + 1
    i = i + 1
print(antall)

Oppgave 4 – Flytskjema og pseudokode

Oppgave 4a – Hvilken pseudokode matcher flytskjemaet?

Slik løser du 4a: Les flytskjemaet ovenfra og ned. Noter for hver blokk hvilken type den er:

• Oval = start/slutt
• Rektangel = handling (tilordning, utregning)
• Parallellogram = inn-/utdata (READ/DISPLAY)
• Rombe (diamant) = betingelse (IF/WHILE) – én pil ut for «ja», én for «nei»

Gå deretter gjennom hver av de tre pseudokode-sekvensene og sjekk at rekkefølgen på handlinger, den samme betingelsen (f.eks. > mot >=), og løkkestrukturen (om testen står før eller etter kroppen) stemmer overens med flytskjemaet. Sekvensen som har identisk rekkefølge og identiske betingelser, er svaret. Vær særlig oppmerksom på forskjellen mellom en WHILE-løkke (test først) og en REPEAT/UNTIL-løkke (test sist), og på om en pil peker tilbake til før eller etter en tilordning.

Oppgave 4b – Forklar med egne ord hva algoritmen gjør

Et godt 4b-svar navngir blokktypene, beskriver løkkas start- og sluttbetingelse, forklarer hva beslutningsblokken tester, og oppsummerer algoritmens formål i én setning – akkurat som malen over.

Oppgave 5 – Togsett, lokomotiv, togdel og vogn

Oppgave 5a – Klassene Togsett og Lokomotiv

Vi bruker komposisjon: når et Togsett opprettes, oppretter konstruktøren automatisk sitt eget Lokomotiv. Lokomotivet velger tilfeldig trekkraft med random.choice.

# togsett.py — oppgave 5
import random


class Lokomotiv:
    TREKKRAFT_VALG = (320, 450, 600)  # tonn

    def __init__(self):
        self.trekkraft = random.choice(self.TREKKRAFT_VALG)

    def __str__(self):
        return f"Lokomotiv med trekkraft {self.trekkraft} tonn"


class Togsett:
    def __init__(self):
        # Komposisjon: et togsett FÅR automatisk et lokomotiv
        self.lokomotiv = Lokomotiv()

Oppgave 5b – Program som oppretter et togsett og skriver ut lokomotivinfo

def main():
    togsett = Togsett()
    print("Nytt togsett opprettet.")
    print(togsett.lokomotiv)   # f.eks. "Lokomotiv med trekkraft 450 tonn"


if __name__ == "__main__":
    main()

Oppgave 5c – Togdel og Vogn, med endringer i Togsett og Lokomotiv

Nå innføres superklassen Togdel. Den holder et klassevariabel-teller slik at hvert serienummer blir unikt. Lokomotiv og Vogn arver fra Togdel. Togsett får metoder for å legge til både nye og eksisterende vogner.

# togsett.py — full versjon etter 5c
import random


class Togdel:
    """Superklasse for alle deler i et togsett. Gir unikt serienummer."""
    _neste_serienummer = 1

    def __init__(self, vekt):
        self.serienummer = Togdel._neste_serienummer
        Togdel._neste_serienummer += 1   # garanterer unikhet
        self.vekt = vekt

    def __str__(self):
        return f"Togdel #{self.serienummer} ({self.vekt} tonn)"


class Lokomotiv(Togdel):
    TREKKRAFT_VALG = (320, 450, 600)  # tonn

    def __init__(self):
        super().__init__(vekt=120)  # egenvekt (ikke spesifisert; teller ikke mot grensen)
        self.trekkraft = random.choice(self.TREKKRAFT_VALG)

    def __str__(self):
        return f"Lokomotiv #{self.serienummer}: trekkraft {self.trekkraft} tonn"


class Vogn(Togdel):
    def __init__(self):
        super().__init__(vekt=random.randint(20, 50))  # tilfeldig 20–50 tonn

    def __str__(self):
        return f"Vogn #{self.serienummer}: vekt {self.vekt} tonn"


class Togsett:
    def __init__(self):
        self.lokomotiv = Lokomotiv()   # komposisjon
        self.vogner = []

    def samlet_vognvekt(self):
        return sum(v.vekt for v in self.vogner)

    def kan_legge_til(self, vogn):
        """Sant hvis vognen får plass innenfor trekkraften."""
        return self.samlet_vognvekt() + vogn.vekt <= self.lokomotiv.trekkraft

    def legg_til_vogn(self, vogn=None):
        """Legg til en eksisterende vogn, eller opprett en ny hvis ingen gis."""
        if vogn is None:
            vogn = Vogn()          # ny vogn
        self.vogner.append(vogn)   # eksisterende ELLER ny
        return vogn

Oppgave 5d – Utvidet program: fyll opp til trekkraften er nådd

def main():
    togsett = Togsett()
    print("Nytt togsett opprettet.")
    print(togsett.lokomotiv)

    # Legg til vogner helt til neste vogn ikke får plass innenfor trekkraften
    while True:
        vogn = Vogn()
        if not togsett.kan_legge_til(vogn):
            break
        togsett.legg_til_vogn(vogn)

    print(
        f"\nLa til {len(togsett.vogner)} vogner "
        f"(samlet vekt {togsett.samlet_vognvekt()} av maks "
        f"{togsett.lokomotiv.trekkraft} tonn):"
    )
    for vogn in togsett.vogner:
        print(f"  {vogn}")


if __name__ == "__main__":
    main()

Oppgave 6 – Etisk dilemma ved kameraovervåking

Oppgave 7 – Registrerte kjøretøy 2008–2024 (datasett)

Oppgave 7a – Totalt antall elbiler per år (2014–2024)

# kjoretoy.py — oppgave 7
import csv
from collections import defaultdict
from pathlib import Path
import matplotlib.pyplot as plt

DATAFIL = Path("kjoretoy_2008_2024.csv")
EL = "elektrisk"   # drivstofftype for elbil (sammenlignes med .lower())


def les_data(filsti=DATAFIL):
    """Les CSV og returner liste av dict-rader: aar, region, drivstofftype, antall."""
    with filsti.open(encoding="utf-8") as f:
        return list(csv.DictReader(f, delimiter=";"))


def elbiler_per_aar(data):
    """Sum av elbiler per år på tvers av alle regioner."""
    resultat = defaultdict(int)
    for rad in data:
        if rad["drivstofftype"].lower() == EL:
            resultat[int(rad["aar"])] += int(rad["antall"])
    return resultat


def vis_elbiltabell(data, fra=2014, til=2024):
    per_aar = elbiler_per_aar(data)
    print(f"\n{'År':<6}{'Elbiler':>12}")
    print("-" * 18)
    for aar in range(fra, til + 1):
        print(f"{aar:<6}{per_aar.get(aar, 0):>12,}".replace(",", " "))

Oppgave 7b – Elbiler per region for valgt år (sortert + andel)

def region_statistikk(data, aar):
    """For gitt år: {region: {"elbiler": n, "totalt": m}}."""
    stat = defaultdict(lambda: {"elbiler": 0, "totalt": 0})
    for rad in data:
        if int(rad["aar"]) != aar:
            continue
        antall = int(rad["antall"])
        stat[rad["region"]]["totalt"] += antall
        if rad["drivstofftype"].lower() == EL:
            stat[rad["region"]]["elbiler"] += antall
    return stat


def vis_aar(data, aar):
    stat = region_statistikk(data, aar)
    # Sorter synkende etter antall elbiler
    rader = sorted(stat.items(), key=lambda x: x[1]["elbiler"], reverse=True)

    print(f"\nElbiler per region i {aar} (synkende):")
    print(f"{'Region':<20}{'Elbiler':>10}{'Andel':>10}")
    print("-" * 40)
    for region, tall in rader:
        andel = tall["elbiler"] / tall["totalt"] * 100 if tall["totalt"] else 0
        print(f"{region:<20}{tall['elbiler']:>10}{andel:>9.1f} %")

Oppgave 7c – Linjediagram for valgt region (per drivstofftype)

def linjediagram(data, region):
    # {drivstofftype: {aar: antall}}
    per_type = defaultdict(lambda: defaultdict(int))
    for rad in data:
        if rad["region"].lower() != region.lower():
            continue
        per_type[rad["drivstofftype"]][int(rad["aar"])] += int(rad["antall"])

    if not per_type:
        print(f"Fant ingen data for regionen '{region}'.")
        return

    aar_liste = sorted({int(r["aar"]) for r in data})
    plt.figure(figsize=(10, 6))
    for drivstoff, verdier in sorted(per_type.items()):
        y = [verdier.get(a, 0) for a in aar_liste]
        plt.plot(aar_liste, y, marker="o", label=drivstoff)

    plt.title(f"Registrerte kjøretøy i {region} (2008–2024)")
    plt.xlabel("År")
    plt.ylabel("Antall registrerte")
    plt.legend()
    plt.grid(True, alpha=0.3)
    plt.tight_layout()
    plt.show()


def main():
    data = les_data()
    vis_elbiltabell(data)                       # 7a

    aar = int(input("\nVelg et år (2014–2024): "))
    vis_aar(data, aar)                          # 7b

    region = input("Velg en region (f.eks. Telemark): ").strip()
    linjediagram(data, region)                 # 7c


if __name__ == "__main__":
    main()

Oppgave 8 – Spillet «stolpebyggeren»

# stolpebyggeren.py — oppgave 8
import random
import sys
import pygame

BREDDE, HOYDE = 800, 400
FANGER_B, FANGER_H = 150, 70
DEL_H = 50
DEL_BREDDER = (50, 100, 150)
KANT = 50                # deler minst 50 px fra sidene
STOLPE_B = DEL_H            # bredde på en rotert del
FARGER = {"blå": (33, 150, 243), "grønn": (76, 175, 80)}
BG = (240, 240, 245)
FART_FANGER = 9
FART_FALL = 3
SPAWN_MS = 1300
FPS = 60


class Stolpedel:
    def __init__(self, x, bredde, fargenavn):
        self.rect = pygame.Rect(x, -DEL_H, bredde, DEL_H)
        self.fargenavn = fargenavn

    def fall(self):
        self.rect.y += FART_FALL

    def roter(self):
        # Kvart rotasjon (90°): bredde og høyde bytter plass
        self.rect.width, self.rect.height = self.rect.height, self.rect.width

    def tegn(self, skjerm):
        pygame.draw.rect(skjerm, FARGER[self.fargenavn], self.rect, border_radius=4)
        pygame.draw.rect(skjerm, (30, 30, 30), self.rect, 2, border_radius=4)


class Stolpe:
    """En sidestolpe som bygges nedenfra og opp med vekslende farger."""
    def __init__(self, x_venstre):
        self.x = x_venstre
        self.deler = []

    def hoyde(self):
        return sum(d.rect.height for d in self.deler)

    def neste_farge(self):
        if not self.deler:
            return "blå"                # første del kan være hvilken som helst; vi krever blå
        return "grønn" if self.deler[-1].fargenavn == "blå" else "blå"

    def ferdig(self):
        return self.hoyde() >= HOYDE

    def legg_til(self, del_):
        del_.roter()                     # blir STOLPE_B bred, gammel bredde blir høyde
        del_.rect.width = STOLPE_B
        del_.rect.x = self.x
        del_.rect.y = HOYDE - self.hoyde() - del_.rect.height
        self.deler.append(del_)

    def tegn(self, skjerm):
        for d in self.deler:
            d.tegn(skjerm)


class Stolpebygger:
    def __init__(self):
        self.rect = pygame.Rect((BREDDE - FANGER_B) // 2, HOYDE - FANGER_H, FANGER_B, FANGER_H)
        self.liv = 3

    def flytt(self, dx):
        self.rect.x = max(0, min(BREDDE - FANGER_B, self.rect.x + dx))

    def tegn(self, skjerm):
        pygame.draw.rect(skjerm, (90, 90, 90), self.rect, border_radius=6)
        pygame.draw.rect(skjerm, (20, 20, 20), self.rect, 3, border_radius=6)


class Spill:
    def __init__(self):
        pygame.init()
        self.skjerm = pygame.display.set_mode((BREDDE, HOYDE))
        pygame.display.set_caption("Stolpebyggeren")
        self.klokke = pygame.time.Clock()
        self.font = pygame.font.SysFont("consolas", 22)
        self.bygger = Stolpebygger()
        self.fallende = []
        self.hoyre = Stolpe(BREDDE - STOLPE_B)   # bygges først, helt til høyre
        self.venstre = Stolpe(0)               # bygges sist, helt til venstre
        self.sist_spawn = 0
        self.slutt = False

    def aktiv_stolpe(self):
        return self.hoyre if not self.hoyre.ferdig() else self.venstre

    def spawn_del(self):
        for _ in range(20):                  # prøv å finne ledig posisjon uten overlapp
            bredde = random.choice(DEL_BREDDER)
            x = random.randint(KANT, BREDDE - KANT - bredde)
            ny = pygame.Rect(x, -DEL_H, bredde, DEL_H)
            if not any(ny.colliderect(d.rect) for d in self.fallende):
                farge = random.choice(list(FARGER))
                self.fallende.append(Stolpedel(x, bredde, farge))
                return

    def oppdater(self, dt):
        self.sist_spawn += dt
        if self.sist_spawn >= SPAWN_MS:
            self.spawn_del()
            self.sist_spawn = 0

        for del_ in self.fallende[:]:
            del_.fall()
            if del_.rect.colliderect(self.bygger.rect):
                self._fang(del_)
                self.fallende.remove(del_)
            elif del_.rect.top > HOYDE:
                self.fallende.remove(del_)          # bommet — ingen straff

        if (self.hoyre.ferdig() and self.venstre.ferdig()) or self.bygger.liv <= 0:
            self.slutt = True

    def _fang(self, del_):
        stolpe = self.aktiv_stolpe()
        if del_.fargenavn == stolpe.neste_farge():
            stolpe.legg_til(del_)                   # riktig farge
        else:
            self.bygger.liv -= 1                      # feil farge koster et liv

    def tegn(self):
        self.skjerm.fill(BG)
        self.hoyre.tegn(self.skjerm)
        self.venstre.tegn(self.skjerm)
        for d in self.fallende:
            d.tegn(self.skjerm)
        self.bygger.tegn(self.skjerm)
        info = self.font.render(
            f"Liv: {self.bygger.liv}   Neste farge: {self.aktiv_stolpe().neste_farge()}",
            True, (0, 0, 0),
        )
        self.skjerm.blit(info, (10, 10))
        pygame.display.flip()

    def vis_resultat(self):
        self.skjerm.fill(BG)
        tittel = ("Gratulerer! Begge stolpene er ferdig bygd."
                  if self.bygger.liv > 0
                  else "Game over – du mistet alle livene.")
        linjer = [tittel,
                  f"Deler i høyre stolpe:  {len(self.hoyre.deler)}",
                  f"Deler i venstre stolpe: {len(self.venstre.deler)}",
                  "Trykk en tast for å avslutte."]
        for i, tekst in enumerate(linjer):
            flate = self.font.render(tekst, True, (0, 0, 0))
            self.skjerm.blit(flate, (BREDDE // 2 - flate.get_width() // 2, 130 + i * 34))
        pygame.display.flip()
        self._vent_pa_tast()

    def _vent_pa_tast(self):
        while True:
            for e in pygame.event.get():
                if e.type in (pygame.QUIT, pygame.KEYDOWN):
                    return

    def kjor(self):
        while not self.slutt:
            dt = self.klokke.tick(FPS)
            for e in pygame.event.get():
                if e.type == pygame.QUIT:
                    self.slutt = True
            taster = pygame.key.get_pressed()
            if taster[pygame.K_LEFT]:
                self.bygger.flytt(-FART_FANGER)
            if taster[pygame.K_RIGHT]:
                self.bygger.flytt(FART_FANGER)
            self.oppdater(dt)
            self.tegn()
        self.vis_resultat()
        pygame.quit()
        sys.exit()


if __name__ == "__main__":
    Spill().kjor()

Oppgave 9 – Innlevering

Foreslått mappestruktur (f.eks. 123456.zip):

123456/
├── oppgave4b/
│   └── forklaring_algoritme.txt      (tekstsvaret ditt til 4b)
├── oppgave5/
│   └── togsett.py
├── oppgave7/
│   ├── kjoretoy.py
│   └── kjoretoy_2008_2024.csv        (datasettet)
├── oppgave8/
│   └── stolpebyggeren.py
└── README.txt   (hvordan hver fil kjøres, og hvilke pakker som trengs)