3.2 Problemløsningsstrategier

Problemløysingsstrategiar

Den største utfordringa i programmering er ikkje å lære syntaksen til eit programmeringsspråk. Det vanskelegaste er å finne ut korleis du skal løyse eit problem. Mange nybyrjarar blir lamma når dei møter ei oppgåve som er litt meir kompleks enn det dei har sett før. Dei stirer på ein tom editor og veit ikkje kvar dei skal byrje.

Heldigvis finst det velprøvde strategiar for problemløysing som du kan lære og øve på. I dette kapittelet skal vi sjå på fire nøkkelstrategiar som utgjer kjernen i det som blir kalla algoritmisk tenking (eller «computational thinking» på engelsk): dekomponering, mønstergjenkjenning, abstraksjon og algoritmedesign. Desse strategiane blir ikkje berre brukte i programmering, men i alle fagfelt der du treng å løyse problem systematisk.

Du vil lære å bryte ned store problem i små bitar, kjenne att mønster som lèt deg gjenbruke løysingar, fokusere på det som er viktig og ignorere det som er uvesentleg, og til slutt designe steg-for-steg-løysingar som kan omsetjast direkte til kode.

Dekomponering

Dekomponering er kanskje den viktigaste problemløysingsstrategien. Ideen er enkel: eit stort, uoverkomeleg problem blir lett å handtere når du bryt det ned i mindre delar.

Tenk deg at du skal lage eit program som er ein enkel quiz. Det høyrest kanskje overveldande ut i starten, men bryt du det ned, ser du at det består av fleire små, handterbare oppgåver:

1. Definere spørsmål og svar
2. Vise eitt spørsmål til brukaren
3. Lese inn svaret til brukaren
4. Sjekke om svaret er rett
5. Telje poeng
6. Vise resultatet til slutt

Kvart av desse stega er langt enklare å løyse åleine enn heile quizen under eitt. Og når du har løyst kvart delsteg, kan du setje dei saman til eit komplett program.

Framgangsmåte for dekomponering:
1. Les oppgåva nøye og identifiser kva som er input og kva som er ønskt output
2. List opp alle deloppgåvene som må utførast
3. Ordne deloppgåvene i rett rekkjefølgje
4. Løys kvar deloppgåve separat
5. Set delløysingane saman og test heilskapen

Mønstergjenkjenning

Når du har brote ned eit problem, vil du ofte oppdage at fleire av delane liknar på kvarandre. I quizeksempelet over gjentok vi nesten identisk kode for kvart spørsmål: vis spørsmålet, les svaret, sjekk om det er rett, oppdater poengsummen. Dette er eit mønster!

Når du kjenner att eit mønster, kan du:
- Bruke ei løkke for å gjenta den same koden med forskjellige data
- Lage ein funksjon som utfører det gjentakande arbeidet
- Bruke datastrukturar (som lister) for å organisere data som høyrer saman

Mønstergjenkjenning handlar òg om å kople nye problem til problem du har løyst før. Har du løyst eit problem med å finne det største talet i ei liste? Same mønsteret kan brukast til å finne det dyraste produktet i ein nettbutikk, den varmaste dagen i ein temperaturlogg, eller den beste karakteren i eit datasett.

Lat oss forbetre quizprogrammet ved å bruke mønstergjenkjenning:

# Forbedret quiz med lister og løkke
sporsmaal = [
    ("Hva er hovedstaden i Norge? ", "oslo"),
    ("Hvilket år ble Norge selvstendig? ", "1905"),
    ("Hva heter Norges lengste elv? ", "glomma"),
]

poeng = 0

print("=== QUIZ ===\n")

for sporsmal, fasit in sporsmaal:
    svar = input(sporsmal).strip().lower()
    if svar == fasit:
        print("Riktig!\n")
        poeng += 1
    else:
        print(f"Feil! Riktig svar var {fasit}.\n")

print(f"Du fikk {poeng} av {len(sporsmaal)} riktig!")

No kan vi enkelt leggje til fleire spørsmål berre ved å utvide lista, utan å skrive meir kode. Mønsteret er identifisert og gjenbrukt.

Abstraksjon i praksis

Abstraksjon handlar om å tenkje på kva som skal gjerast, ikkje korleis det blir gjort. I programmering bruker vi funksjonar for å oppnå abstraksjon. Lat oss sjå på quizprogrammet igjen, no med funksjonar:

def still_sporsmal(sporsmal, fasit):
    """Stiller et spørsmål og returnerer True hvis svaret er riktig."""
    svar = input(sporsmal).strip().lower()
    if svar == fasit:
        print("Riktig!\n")
        return True
    else:
        print(f"Feil! Riktig svar var {fasit}.\n")
        return False

def kjor_quiz(sporsmaal):
    """Kjører en quiz med en liste av (spørsmål, svar)-tupler."""
    poeng = 0
    for sporsmal, fasit in sporsmaal:
        if still_sporsmal(sporsmal, fasit):
            poeng += 1
    return poeng

def vis_resultat(poeng, totalt):
    """Viser resultatet av quizen."""
    prosent = (poeng / totalt) * 100
    print(f"Du fikk {poeng} av {totalt} riktig ({prosent:.0f}%)")
    if prosent == 100:
        print("Fantastisk! Full score!")
    elif prosent >= 50:
        print("Bra jobbet!")
    else:
        print("Øv litt mer og prøv igjen!")

# Hovedprogram
sporsmaal = [
    ("Hva er hovedstaden i Norge? ", "oslo"),
    ("Hvilket år ble Norge selvstendig? ", "1905"),
    ("Hva heter Norges lengste elv? ", "glomma"),
]

print("=== QUIZ ===\n")
poeng = kjor_quiz(sporsmaal)
vis_resultat(poeng, len(sporsmaal))

No er hovudprogrammet berre fire linjer. All kompleksitet er gøymd inne i funksjonane. Kvar funksjon har eit tydeleg namn som forklarer kva han gjer, og du kan lese hovudprogrammet nesten som vanleg norsk: «Kjør quizen. Vis resultatet.»

Top-down-design og trinnvis forfining

Top-down-design er ein strategi der du startar med den overordna løysinga og gradvis bryt henne ned i meir detaljerte delar. Det er som å teikne eit kart der du først teiknar landegrensene, deretter fylka, byane, og til slutt gatene.

Eksempel: Bygge ein karakterkalkulator

Steg 1: Overordna plan

1. Les inn karakterer
2. Beregn gjennomsnitt
3. Vis resultater

Steg 2: Forfin kvart steg

1. Les inn karakterer
   1.1 Spør hvor mange fag
   1.2 For hvert fag: les inn fagnavn og karakter
   1.3 Lagre i en liste

2. Beregn gjennomsnitt
   2.1 Summer alle karakterer
   2.2 Del på antall fag

3. Vis resultater
   3.1 Vis alle fag med karakterer
   3.2 Vis gjennomsnittet
   3.3 Vis beste og svakeste fag

Steg 3: Implementer i Python

def les_karakterer():
    """Leser inn fag og karakterer fra brukeren."""
    antall = int(input("Hvor mange fag? "))
    fag_liste = []

    for i in range(antall):
        fag = input(f"Fagnavn {i + 1}: ")
        karakter = int(input(f"Karakter i {fag} (1-6): "))
        fag_liste.append((fag, karakter))

    return fag_liste

def beregn_gjennomsnitt(fag_liste):
    """Beregner gjennomsnittskarakteren."""
    total = sum(karakter for _, karakter in fag_liste)
    return total / len(fag_liste)

def vis_resultater(fag_liste, gjennomsnitt):
    """Viser alle karakterer og statistikk."""
    print("\n=== KARAKTEROVERSIKT ===")
    for fag, karakter in fag_liste:
        print(f"  {fag}: {karakter}")

    print(f"\nGjennomsnitt: {gjennomsnitt:.2f}")

    beste = max(fag_liste, key=lambda x: x[1])
    svakeste = min(fag_liste, key=lambda x: x[1])
    print(f"Beste fag: {beste[0]} ({beste[1]})")
    print(f"Svakeste fag: {svakeste[0]} ({svakeste[1]})")

# Hovedprogram
fag_liste = les_karakterer()
gjennomsnitt = beregn_gjennomsnitt(fag_liste)
vis_resultater(fag_liste, gjennomsnitt)

Denne tilnærminga gjer det enkelt å utvikle sjølv komplekse program. Du fokuserer på éi ting om gongen og byggjer opp løysinga lag for lag.

Systematisk framgangsmåte

Her er ein steg-for-steg-framgangsmåte du kan bruke for kvar einaste programmeringsoppgåve:

1. Forstå problemet
- Les oppgåva nøye, gjerne fleire gonger
- Kva er input? Kva er ønskt output?
- Finst det spesialtilfelle? Kva med ugyldige inndata?

2. Planlegg løysinga
- Bruk dekomponering: bryt ned i delproblem
- Sjå etter mønster: liknar dette på noko du har løyst før?
- Skriv algoritmen i naturleg språk eller pseudokode

3. Implementer
- Skriv kode for éin del om gongen
- Test kvar del før du går vidare
- Bruk beskrivande variabelnamn og kommentarar

4. Test
- Test med normale inndata
- Test med grensetilfelle (0, negative tal, tomme lister)
- Test med ugyldige inndata
- Samanlikn resultatet med forventa utdata

5. Forbetre
- Kan koden forenklast?
- Er det gjentakande kode som kan bli ein funksjon?
- Er variabelnamna beskrivande?
- Er koden godt kommentert?

Denne prosessen er iterativ. Du vil ofte gå tilbake til eit tidlegare steg når du oppdagar noko nytt. Det er heilt normalt og ein del av prosessen.

Oppsummering

I dette kapittelet har du lært:

- Algoritmisk tenking: formulere problem så ein datamaskin kan løyse dei.
- Dekomponering: bryte eit problem ned i mindre delproblem.
- Mønstergjenkjenning: finne likskapar og gjentakingar.
- Abstraksjon: trekkje ut det vesentlege og skjule detaljar.
- Top-down-design: trinnvis forfining frå heilskap til detalj.

Nøkkelbegrep