9.2 Løkker og variabler | Matematikk 8. klasse

Bruke løkker og variabler i programmering for å løse matematiske problemer.

50 min

12 oppgaver

LøkkerVariablerGjentakelseBetingelser

Du leser den tradisjonelle versjonen

Din fremgang i kapitlet

0 / 12 oppgaver

Kapitlets plass i kurset

Bygger på

9.1Introduksjon til programmering med Python

Brukes videre i

9.3Algoritmer i matematikk

Løkker og variabler

I forrige kapittel lærte du å skrive enkle programmer som utfører instruksjoner linje for linje. Men hva om du vil gjøre det samme mange ganger? For eksempel: hva om du vil skrive ut gangetabellen for $7$ ? Du kunne skrive ti print()-kommandoer, men det finnes en mye bedre måte: løkker.

En løkke er en instruksjon som gjentar en kodeblokk mange ganger. Tenk deg en karrusell som går rundt og rundt – koden i løkken kjøres om igjen og om igjen.

I dette kapittelet skal du lære:
- Hvordan variabler kan oppdateres
- For-løkker for å gjenta kode et bestemt antall ganger
- While-løkker for å gjenta kode så lenge en betingelse er sann
- Å bruke løkker til å utforske tallmønstre og matematikk

Oppdatere variabler

En variabel kan endres underveis i programmet. Vi kan oppdatere verdien ved å bruke variabelens gamle verdi: teller = 0 teller = teller + 1 # teller er nå 1 teller = teller + 1 # teller er nå 2 teller = teller + 1 # teller er nå 3 print(teller) # Skriver ut 3 Forkortelser for vanlige oppdateringer: Vanlig skriving Forkorting x = x + 3 x += 3 x = x - 1 x -= 1 x = x * 2 x *= 2 x = x / 5 x /= 5 Disse forkortingene gjør akkurat det samme, men er raskere å skrive.

Vanlig skriving	Forkorting
`x = x + 3`	`x += 3`
`x = x - 1`	`x -= 1`
`x = x * 2`	`x *= 2`
`x = x / 5`	`x /= 5`

For-løkke

0, 1, 2, 3, 4

✏️Eksempel 1: Gangetabellen

Skriv et program som skriver ut gangetabellen for $7$ , fra $7 \cdot 1$ til $7 \cdot 10$ .

for i in range(1, 11):
    print(7, "*", i, "=", 7 * i)

Utskrift:

7 * 1 = 7
7 * 2 = 14
7 * 3 = 21
7 * 4 = 28
7 * 5 = 35
7 * 6 = 42
7 * 7 = 49
7 * 8 = 56
7 * 9 = 63
7 * 10 = 70

Forklaring:
- range(1, 11) gir tallene $1, 2, 3, \ldots, 10$
- For hvert tall i skrives det ut en linje med $7 \cdot i$
- Løkken kjører 10 ganger – mye enklere enn å skrive 10 separate print()-linjer!

📝Oppgave F1

Finn feilen! Amina vil skrive ut tallene

1, 2, 3, 4, 5

med en for-løkke. Hun skriver:

for i in range(5):
    print(i)

Hun forventer å se:

Men det hun faktisk ser, er noe annet. Hva skrives ut, og hva må hun endre for å få riktig resultat?

✏️Eksempel 2: Summere tall med løkke

Skriv et program som beregner summen $1 + 2 + 3 + \ldots + 100$ .

total = 0
for i in range(1, 101):
    total += i

print("Summen fra 1 til 100 er:", total)

Utskrift:

Summen fra 1 til 100 er: 5050

Forklaring:
- Vi starter med total = 0
- For hvert tall i fra $1$ til $100$ legger vi det til total
- Etter løkken inneholder total summen av alle tallene

Sjekk: Summen $1 + 2 + 3 + \ldots + n$ kan beregnes med formelen $\displaystyle \frac{n(n+1)}{2}$ :

$\frac{100 \cdot 101}{2} = 5050 \checkmark$

Denne historien er kjent: den unge Carl Friedrich Gauss fant denne formelen allerede som 10-åring!

While-løkke

En while-løkke gjentar en kodeblokk så lenge en betingelse er sann : tall = 1 while tall <= 5: print(tall) tall += 1 Utskrift: 1 2 3 4 5 Hvordan det fungerer: 1. Python sjekker betingelsen tall <= 5 2. Hvis den er sann (True), kjøres koden inni løkken 3. Deretter går Python tilbake til steg 1 og sjekker igjen 4. Når betingelsen blir usann (False), hopper Python ut av løkken Sammenligningsoperatorer: Operator Betydning == Er lik!= Er ulik < Mindre enn > Større enn <= Mindre enn eller lik >= Større enn eller lik

Operator	Betydning
`==`	Er lik
`!=`	Er ulik
`<`	Mindre enn
`>`	Større enn
`<=`	Mindre enn eller lik
`>=`	Større enn eller lik

Uendelig løkke

Hvis betingelsen i en while-løkke aldri blir usann, vil løkken kjøre for alltid! Dette kalles en uendelig løkke.

# IKKE kjør dette - det stopper aldri!
tall = 1
while tall > 0:
    print(tall)
    tall += 1

Her vokser tall hele tiden, og betingelsen tall > 0 er alltid sann.

Tips: Sørg alltid for at noe inni while-løkken bringer deg nærmere slutten. Hvis programmet «henger», trykk Ctrl+C for å stoppe det.

✏️Eksempel 3: Dobling med while-løkke

Vi starter med $1$ kr og dobler beløpet hver dag. Hvor mange dager tar det før vi har mer enn $1000$ kr?

belop = 1
dager = 0

while belop <= 1000:
    belop = belop * 2
    dager = dager + 1

print("Etter", dager, "dager har du", belop, "kr")

Utskrift:

Etter 10 dager har du 1024 kr

Steg for steg:

Dag	Beløp
$0$	$1$ kr
$1$	$2$ kr
$2$	$4$ kr
$3$	$8$ kr
$4$	$16$ kr
$5$	$32$ kr
$6$	$64$ kr
$7$	$128$ kr
$8$	$256$ kr
$9$	$512$ kr
$10$	$1024$ kr

Etter

10

dager har vi

2^{10} = 1024

kr, som er mer enn

1000

kr. Eksponentiell vekst er kraftig!

✏️Eksempel 4: Utforske tallmønstre med løkke

Bruk en løkke til å skrive ut de 10 første trekanttallene. Trekanttall nummer $n$ er $\displaystyle T_n = \frac{n(n+1)}{2}$ .

for n in range(1, 11):
    trekanttall = n * (n + 1) // 2
    print("T" + str(n) + " =", trekanttall)

Utskrift:

T1 = 1
T2 = 3
T3 = 6
T4 = 10
T5 = 15
T6 = 21
T7 = 28
T8 = 36
T9 = 45
T10 = 55

Mønsteret: $1, 3, 6, 10, 15, 21, 28, 36, 45, 55, \ldots$

Legg merke til at differansene mellom trekanttallene er $2, 3, 4, 5, 6, \ldots$ – altså de naturlige tallene! Det gir mening fordi $T_n - T_{n-1} = n$ .

✏️Eksempel 5: Partall og oddetall med range()

Skriv to programmer: ett som skriver ut alle partall fra $2$ til $20$ , og ett som skriver ut alle oddetall fra $1$ til $19$ .

Partall:

for i in range(2, 21, 2):
    print(i, end=" ")

Utskrift: 2 4 6 8 10 12 14 16 18 20

Oddetall:

for i in range(1, 20, 2):
    print(i, end=" ")

Utskrift: 1 3 5 7 9 11 13 15 17 19

Forklaring:
- range(2, 21, 2) starter på $2$ , øker med $2$ for hvert steg, og stopper før $21$
- range(1, 20, 2) starter på $1$ , øker med $2$ for hvert steg, og stopper før $20$
- end=" " gjør at print() setter mellomrom etter hver verdi i stedet for linjeskift

Nestet løkke

En nestet løkke er en løkke inne i en annen løkke. For hver gjennomkjøring av den ytre løkken, kjører den indre løkken alle sine gjennomkjøringer.

for rad in range(1, 4):
    for kolonne in range(1, 4):
        print(rad, "*", kolonne, "=", rad * kolonne)
    print()  # Tom linje mellom radene

Utskrift:

Forklaring: Den ytre løkken (rad) går fra $1$ til $3$ . For hver verdi av rad kjører den indre løkken (kolonne) fra $1$ til $3$ . Totalt blir det $3 \times 3 = 9$ utskrifter.

📝Oppgave 1

Hva skriver dette programmet ut?

for i in range(4):
    print(i)

for i in range(1, 6):
    print(i * 2)

for i in range(3, 0, -1):
    print(i)
print("Start!")

Løs oppgaven Tren

📝Oppgave 2

Skriv et program som skriver ut gangetabellen for $9$ (fra $9 \cdot 1$ til $9 \cdot 10$ ) ved å bruke en for-løkke.

📝Oppgave 3

Skriv et program som beregner summen $1 + 2 + 3 + \ldots + 50$ ved å bruke en for-løkke.

📝Oppgave 4

Hva skriver dette programmet ut?

x = 1
for i in range(5):
    x = x * 2
print(x)

total = 0
for i in range(1, 6):
    total += i * i
print(total)

Løs oppgaven Tren

📝Oppgave 5

Skriv et program som bruker en for-løkke til å beregne $n!$ (n-fakultet) for $n = 7$ . Husk at $n! = 1 \cdot 2 \cdot 3 \cdot \ldots \cdot n$ .

📝Oppgave 6

Skriv et program som bruker en while-løkke til å finne det minste tallet $n$ slik at $2^n > 1\,000\,000$ .

📝Oppgave 7

Skriv et program som skriver ut alle kvadrattall fra $1$ til $200$ . Bruk en while-løkke.

📝Oppgave 8

Skriv et program som bruker en for-løkke til å skrive ut de 15 første leddene i Fibonacci-følgen: $1, 1, 2, 3, 5, 8, 13, \ldots$

📝Oppgave 9

Skriv et program som bruker nestede løkker til å skrive ut den lille gangetabellen ( $1 \times 1$ til $10 \times 10$ ).

📝Oppgave 10

Bruk en løkke til å utforske følgende påstand: «Summen av de $n$ første oddetallene er alltid et kvadrattall.» Skriv et program som beregner summen for $n = 1, 2, 3, \ldots, 10$ og viser at det stemmer.

📝Oppgave D1

Drøftingsoppgave: Summen

1 + 2 + 3 + \ldots + n

kan beregnes med formelen

\displaystyle \frac{n(n+1)}{2}

eller med en for-løkke. Diskuter: Når er det best å bruke formelen, og når er det best å bruke en løkke? Kan du tenke deg en sum der det ikke finnes en enkel formel, slik at en løkke er det eneste alternativet?

Oppsummering

Oppdatere variabler

- x = x + 3 (eller kortformen x += 3) oppdaterer verdien av

x

- Vanlig å bruke en «teller» eller «akkumulator» som oppdateres i løkken

For-løkke

- for i in range(n): gjentar koden

n

ganger, med

i = 0, 1, 2, \ldots, n-1

- range(start, slutt) – fra start til (men ikke med) slutt
- range(start, slutt, steg) – med et bestemt steg mellom verdiene
- Koden inni løkken må ha innrykk

While-løkke

- while betingelse: gjentar koden så lenge betingelsen er sann
- Pass på at betingelsen til slutt blir usann, ellers får du en uendelig løkke
- Nyttig når du ikke vet på forhånd hvor mange ganger koden skal kjøres

Nestede løkker

- En løkke inne i en annen løkke
- Brukes f.eks. til å lage tabeller (rader og kolonner)

Matematisk utforskning

- Løkker er perfekte for å utforske tallmønstre (trekanttall, Fibonacci, osv.)
- Vi kan bruke programmering til å bekrefte eller oppdage matematiske sammenhenger

Repetisjonsoppgaver

Din fremgang

0deloppgaver0 / 6 oppgaver

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.