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 variablar

I førre kapittel lærte du å skrive enkle program som utfører instruksjonar linje for linje. Men kva om du vil gjere det same mange gonger? Til dømes: kva om du vil skrive ut gongetabellen for $7$ ? Du kunne skrive ti print()-kommandoar, men det finst ein mykje betre måte: løkker.

Ei løkke er ein instruksjon som gjentek ein kodeblokk mange gonger. Tenk deg ein karusell som går rundt og rundt – koden i løkka køyrer om igjen og om igjen.

I dette kapittelet skal du lære:
- Korleis variablar kan oppdaterast
- For-løkker for å gjenta kode eit visst tal gonger
- While-løkker for å gjenta kode så lenge eit vilkår er sant
- Å bruke løkker til å utforske talmønster og matematikk

Oppdatere variablar

Ein variabel kan endrast undervegs i programmet. Vi kan oppdatere verdien ved å bruke den gamle verdien til variabelen: teller = 0 teller = teller + 1 # teller er no 1 teller = teller + 1 # teller er no 2 teller = teller + 1 # teller er no 3 print(teller) # Skriv ut 3 Forkortingar for vanlege oppdateringar: Vanleg skriving Forkorting x = x + 3 x += 3 x = x - 1 x -= 1 x = x * 2 x *= 2 x = x / 5 x /= 5 Desse forkortingane gjer akkurat det same, men er raskare å skrive.

Vanleg 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

✏️Døme 1: Gongetabellen

Skriv eit program som skriv ut gongetabellen for $7$ , frå $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 tala $1, 2, 3, \ldots, 10$
- For kvart tal i blir det skrive ut ei linje med $7 \cdot i$
- Løkka køyrer 10 gonger – mykje enklare enn å skrive 10 separate print()-linjer!

📝Oppgave F1

Finn feilen! Amina vil skrive ut tala

1, 2, 3, 4, 5

med ei for-løkke. Ho skriv:

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

Ho ventar å sjå:

Men det ho faktisk ser, er noko anna. Kva blir skrive ut, og kva må ho endre for å få rett resultat?

✏️Døme 2: Summere tal med løkke

Skriv eit program som reknar ut 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 startar med total = 0
- For kvart tal i frå $1$ til $100$ legg vi det til total
- Etter løkka inneheld total summen av alle tala

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

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

Denne historia er kjend: den unge Carl Friedrich Gauss fann denne formelen allereie som 10-åring!

While-løkke

Ei while-løkke gjentek ein kodeblokk så lenge eit vilkår er sant : tall = 1 while tall <= 5: print(tall) tall += 1 Utskrift: 1 2 3 4 5 Korleis det fungerer: 1. Python sjekkar vilkåret tall <= 5 2. Dersom det er sant (True), køyrer koden inni løkka 3. Deretter går Python tilbake til steg 1 og sjekkar igjen 4. Når vilkåret blir usant (False), hoppar Python ut av løkka Samanlikningsoperatorar: Operator Tyding == Er lik!= Er ulik < Mindre enn > Større enn <= Mindre enn eller lik >= Større enn eller lik

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

Uendeleg løkke

Dersom vilkåret i ei while-løkke aldri blir usant, vil løkka køyre for alltid! Dette blir kalla ei uendeleg løkke.

# IKKJE køyr dette - det stoppar aldri!
tall = 1
while tall > 0:
    print(tall)
    tall += 1

Her veks tall heile tida, og vilkåret tall > 0 er alltid sant.

Tips: Sørg alltid for at noko inni while-løkka bringer deg nærare slutten. Dersom programmet «heng», trykk Ctrl+C for å stoppe det.

✏️Døme 3: Dobling med while-løkke

Vi startar med $1$ kr og doblar beløpet kvar dag. Kor mange dagar tek det før vi har meir 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

dagar har vi

2^{10} = 1024

kr, som er meir enn

1000

kr. Eksponentiell vekst er kraftig!

✏️Døme 4: Utforske talmønster med løkke

Bruk ei løkke til å skrive ut dei 10 første trekanttala. Trekanttal 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 differansane mellom trekanttala er $2, 3, 4, 5, 6, \ldots$ – altså dei naturlege tala! Det gir meining fordi $T_n - T_{n-1} = n$ .

✏️Døme 5: Partal og oddetal med range()

Skriv to program: eitt som skriv ut alle partal frå $2$ til $20$ , og eitt som skriv ut alle oddetal frå $1$ til $19$ .

Partal:

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

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

Oddetal:

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) startar på $2$ , aukar med $2$ for kvart steg, og stoppar før $21$
- range(1, 20, 2) startar på $1$ , aukar med $2$ for kvart steg, og stoppar før $20$
- end=" " gjer at print() set mellomrom etter kvar verdi i staden for linjeskift

Nøsta løkke

Ei nøsta løkke er ei løkke inne i ei anna løkke. For kvar gjennomkøyring av den ytre løkka køyrer den indre løkka alle sine gjennomkøyringar.

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økka (rad) går frå $1$ til $3$ . For kvar verdi av rad køyrer den indre løkka (kolonne) frå $1$ til $3$ . Totalt blir det $3 \times 3 = 9$ utskrifter.

📝Oppgave 1

Kva skriv 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 eit program som skriv ut gongetabellen for $9$ (frå $9 \cdot 1$ til $9 \cdot 10$ ) ved å bruke ei for-løkke.

📝Oppgave 3

Skriv eit program som reknar ut summen $1 + 2 + 3 + \ldots + 50$ ved å bruke ei for-løkke.

📝Oppgave 4

Kva skriv 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 eit program som bruker ei for-løkke til å rekne ut $n!$ (n-fakultet) for $n = 7$ . Hugs at $n! = 1 \cdot 2 \cdot 3 \cdot \ldots \cdot n$ .

📝Oppgave 6

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

📝Oppgave 7

Skriv eit program som skriv ut alle kvadrattal frå $1$ til $200$ . Bruk ei while-løkke.

📝Oppgave 8

Skriv eit program som bruker ei for-løkke til å skrive ut dei 15 første ledda i Fibonacci-følgja: $1, 1, 2, 3, 5, 8, 13, \ldots$

📝Oppgave 9

Skriv eit program som bruker nøsta løkker til å skrive ut den vesle gongetabellen ( $1 \times 1$ til $10 \times 10$ ).

📝Oppgave 10

Bruk ei løkke til å utforske følgjande påstand: «Summen av dei $n$ første oddetala er alltid eit kvadrattal.» Skriv eit program som reknar ut summen for $n = 1, 2, 3, \ldots, 10$ og viser at det stemmer.

📝Oppgave D1

Drøftingsoppgåve: Summen

1 + 2 + 3 + \ldots + n

kan reknast ut med formelen

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

eller med ei for-løkke. Diskuter: Når er det best å bruke formelen, og når er det best å bruke ei løkke? Kan du tenkje deg ein sum der det ikkje finst ein enkel formel, slik at ei løkke er det einaste alternativet?

Oppsummering

Oppdatere variablar

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

x

- Vanleg å bruke ein «teljar» eller «akkumulator» som blir oppdatert i løkka

For-løkke

- for i in range(n): gjentek koden

n

gonger, med

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

- range(start, slutt) – frå start til (men ikkje med) slutt
- range(start, slutt, steg) – med eit visst steg mellom verdiane
- Koden inni løkka må ha innrykk

While-løkke

- while vilkår: gjentek koden så lenge vilkåret er sant
- Pass på at vilkåret til slutt blir usant, elles får du ei uendeleg løkke
- Nyttig når du ikkje veit på førehand kor mange gonger koden skal køyre

Nøsta løkker

- Ei løkke inne i ei anna løkke
- Blir brukt t.d. til å lage tabellar (rader og kolonnar)

Matematisk utforsking

- Løkker er perfekte for å utforske talmønster (trekanttal, Fibonacci, osv.)
- Vi kan bruke programmering til å stadfeste eller oppdage matematiske samanhengar

Repetisjonsoppgåver

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.