Algoritmer og programmering 1T-Y (DT) – oppgaver

Oppgave 1 · MiddelsGrunnopplæring i Python

Algoritme for en tallfølge

Oppgave:

Tallfølgen starter med $4$ og øker med $4$ hver gang. Skriv de første $7$ leddene, og finn summen av dem. Forklar også hvordan en enkel Python-løkke kan gjøre det samme.

Vis løsning

Hva spør oppgaven om? Vi skal først oversette oppgaveteksten til matematikk. Deretter velger vi riktig regel, regner i små kontrollerbare steg og forklarer hvorfor hvert steg er lov.

Steg 1 — Finn mønsteret

$a_1=4,\quad d=4$

Fast økning betyr at dette er en aritmetisk følge.

Steg 2 — Skriv leddformelen

$a_k=4+(k-1)\cdot 4$

Formelen gir hvilket som helst ledd i følgen.

Steg 3 — List de første leddene

$4, 8, 12, 16, 20, 24, 28$

Vi legger til den faste differansen hver gang.

Steg 4 — Summer leddene

$4+8+12+16+20+24+28=112$

Summen kan finnes ved direkte addisjon når antall ledd er lite.

Steg 5 — Knytt til algoritme

$\text{gjenta }7\text{ ganger}$

En løkke passer fordi samme handling gjentas.

Steg 6 — Kontroller med formel

$S_n=\dfrac{7(4+28)}{2}=112$

Sumformelen bekrefter løkkeresultatet.

Vanlig feil: Å starte løkken på feil indeks slik at første eller siste ledd mangler.

Tolkning

Algoritmen gjør samme regning som formelen, men steg for steg.

Kontroll i GeoGebra (CAS)

GeoGebra · CAS

1

Sequence(4+(k-1)*4, k, 1, 7)

→

{4, 8, 12, 16, 20, 24, 28}

2

Sum(Sequence(4+(k-1)*4, k, 1, 7))

→

112

Kontroll i Python

Python-kontroll

start = 4
steg = 4
antall = 7
verdier = []
for i in range(antall):
    verdier.append(start + i*steg)
print(verdier)
print(sum(verdier))

Fasit: De første leddene er

4, 8, 12, 16, 20, 24, 28

, og summen er

112

. (Bekreftet i GeoGebra og Python.)

Regel / huskeregel

En løkke brukes når samme regel skal gjentas flere ganger.

Vanlige feil

Off-by-one-feil gjør at løkken får ett ledd for mye eller for lite.

Dette ser sensor etter

Riktig mønster, riktig sum og klar sammenheng mellom matematikk og kode.

For høy måloppnåelse

Forklar hvorfor formel og algoritme gir samme resultat.

Oppgave 2 · KrevendeGrunnopplæring i Python

Algoritme for en tallfølge

Oppgave:

Tallfølgen starter med $5$ og øker med $6$ hver gang. Skriv de første $8$ leddene, og finn summen av dem. Forklar også hvordan en enkel Python-løkke kan gjøre det samme.

Vis løsning

Hva spør oppgaven om? Vi skal først oversette oppgaveteksten til matematikk. Deretter velger vi riktig regel, regner i små kontrollerbare steg og forklarer hvorfor hvert steg er lov.

Steg 1 — Finn mønsteret

$a_1=5,\quad d=6$

Fast økning betyr at dette er en aritmetisk følge.

Steg 2 — Skriv leddformelen

$a_k=5+(k-1)\cdot 6$

Formelen gir hvilket som helst ledd i følgen.

Steg 3 — List de første leddene

$5, 11, 17, 23, 29, 35, 41, 47$

Vi legger til den faste differansen hver gang.

Steg 4 — Summer leddene

$5+11+17+23+29+35+41+47=208$

Summen kan finnes ved direkte addisjon når antall ledd er lite.

Steg 5 — Knytt til algoritme

$\text{gjenta }8\text{ ganger}$

En løkke passer fordi samme handling gjentas.

Steg 6 — Kontroller med formel

$S_n=\dfrac{8(5+47)}{2}=208$

Sumformelen bekrefter løkkeresultatet.

Vanlig feil: Å starte løkken på feil indeks slik at første eller siste ledd mangler.

Tolkning

Algoritmen gjør samme regning som formelen, men steg for steg.

Kontroll i GeoGebra (CAS)

GeoGebra · CAS

1

Sequence(5+(k-1)*6, k, 1, 8)

→

{5, 11, 17, 23, 29, 35, 41, 47}

2

Sum(Sequence(5+(k-1)*6, k, 1, 8))

→

208

Kontroll i Python

Python-kontroll

start = 5
steg = 6
antall = 8
verdier = []
for i in range(antall):
    verdier.append(start + i*steg)
print(verdier)
print(sum(verdier))

Fasit: De første leddene er

5, 11, 17, 23, 29, 35, 41, 47

, og summen er

208

. (Bekreftet i GeoGebra og Python.)

Regel / huskeregel

En løkke brukes når samme regel skal gjentas flere ganger.

Vanlige feil

Off-by-one-feil gjør at løkken får ett ledd for mye eller for lite.

Dette ser sensor etter

Riktig mønster, riktig sum og klar sammenheng mellom matematikk og kode.

For høy måloppnåelse

Forklar hvorfor formel og algoritme gir samme resultat.

Oppgave 3 · KrevendeGrunnopplæring i Python

Algoritme for en tallfølge

Oppgave:

Tallfølgen starter med $6$ og øker med $2$ hver gang. Skriv de første $9$ leddene, og finn summen av dem. Forklar også hvordan en enkel Python-løkke kan gjøre det samme.

Vis løsning

Hva spør oppgaven om? Vi skal først oversette oppgaveteksten til matematikk. Deretter velger vi riktig regel, regner i små kontrollerbare steg og forklarer hvorfor hvert steg er lov.

Steg 1 — Finn mønsteret

$a_1=6,\quad d=2$

Fast økning betyr at dette er en aritmetisk følge.

Steg 2 — Skriv leddformelen

$a_k=6+(k-1)\cdot 2$

Formelen gir hvilket som helst ledd i følgen.

Steg 3 — List de første leddene

$6, 8, 10, 12, 14, 16, 18, 20, 22$

Vi legger til den faste differansen hver gang.

Steg 4 — Summer leddene

$6+8+10+12+14+16+18+20+22=126$

Summen kan finnes ved direkte addisjon når antall ledd er lite.

Steg 5 — Knytt til algoritme

$\text{gjenta }9\text{ ganger}$

En løkke passer fordi samme handling gjentas.

Steg 6 — Kontroller med formel

$S_n=\dfrac{9(6+22)}{2}=126$

Sumformelen bekrefter løkkeresultatet.

Vanlig feil: Å starte løkken på feil indeks slik at første eller siste ledd mangler.

Tolkning

Algoritmen gjør samme regning som formelen, men steg for steg.

Kontroll i GeoGebra (CAS)

GeoGebra · CAS

1

Sequence(6+(k-1)*2, k, 1, 9)

→

{6, 8, 10, 12, 14, 16, 18, 20, 22}

2

Sum(Sequence(6+(k-1)*2, k, 1, 9))

→

126

Kontroll i Python

Python-kontroll

start = 6
steg = 2
antall = 9
verdier = []
for i in range(antall):
    verdier.append(start + i*steg)
print(verdier)
print(sum(verdier))

Fasit: De første leddene er

6, 8, 10, 12, 14, 16, 18, 20, 22

, og summen er

126

. (Bekreftet i GeoGebra og Python.)

Regel / huskeregel

En løkke brukes når samme regel skal gjentas flere ganger.

Vanlige feil

Off-by-one-feil gjør at løkken får ett ledd for mye eller for lite.

Dette ser sensor etter

Riktig mønster, riktig sum og klar sammenheng mellom matematikk og kode.

For høy måloppnåelse

Forklar hvorfor formel og algoritme gir samme resultat.

Oppgave 4 · LettGrafisk framstilling og store datasett med Python

Algoritme for en tallfølge

Oppgave:

Tallfølgen starter med $5$ og øker med $4$ hver gang. Skriv de første $8$ leddene, og finn summen av dem. Forklar også hvordan en enkel Python-løkke kan gjøre det samme.

Vis løsning

Hva spør oppgaven om? Vi skal først oversette oppgaveteksten til matematikk. Deretter velger vi riktig regel, regner i små kontrollerbare steg og forklarer hvorfor hvert steg er lov.

Steg 1 — Finn mønsteret

$a_1=5,\quad d=4$

Fast økning betyr at dette er en aritmetisk følge.

Steg 2 — Skriv leddformelen

$a_k=5+(k-1)\cdot 4$

Formelen gir hvilket som helst ledd i følgen.

Steg 3 — List de første leddene

$5, 9, 13, 17, 21, 25, 29, 33$

Vi legger til den faste differansen hver gang.

Steg 4 — Summer leddene

$5+9+13+17+21+25+29+33=152$

Summen kan finnes ved direkte addisjon når antall ledd er lite.

Steg 5 — Knytt til algoritme

$\text{gjenta }8\text{ ganger}$

En løkke passer fordi samme handling gjentas.

Steg 6 — Kontroller med formel

$S_n=\dfrac{8(5+33)}{2}=152$

Sumformelen bekrefter løkkeresultatet.

Vanlig feil: Å starte løkken på feil indeks slik at første eller siste ledd mangler.

Tolkning

Algoritmen gjør samme regning som formelen, men steg for steg.

Kontroll i GeoGebra (CAS)

GeoGebra · CAS

1

Sequence(5+(k-1)*4, k, 1, 8)

→

{5, 9, 13, 17, 21, 25, 29, 33}

2

Sum(Sequence(5+(k-1)*4, k, 1, 8))

→

152

Kontroll i Python

Python-kontroll

start = 5
steg = 4
antall = 8
verdier = []
for i in range(antall):
    verdier.append(start + i*steg)
print(verdier)
print(sum(verdier))

Fasit: De første leddene er

5, 9, 13, 17, 21, 25, 29, 33

, og summen er

152

. (Bekreftet i GeoGebra og Python.)

Regel / huskeregel

En løkke brukes når samme regel skal gjentas flere ganger.

Vanlige feil

Off-by-one-feil gjør at løkken får ett ledd for mye eller for lite.

Dette ser sensor etter

Riktig mønster, riktig sum og klar sammenheng mellom matematikk og kode.

For høy måloppnåelse

Forklar hvorfor formel og algoritme gir samme resultat.

Oppgave 5 · MiddelsGrafisk framstilling og store datasett med Python

Algoritme for en tallfølge

Oppgave:

Tallfølgen starter med $6$ og øker med $6$ hver gang. Skriv de første $9$ leddene, og finn summen av dem. Forklar også hvordan en enkel Python-løkke kan gjøre det samme.

Vis løsning

Hva spør oppgaven om? Vi skal først oversette oppgaveteksten til matematikk. Deretter velger vi riktig regel, regner i små kontrollerbare steg og forklarer hvorfor hvert steg er lov.

Steg 1 — Finn mønsteret

$a_1=6,\quad d=6$

Fast økning betyr at dette er en aritmetisk følge.

Steg 2 — Skriv leddformelen

$a_k=6+(k-1)\cdot 6$

Formelen gir hvilket som helst ledd i følgen.

Steg 3 — List de første leddene

$6, 12, 18, 24, 30, 36, 42, 48, 54$

Vi legger til den faste differansen hver gang.

Steg 4 — Summer leddene

$6+12+18+24+30+36+42+48+54=270$

Summen kan finnes ved direkte addisjon når antall ledd er lite.

Steg 5 — Knytt til algoritme

$\text{gjenta }9\text{ ganger}$

En løkke passer fordi samme handling gjentas.

Steg 6 — Kontroller med formel

$S_n=\dfrac{9(6+54)}{2}=270$

Sumformelen bekrefter løkkeresultatet.

Vanlig feil: Å starte løkken på feil indeks slik at første eller siste ledd mangler.

Tolkning

Algoritmen gjør samme regning som formelen, men steg for steg.

Kontroll i GeoGebra (CAS)

GeoGebra · CAS

1

Sequence(6+(k-1)*6, k, 1, 9)

→

{6, 12, 18, 24, 30, 36, 42, 48, 54}

2

Sum(Sequence(6+(k-1)*6, k, 1, 9))

→

270

Kontroll i Python

Python-kontroll

start = 6
steg = 6
antall = 9
verdier = []
for i in range(antall):
    verdier.append(start + i*steg)
print(verdier)
print(sum(verdier))

Fasit: De første leddene er

6, 12, 18, 24, 30, 36, 42, 48, 54

, og summen er

270

. (Bekreftet i GeoGebra og Python.)

Regel / huskeregel

En løkke brukes når samme regel skal gjentas flere ganger.

Vanlige feil

Off-by-one-feil gjør at løkken får ett ledd for mye eller for lite.

Dette ser sensor etter

Riktig mønster, riktig sum og klar sammenheng mellom matematikk og kode.

For høy måloppnåelse

Forklar hvorfor formel og algoritme gir samme resultat.

Oppgave 6 · MiddelsGrafisk framstilling og store datasett med Python

Algoritme for en tallfølge

Oppgave:

Tallfølgen starter med $2$ og øker med $2$ hver gang. Skriv de første $5$ leddene, og finn summen av dem. Forklar også hvordan en enkel Python-løkke kan gjøre det samme.

Vis løsning

Hva spør oppgaven om? Vi skal først oversette oppgaveteksten til matematikk. Deretter velger vi riktig regel, regner i små kontrollerbare steg og forklarer hvorfor hvert steg er lov.

Steg 1 — Finn mønsteret

$a_1=2,\quad d=2$

Fast økning betyr at dette er en aritmetisk følge.

Steg 2 — Skriv leddformelen

$a_k=2+(k-1)\cdot 2$

Formelen gir hvilket som helst ledd i følgen.

Steg 3 — List de første leddene

$2, 4, 6, 8, 10$

Vi legger til den faste differansen hver gang.

Steg 4 — Summer leddene

$2+4+6+8+10=30$

Summen kan finnes ved direkte addisjon når antall ledd er lite.

Steg 5 — Knytt til algoritme

$\text{gjenta }5\text{ ganger}$

En løkke passer fordi samme handling gjentas.

Steg 6 — Kontroller med formel

$S_n=\dfrac{5(2+10)}{2}=30$

Sumformelen bekrefter løkkeresultatet.

Vanlig feil: Å starte løkken på feil indeks slik at første eller siste ledd mangler.

Tolkning

Algoritmen gjør samme regning som formelen, men steg for steg.

Kontroll i GeoGebra (CAS)

GeoGebra · CAS

1

Sequence(2+(k-1)*2, k, 1, 5)

→

{2, 4, 6, 8, 10}

2

Sum(Sequence(2+(k-1)*2, k, 1, 5))

→

30

Kontroll i Python

Python-kontroll

start = 2
steg = 2
antall = 5
verdier = []
for i in range(antall):
    verdier.append(start + i*steg)
print(verdier)
print(sum(verdier))

Fasit: De første leddene er

2, 4, 6, 8, 10

, og summen er

30

. (Bekreftet i GeoGebra og Python.)

Regel / huskeregel

En løkke brukes når samme regel skal gjentas flere ganger.

Vanlige feil

Off-by-one-feil gjør at løkken får ett ledd for mye eller for lite.

Dette ser sensor etter

Riktig mønster, riktig sum og klar sammenheng mellom matematikk og kode.

For høy måloppnåelse

Forklar hvorfor formel og algoritme gir samme resultat.

Oppgave 7 · MiddelsGrafisk framstilling og store datasett med Python

Algoritme for en tallfølge

Oppgave:

Tallfølgen starter med $3$ og øker med $4$ hver gang. Skriv de første $6$ leddene, og finn summen av dem. Forklar også hvordan en enkel Python-løkke kan gjøre det samme.

Vis løsning

Hva spør oppgaven om? Vi skal først oversette oppgaveteksten til matematikk. Deretter velger vi riktig regel, regner i små kontrollerbare steg og forklarer hvorfor hvert steg er lov.

Steg 1 — Finn mønsteret

$a_1=3,\quad d=4$

Fast økning betyr at dette er en aritmetisk følge.

Steg 2 — Skriv leddformelen

$a_k=3+(k-1)\cdot 4$

Formelen gir hvilket som helst ledd i følgen.

Steg 3 — List de første leddene

$3, 7, 11, 15, 19, 23$

Vi legger til den faste differansen hver gang.

Steg 4 — Summer leddene

$3+7+11+15+19+23=78$

Summen kan finnes ved direkte addisjon når antall ledd er lite.

Steg 5 — Knytt til algoritme

$\text{gjenta }6\text{ ganger}$

En løkke passer fordi samme handling gjentas.

Steg 6 — Kontroller med formel

$S_n=\dfrac{6(3+23)}{2}=78$

Sumformelen bekrefter løkkeresultatet.

Vanlig feil: Å starte løkken på feil indeks slik at første eller siste ledd mangler.

Tolkning

Algoritmen gjør samme regning som formelen, men steg for steg.

Kontroll i GeoGebra (CAS)

GeoGebra · CAS

1

Sequence(3+(k-1)*4, k, 1, 6)

→

{3, 7, 11, 15, 19, 23}

2

Sum(Sequence(3+(k-1)*4, k, 1, 6))

→

78

Kontroll i Python

Python-kontroll

start = 3
steg = 4
antall = 6
verdier = []
for i in range(antall):
    verdier.append(start + i*steg)
print(verdier)
print(sum(verdier))

Fasit: De første leddene er

3, 7, 11, 15, 19, 23

, og summen er

78

. (Bekreftet i GeoGebra og Python.)

Regel / huskeregel

En løkke brukes når samme regel skal gjentas flere ganger.

Vanlige feil

Off-by-one-feil gjør at løkken får ett ledd for mye eller for lite.

Dette ser sensor etter

Riktig mønster, riktig sum og klar sammenheng mellom matematikk og kode.

For høy måloppnåelse

Forklar hvorfor formel og algoritme gir samme resultat.

Oppgave 8 · MiddelsGrafisk framstilling og store datasett med Python

Algoritme for en tallfølge

Oppgave:

Tallfølgen starter med $4$ og øker med $6$ hver gang. Skriv de første $7$ leddene, og finn summen av dem. Forklar også hvordan en enkel Python-løkke kan gjøre det samme.

Vis løsning

Hva spør oppgaven om? Vi skal først oversette oppgaveteksten til matematikk. Deretter velger vi riktig regel, regner i små kontrollerbare steg og forklarer hvorfor hvert steg er lov.

Steg 1 — Finn mønsteret

$a_1=4,\quad d=6$

Fast økning betyr at dette er en aritmetisk følge.

Steg 2 — Skriv leddformelen

$a_k=4+(k-1)\cdot 6$

Formelen gir hvilket som helst ledd i følgen.

Steg 3 — List de første leddene

$4, 10, 16, 22, 28, 34, 40$

Vi legger til den faste differansen hver gang.

Steg 4 — Summer leddene

$4+10+16+22+28+34+40=154$

Summen kan finnes ved direkte addisjon når antall ledd er lite.

Steg 5 — Knytt til algoritme

$\text{gjenta }7\text{ ganger}$

En løkke passer fordi samme handling gjentas.

Steg 6 — Kontroller med formel

$S_n=\dfrac{7(4+40)}{2}=154$

Sumformelen bekrefter løkkeresultatet.

Vanlig feil: Å starte løkken på feil indeks slik at første eller siste ledd mangler.

Tolkning

Algoritmen gjør samme regning som formelen, men steg for steg.

Kontroll i GeoGebra (CAS)

GeoGebra · CAS

1

Sequence(4+(k-1)*6, k, 1, 7)

→

{4, 10, 16, 22, 28, 34, 40}

2

Sum(Sequence(4+(k-1)*6, k, 1, 7))

→

154

Kontroll i Python

Python-kontroll

start = 4
steg = 6
antall = 7
verdier = []
for i in range(antall):
    verdier.append(start + i*steg)
print(verdier)
print(sum(verdier))

Fasit: De første leddene er

4, 10, 16, 22, 28, 34, 40

, og summen er

154

. (Bekreftet i GeoGebra og Python.)

Regel / huskeregel

En løkke brukes når samme regel skal gjentas flere ganger.

Vanlige feil

Off-by-one-feil gjør at løkken får ett ledd for mye eller for lite.

Dette ser sensor etter

Riktig mønster, riktig sum og klar sammenheng mellom matematikk og kode.

For høy måloppnåelse

Forklar hvorfor formel og algoritme gir samme resultat.