Lær å beskrive algoritmer ved hjelp av pseudokode og flytdiagrammer.
Pseudokode og flytdiagrammer
Før du setter deg ned og skriver kode, er det lurt å planlegge løsningen din. Akkurat som en arkitekt tegner plantegninger før byggearbeiderne begynner, bør en programmerer beskrive algoritmen sin før hen begynner å kode. To av de viktigste verktøyene for dette er pseudokode og flytdiagrammer.
Pseudokode lar deg beskrive algoritmen i en blanding av naturlig språk og programmering, uten å bekymre deg for syntaksregler og semikolon. Flytdiagrammer gir deg et visuelt bilde av hvordan algoritmen flyter, noe som er spesielt nyttig for å forstå forgreninger og løkker.
I dette kapittelet skal du lære å skrive klar og strukturert pseudokode, tegne flytdiagrammer med standardiserte symboler, og oversette mellom pseudokode, flytdiagrammer og Python-kode. Disse ferdighetene er verdifulle både på eksamen og i profesjonell programvareutvikling.
Hvordan skrive god pseudokode
Selv om det ikke finnes én offisiell standard for pseudokode, er det noen konvensjoner som gjør pseudokoden lettere å lese og oversette til kode:
Nøkkelord for kontrollstrukturer:
- LES eller INNDATA – les inn data fra brukeren
- SKRIV eller VIS – skriv ut data til skjermen
- SETT – tilordne en verdi til en variabel
- HVIS ... SÅ ... ELLERS – betingelse
- GJENTA SÅ LENGE – while-løkke
- FOR HVER ... I ... – for-løkke
- FUNKSJON – definere en funksjon
- RETURNER – returnere en verdi fra en funksjon
Regler for god pseudokode:
1. Bruk innrykk for å vise hvilke linjer som hører sammen (som i Python)
2. Skriv nøkkelord med store bokstaver for å skille dem fra vanlig tekst
3. Bruk beskrivende variabelnavn som gjør det klart hva variabelen inneholder
4. Hold hvert steg på én linje der det er mulig
5. Nummerer linjene hvis det gjør det lettere å referere til dem
6. Vær presis – unngå tvetydige formuleringer
Pseudokode er ikke ment å kjøres av en datamaskin. Den er et kommunikasjonsverktøy mellom mennesker, og dens viktigste egenskap er klarhet.
Skriv pseudokode for et program som leser inn karakterer til brukeren skriver -1, og deretter beregner og viser gjennomsnittet.
SETT sum = 0
SETT antall = 0
LES karakter
GJENTA SÅ LENGE karakter != -1:
SETT sum = sum + karakter
SETT antall = antall + 1
LES karakter
HVIS antall > 0:
SETT gjennomsnitt = sum / antall
VIS "Gjennomsnittet er " + gjennomsnitt
ELLERS:
VIS "Ingen karakterer ble skrevet inn"Tilsvarende Python-kode:
summen = 0
antall = 0
karakter = int(input("Skriv inn karakter (-1 for å avslutte): "))
while karakter != -1:
summen += karakter
antall += 1
karakter = int(input("Skriv inn karakter (-1 for å avslutte): "))
if antall > 0:
gjennomsnitt = summen / antall
print(f"Gjennomsnittet er {gjennomsnitt:.2f}")
else:
print("Ingen karakterer ble skrevet inn")Legg merke til hvor direkte oversettelsen er fra pseudokode til Python. GJENTA SÅ LENGE blir while, HVIS/ELLERS blir if/else, LES blir input(), og VIS blir print().
Flytdiagrammer
Et flytdiagram er en visuell representasjon av en algoritme. Det bruker standardiserte symboler koblet sammen med piler for å vise hvordan data og kontroll flyter gjennom programmet. Flytdiagrammer er spesielt nyttige for å visualisere betingelser og løkker.
Standardsymboler i flytdiagrammer:
| Symbol | Form | Betydning |
|---|---|---|
| Start/Stopp | Avrundet rektangel (oval) | Markerer starten og slutten av algoritmen |
| Prosess | Rektangel | En handling eller beregning (f.eks. «sum = a + b») |
| Beslutning | Rombe (diamant) | Et valg basert på en betingelse (Ja/Nei) |
| Inn/Ut | Parallellogram | Innlesing eller utskrift av data |
| Pil | Pil (→) | Viser retningen flyten følger |
Regler for gode flytdiagrammer:
1. Hvert flytdiagram har nøyaktig én Start og minst én Stopp
2. Alle symboler skal ha piler som viser flyten
3. Beslutningssymboler har alltid to utganger: Ja og Nei
4. Pilene skal aldri krysse hverandre der det kan unngås
5. Flyten skal gå ovenfra og ned som hovedretning
6. Bruk konsekvent stil og størrelse på symbolene
Beskriv flytdiagrammet for en algoritme som sjekker om et tall er partall eller oddetall.
[Start]
↓
[Les inn tall]
↓
<Er tall % 2 == 0?>
/ \
Ja Nei
↓ ↓
[Vis [Vis
"Partall"] "Oddetall"]
↓ ↓
\ /
↓
[Stopp]Forklaring:
1. Start-symbolet markerer begynnelsen
2. Et parallellogram (Inn/Ut) leser inn tallet
3. En rombe (Beslutning) sjekker om tallet er delelig med 2
4. Basert på svaret skrives enten «Partall» eller «Oddetall» ut
5. Begge grenene fører til Stopp-symbolet
Tilsvarende Python-kode:
tall = int(input("Skriv inn et tall: "))
if tall % 2 == 0:
print("Partall")
else:
print("Oddetall")Flytdiagrammet gjør det visuelt tydelig at det er to mulige veier gjennom programmet, avhengig av betingelsen.
Flytdiagrammer med løkker
Løkker i flytdiagrammer vises ved at en pil går tilbake til et tidligere punkt i diagrammet, slik at en gruppe symboler gjentas. Her er et eksempel på en while-løkke som teller ned fra 5 til 1:
[Start]
↓
[Sett teller = 5]
↓
<Er teller > 0?>──Nei──→[Vis "Ferdig!"]──→[Stopp]
|
Ja
↓
[Vis teller]
↓
[Sett teller = teller - 1]
|
└────────→ (tilbake til beslutningen)Tilsvarende Python-kode:
teller = 5
while teller > 0:
print(teller)
teller -= 1
print("Ferdig!")Pilen som går tilbake oppover er det som skaper løkken. Uten denne pilen ville koden bare kjørt én gang. Det er viktig at noe inne i løkken endrer betingelsen (her: teller reduseres), slik at løkken til slutt stopper.
For-løkker kan også vises i flytdiagrammer. De har en teller som økes automatisk i hvert gjennomløp:
[Start]
↓
[Sett i = 1]
↓
<Er i <= 10?>──Nei──→[Stopp]
|
Ja
↓
[Vis i * i]
↓
[Sett i = i + 1]
|
└────────→ (tilbake til beslutningen)Dette tilsvarer:
for i in range(1, 11):
print(i * i)Lag pseudokode, beskriv flytdiagrammet, og skriv Python-kode for en algoritme som finner summen av alle partall fra 1 til n.
LES n
SETT sum = 0
FOR HVER i FRA 1 TIL n:
HVIS i % 2 == 0:
SETT sum = sum + i
VIS "Summen av partall fra 1 til " + n + " er " + sumFlytdiagram (beskrivelse):
[Start]
↓
[Les inn n]
↓
[Sett sum = 0, i = 1]
↓
<Er i <= n?>──Nei──→[Vis sum]──→[Stopp]
|
Ja
↓
<Er i % 2 == 0?>
/ \
Ja Nei
↓ |
[sum = sum + i] |
↓ |
\ /
↓
[i = i + 1]
|
└────────→ (tilbake til "Er i <= n?")Python-kode:
n = int(input("Skriv inn n: "))
summen = 0
for i in range(1, n + 1):
if i % 2 == 0:
summen += i
print(f"Summen av partall fra 1 til {n} er {summen}")Kjøring med n = 10:
Skriv inn n: 10
Summen av partall fra 1 til 10 er 30Partallene fra 1 til 10 er 2, 4, 6, 8, 10, og summen er 2+4+6+8+10 = 30.
Når bør du bruke hva?
Både pseudokode og flytdiagrammer er nyttige verktøy, men de har ulike styrker:
| Egenskap | Pseudokode | Flytdiagram |
|---|---|---|
| Representasjon | Tekstlig | Visuell |
| Best for | Detaljerte algoritmer | Overordnet logikkflyt |
| Betingelser | Tydelig med HVIS/ELLERS | Svært visuelt med rombe |
| Løkker | Kompakt skrivemåte | Piler som går tilbake |
| Komplekse algoritmer | Skalerer godt | Kan bli uoversiktlig |
| Oversettelse til kode | Svært direkte | Krever mer tolkning |
| Kommunikasjon | Teknisk publikum | Bredere publikum |
Anbefaling: Bruk flytdiagrammer for å visualisere den overordnede logikken, spesielt for betingelser og løkker. Bruk pseudokode for å beskrive detaljene i algoritmen. I praksis bruker mange programmerere begge deler: først et flytdiagram for å forstå den store strukturen, deretter pseudokode for å beskrive hvert steg i detalj.
Uansett hvilket verktøy du bruker, er det viktigste at du planlegger før du koder. Erfarne programmerere bruker ofte mer tid på planlegging og design enn på selve kodingen.
Du kan tegne flytdiagrammer for hånd på papir, men det finnes også gode digitale verktøy. draw.io (diagrams.net) er gratis og nettbasert, og har ferdige maler for flytdiagrammer. Lucidchart har en gratis versjon for studenter. I VS Code finnes utvidelsen Draw.io Integration som lar deg tegne diagrammer direkte i editoren. Å bruke digitale verktøy gjør det enkelt å redigere og dele diagrammene dine.
Skriv pseudokode for et program som validerer et passord. Passordet må ha minst 8 tegn, inneholde minst én stor bokstav, minst én liten bokstav, og minst ett siffer.
FUNKSJON valider_passord(passord):
HVIS lengden av passord < 8:
RETURNER "For kort – minst 8 tegn kreves"
SETT har_stor = USANN
SETT har_liten = USANN
SETT har_siffer = USANN
FOR HVERT tegn I passord:
HVIS tegn er stor bokstav:
SETT har_stor = SANN
HVIS tegn er liten bokstav:
SETT har_liten = SANN
HVIS tegn er siffer:
SETT har_siffer = SANN
HVIS IKKE har_stor:
RETURNER "Mangler stor bokstav"
HVIS IKKE har_liten:
RETURNER "Mangler liten bokstav"
HVIS IKKE har_siffer:
RETURNER "Mangler siffer"
RETURNER "Passordet er gyldig!"
LES passord
VIS valider_passord(passord)Python-kode:
def valider_passord(passord):
if len(passord) < 8:
return "For kort – minst 8 tegn kreves"
har_stor = False
har_liten = False
har_siffer = False
for tegn in passord:
if tegn.isupper():
har_stor = True
if tegn.islower():
har_liten = True
if tegn.isdigit():
har_siffer = True
if not har_stor:
return "Mangler stor bokstav"
if not har_liten:
return "Mangler liten bokstav"
if not har_siffer:
return "Mangler siffer"
return "Passordet er gyldig!"
passord = input("Skriv inn passord: ")
print(valider_passord(passord))Kjøring:
Skriv inn passord: Hemmelig123
Passordet er gyldig!
Skriv inn passord: kort
For kort – minst 8 tegn krevesHvilken form brukes for å representere en beslutning (betingelse) i et flytdiagram?
Hva er hovedfordelen med pseudokode sammenlignet med å skrive kode direkte?
Hva tilsvarer denne pseudokoden i Python?
SETT total = 0
FOR HVER tall I [3, 7, 2, 9]:
HVIS tall > 5:
SETT total = total + tall
VIS totalSkriv pseudokode for en algoritme som sjekker om et ord er et palindrom (leses likt fra begge retninger, som «anna» eller «regninger»). Oversett deretter pseudokoden til Python.
Beskriv et flytdiagram (med tekst, som i eksemplene) for en algoritme som leser inn tall fra brukeren helt til brukeren skriver 0, og deretter viser det største tallet som ble skrevet inn.
Skriv pseudokode og Python-kode for et program som gjetter et tilfeldig tall mellom 1 og 100. Programmet skal gi tilbakemelding om gjettet er for høyt, for lavt eller riktig, og telle antall forsøk.
Gitt følgende flytdiagram-beskrivelse:
1. Start
2. Sett n = 1
3. Er n > 5? Ja: gå til 7. Nei: gå til 4.
4. Vis n * n
5. Sett n = n + 1
6. Gå til 3.
7. Stopp.
Hva er den fullstendige utskriften fra dette flytdiagrammet?
Oppsummering
I dette kapittelet har du lært:
- Pseudokode: uformell, strukturert beskrivelse av en algoritme.
- Flytdiagram: grafisk fremstilling av en algoritme.
- Symboler: start/stopp, prosess, beslutning og inn/ut-data.
- Oversetting: mellom pseudokode, flytdiagram og Python.
- Når bruke hva: planlegging før koding.
Noekkelbegreper
| Begrep | Forklaring |
|---|---|
| Pseudokode | Uformell tekstlig beskrivelse av en algoritme |
| Flytdiagram | Grafisk fremstilling av en algoritme |
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.