3.2 Problemløsningsstrategier

Problemløsningsstrategier

Den største utfordringen i programmering er ikke å lære syntaksen til et programmeringsspråk. Det vanskeligste er å finne ut hvordan du skal løse et problem. Mange nybegynnere blir lammet når de møter en oppgave som er litt mer kompleks enn det de har sett før. De stirrer på en tom editor og vet ikke hvor de skal begynne.

Heldigvis finnes det velprøvde strategier for problemløsning som du kan lære og øve på. I dette kapittelet skal vi se på fire nøkkelstrategier som utgjør kjernen i det som kalles algoritmisk tenkning (eller «computational thinking» på engelsk): dekomponering, mønstergjenkjenning, abstraksjon og algoritmedesign. Disse strategiene brukes ikke bare i programmering, men i alle fagfelt der du trenger å løse problemer systematisk.

Du vil lære å bryte ned store problemer i små biter, gjenkjenne mønstre som lar deg gjenbruke løsninger, fokusere på det som er viktig og ignorere det som er uvesentlig, og til slutt designe steg-for-steg-løsninger som kan oversettes direkte til kode.

Dekomponering

Dekomponering er kanskje den viktigste problemløsningsstrategien. Ideen er enkel: et stort, uoverkommelig problem blir lett å håndtere når du bryter det ned i mindre deler.

Tenk deg at du skal lage et program som er en enkel quiz. Det høres kanskje overveldende ut i starten, men bryter du det ned, ser du at det består av flere små, håndterbare oppgaver:

1. Definere spørsmål og svar
2. Vise ett spørsmål til brukeren
3. Lese inn brukerens svar
4. Sjekke om svaret er riktig
5. Telle poeng
6. Vise resultatet til slutt

Hvert av disse stegene er langt enklere å løse alene enn hele quizen under ett. Og når du har løst hvert delsteg, kan du sette dem sammen til et komplett program.

Fremgangsmåte for dekomponering:
1. Les oppgaven nøye og identifiser hva som er input og hva som er ønsket output
2. List opp alle deloppgavene som må utføres
3. Ordne deloppgavene i riktig rekkefølge
4. Løs hver deloppgave separat
5. Sett delløsningene sammen og test helheten

Mønstergjenkjenning

Når du har brutt ned et problem, vil du ofte oppdage at flere av delene ligner på hverandre. I quizeksempelet over gjentok vi nesten identisk kode for hvert spørsmål: vis spørsmålet, les svaret, sjekk om det er riktig, oppdater poengsummen. Dette er et mønster!

Når du gjenkjenner et mønster, kan du:
- Bruke en løkke for å gjenta den samme koden med forskjellige data
- Lage en funksjon som utfører det gjentakende arbeidet
- Bruke datastrukturer (som lister) for å organisere data som hører sammen

Mønstergjenkjenning handler også om å koble nye problemer til problemer du har løst før. Har du løst et problem med å finne det største tallet i en liste? Samme mønster kan brukes til å finne det dyreste produktet i en nettbutikk, den varmeste dagen i en temperaturlogg, eller den beste karakteren i et datasett.

La oss forbedre 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!")

Nå kan vi enkelt legge til flere spørsmål bare ved å utvide listen, uten å skrive mer kode. Mønsteret er identifisert og gjenbrukt.

Abstraksjon i praksis

Abstraksjon handler om å tenke på hva som skal gjøres, ikke hvordan det gjøres. I programmering bruker vi funksjoner for å oppnå abstraksjon. La oss se på quizprogrammet igjen, nå med funksjoner:

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))

Nå er hovedprogrammet bare fire linjer. All kompleksitet er gjemt inne i funksjonene. Hver funksjon har et tydelig navn som forklarer hva den gjør, og du kan lese hovedprogrammet nesten som vanlig norsk: «Kjør quizen. Vis resultatet.»

Top-down-design og trinnvis forfining

Top-down-design er en strategi der du starter med den overordnede løsningen og gradvis bryter den ned i mer detaljerte deler. Det er som å tegne et kart der du først tegner landegrensene, deretter fylkene, byene, og til slutt gatene.

Eksempel: Bygge en karakterkalkulator

Steg 1: Overordnet plan

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

Steg 2: Forfin hvert 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ærmingen gjør det enkelt å utvikle selv komplekse programmer. Du fokuserer på én ting om gangen og bygger opp løsningen lag for lag.

Systematisk fremgangsmåte

Her er en steg-for-steg-fremgangsmåte du kan bruke for enhver programmeringsoppgave:

1. Forstå problemet
- Les oppgaven nøye, gjerne flere ganger
- Hva er input? Hva er ønsket output?
- Finnes det spesialtilfeller? Hva med ugyldige inndata?

2. Planlegg løsningen
- Bruk dekomponering: bryt ned i delproblemer
- Se etter mønstre: ligner dette på noe du har løst før?
- Skriv algoritmen i naturlig språk eller pseudokode

3. Implementer
- Skriv kode for én del om gangen
- Test hver del før du går videre
- Bruk beskrivende variabelnavn og kommentarer

4. Test
- Test med normale inndata
- Test med grensetilfeller (0, negative tall, tomme lister)
- Test med ugyldige inndata
- Sammenlign resultatet med forventet utdata

5. Forbedre
- Kan koden forenkles?
- Er det gjentakende kode som kan bli en funksjon?
- Er variabelnavnene beskrivende?
- Er koden godt kommentert?

Denne prosessen er iterativ. Du vil ofte gå tilbake til et tidligere steg når du oppdager noe nytt. Det er helt normalt og en del av prosessen.

Oppsummering

I dette kapittelet har du lært:

- Algoritmisk tenkning: formulere problemer så en datamaskin kan løse dem.
- Dekomponering: bryte et problem ned i mindre delproblemer.
- Moenstergjenkjenning: finne likheter og gjentakelser.
- Abstraksjon: trekke ut det vesentlige og skjule detaljer.
- Top-down-design: trinnvis forfining fra helhet til detalj.

Noekkelbegreper