diff --git a/lectures/chap3/lab/intro_til_lokker.ipynb b/lectures/chap3/lab/intro_til_lokker.ipynb
index 24f4355f3ea19d543231764fd8a88a8006f02d51..7f9244b15245f68e9eee34b1f01678416aba3935 100644
--- a/lectures/chap3/lab/intro_til_lokker.ipynb
+++ b/lectures/chap3/lab/intro_til_lokker.ipynb
@@ -343,464 +343,6 @@
"\n",
"Inni while-løkka vil det da også være fornuftig å bytte om rekkefølgen på print-setningen og input-setningen, fordi du allerede har gjort en input før løkka som du kan basere den første \"Hah...\"-responsen på."
]
- },
- {
- "cell_type": "markdown",
- "metadata": {
- "deletable": false,
- "run_control": {
- "frozen": true
- }
- },
- "source": [
- "## c)\n",
- "Ta igjen utgangspunkt i while-løkka med 3 repetisjoner som vist før oppgave (b). Vi ønsker nå å endre programmet på følgende måte:\n",
- "\n",
- "Brukeren starter med 42 bokstaver til disposisjon. For hver runde skal programmet trekke fra antall bokstaver i det adjektivet som ble brukt.\n",
- "\n",
- "Løkka skal fortsette så lenge det fortsatt er bokstaver til disposisjon (dvs. dette tallet er større enn 0). \n",
- "\n",
- "**Eksempel på kjøring:**\n",
- "\n",
- "```python\n",
- "Du har 42 bokstaver til disposisjon.\n",
- "Beskriv deg selv med et adjektiv? snill\n",
- "Hah, du snill!? Jeg er mye snillere!\n",
- "Du har 37 bokstaver til disposisjon.\n",
- "Beskriv deg selv med et adjektiv? desperat\n",
- "Hah, du desperat!? Jeg er mye desperatere!\n",
- "Du har 29 bokstaver til disposisjon.\n",
- "Beskriv deg selv med et adjektiv? kjempetørst\n",
- "Hah, du kjempetørst!? Jeg er mye kjempetørstere!\n",
- "Du har 18 bokstaver til disposisjon.\n",
- "Beskriv deg selv med et adjektiv? megasupereffektiv\n",
- "Hah, du megasupereffektiv!? Jeg er mye megasupereffektivere!\n",
- "Du har 1 bokstaver til disposisjon.\n",
- "Beskriv deg selv med et adjektiv? o\n",
- "Hah, du o!? Jeg er mye oere!\n",
- "Takk for nå!\n",
- ">>>\n",
- "```\n",
- "\n",
- "I siste linje, hvor det bare er 1 bokstav til disposisjon, er brukeren lojal her og skrive bare en bokstav - men du behøver ikke lage programmet slik at det sikrer dette... det er ok om brukeren skriver et lenger ord den siste gangen, så lenge brukeren ikke får lov til å skrive nye ord når antall bokstaver til disposisjon er blitt <= 0."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": []
- },
- {
- "cell_type": "markdown",
- "metadata": {
- "deletable": false,
- "heading_collapsed": true,
- "run_control": {
- "frozen": true
- }
- },
- "source": [
- "**Hint:** I stedet for tellevariabelen i som starter på 0, og med betingelse < 3 i while-setninga, må du nå ha en variabel som starter på 42, og hvor lengden av hvert nye ord trekkes fra i løkka. Lengde kan finnes med funksjonen len(), dvs. len(adj) gir lengden til strengen adj. Testen i while-setninga må også tilpasses til det vi nå er ute etter, nemlig å fortsette så lenge det fremdeles er bokstaver til disposisjon."
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {
- "deletable": false,
- "hidden": true,
- "run_control": {
- "frozen": true
- }
- },
- "source": [
- "#### Intro til for-løkke og range()\n",
- "Som forklart over, er for-løkker egnet for tilfeller hvor antall repetisjoner er kjent. I oppgave (a) startet vi med kode:"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "hidden": true
- },
- "outputs": [],
- "source": [
- "def diss_brukeren_n_ganger(n):\n",
- " \n",
- " for i in range(3):\n",
- " adj = input(\"Beskriv deg selv med et adjektiv? \")\n",
- " print(\"Hah, du\", adj + \"!? Jeg er mye\", adj + \"ere!\")\n",
- " \n",
- " print(\"Takk for nå!\")\n",
- "\n",
- "n = input(\"Hvor mange adjektiv vil du gi? \")\n",
- "diss_brukeren_n_ganger(n)"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {
- "deletable": false,
- "editable": false,
- "hidden": true,
- "run_control": {
- "frozen": true
- }
- },
- "source": [
- "som repeterer 3 ganger. Du byttet deretter ut tallet 3 med en variabel for å kunne repetere et annet (men fortsatt kjent) antall ganger.\n",
- "\n",
- "I oppgave (a) ble løkkevariabelen i ikke brukt til noe inni selve løkka, den fins kun i for-setningen. Poenget i denne løkka er bare å telle opp at den kjører 3 ganger, i har ingen mening utover det.\n",
- "\n",
- "I andre tilfeller hvor vi bruker for-løkker kan løkkevariabelen ha en større betydning. Det er da viktig å forstå ikke bare at f.eks. range(3) fører til 3 repetisjoner, men å vite eksakt hvilken tallsekvens en range() representerer.\n",
- "\n",
- "Generelt gjelder følgende:\n",
- "\n",
- "* Hvis vi gir inn bare **ett tall** til range(), tolkes dette som sluttverdien. Startverdien er default 0. Sluttverdien selv er **ikke** med i sekvensen; det er \"til\", ikke \"til og med\". Eksempel:\n",
- " * range(3) gir tallsekvensen 0, 1, 2. Løkka over kjører 3 ganger ved å ta først med i=0, så med i=1, så med i=2.\n",
- " * range(5) gir 0, 1, 2, 3, 4\n",
- " * range(0) gir en tom tallsekvens. Samme vil være tilfelle med negative tall; og en løkke for i in range(0): vil kjøre null ganger.\n",
- "* Hvis vi gir inn **to tall** til range(), tolkes dette som startverdi (fra og med) og sluttverdi (til, men ikke med). Eksempel:\n",
- " * range(1, 7) gir 1, 2, 3, 4, 5, 6\n",
- " * range(-3, 4) gir -3, -2, -1, 0, 1, 2, 3\n",
- " * range(4, 3) gir en tom tallsekvens (fordi sluttverdi er mindre enn startverdi)\n",
- "* Hvis vi gir inn tre tall til range(), er de to første start og slutt som før, det tredje er stegverdien. Default stegverdi er +1, så vi trenger kun angi den hvis vi ønsker noe annet enn +1. Eksempel:\n",
- " * range(1, 10, 2) gir 1, 3, 5, 7, 9\n",
- " * range(3, 11, 4) gir 3, 7 (men ikke 11, fordi det bare er til sluttverdien, ikke til og med)\n",
- " * range(11, 3, -2) gir 11, 9, 7, 5 - det går altså an å bruke negative tall for stegverdi, da må startverdi være større enn sluttverdi for at løkka skal kjøre\n",
- "\n",
- "På basis av dette kan vi endre det lille programmet over til ett som bruker variabelen i også inne i løkka, f.eks. (**Kjør gjerne selv koden med ctrl + enter, og ta gjerne å endre på verdiene for å se hva som skjer**)"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "hidden": true
- },
- "outputs": [],
- "source": [
- "for i in range(7, 14, 3):\n",
- " adj = input(\"Beskriv deg selv med et adjektiv? \")\n",
- " print(\"Hah, du\", adj + \"!? Jeg er\", i, \"ganger\", adj + \"ere!\")\n",
- "print(\"Takk for nå!\")"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {
- "deletable": false,
- "editable": false,
- "hidden": true,
- "run_control": {
- "frozen": true
- }
- },
- "source": [
- "Her vil koden fortsatt kjøre 3 ganger fordi den resulterende tallsekvensen har 3 elementer, men bruken av i inni løkka gjør programmet mer og mer skrytende. (Bare range(3) ville ikke ha sett like bra ut her, da sier den \"0 ganger...\", \"1 ganger...\" som ikke er særlig imponerende)"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {
- "deletable": false,
- "editable": false,
- "hidden": true,
- "run_control": {
- "frozen": true
- }
- },
- "source": [
- "Et annet eksempel (kjør koden!):"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 3,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Hvilket tall vil du se gangetabellen for? 6\n",
- "6-gangen går slik:\n",
- "6 12 18 24 30 36 42 48 54 60 Takk for nå!\n"
- ]
- }
- ],
- "source": [
- "tall = int(input(\"Hvilket tall vil du se gangetabellen for? \"))\n",
- "print(str(tall)+\"-gangen går slik:\")\n",
- " \n",
- "for i in range(1, 11):\n",
- " print(i * tall, end = \" \")\n",
- " \n",
- "print(\"Takk for nå!\")"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {
- "deletable": false,
- "editable": false,
- "hidden": true,
- "run_control": {
- "frozen": true
- }
- },
- "source": [
- "Merk igjen at sluttverdien er til, men ikke med, så vi må gi 11 som sluttverdi i range() for at den skal få med 70 i resultatet, dersom vi vil se hele 7-gangen.\n",
- "\n",
- "end = \" \" i print-setninga gjør at vi ikke får linjeskift mellom hvert tall men i stedet får dem etter hverandre med blanke mellom.\n",
- "\n",
- " \n",
- "\n",
- "Problemet kunne alternativt ha vært løst ved å bruke tallet det skal ganges med som stegverdi. Ulempen er at range-uttrykket blir litt mer komplisert, men samtidig slipper vi nå unna med en enkelt multiplikasjon utenfor løkka i stedet for å multiplisere i hver runde av løkka:"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 4,
- "metadata": {
- "ExecuteTime": {
- "end_time": "2019-07-02T12:45:50.304075Z",
- "start_time": "2019-07-02T12:33:15.731777Z"
- },
- "hidden": true
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Hvilket tall vil du se gangetabellen for? 6\n",
- "6-gangen går slik:\n",
- "6 12 18 24 30 36 42 48 54 60 Takk for nå!\n"
- ]
- }
- ],
- "source": [
- "tall = int(input(\"Hvilket tall vil du se gangetabellen for? \"))\n",
- "print(str(tall)+\"-gangen går slik:\")\n",
- " \n",
- "for i in range(tall, tall * 10 + 1, tall):\n",
- " print(i, end = \" \")\n",
- " \n",
- "print(\"Takk for nå!\")"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {
- "deletable": false,
- "editable": false,
- "hidden": true,
- "run_control": {
- "frozen": true
- }
- },
- "source": [
- "Dette programmet vil gi eksakt samme utskrift som det foregående, bare oppnådd på en litt annen måte; for 7-gangen vil nå 7 være startverdi og stegverdi, og 71 sluttverdi for range()."
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {
- "deletable": false,
- "run_control": {
- "frozen": true
- }
- },
- "source": [
- "## d)\n",
- "koden under er de to første for-løkkene ferdige og gir riktig utskrift i forhold til den forklarende teksten i print-setningene.\n",
- "\n",
- "Den neste oppgaven er ikke ferdig. Bytt ut `range(0)` i disse tre (også merket med ###) slik at for-løkken gir tallsekvenser som passer med det som forklares i print-setningene.\n",
- "\n",
- "\n",
- "**Øvelse på range()**"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 1,
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Oddetallene fra 1 til 20:\n",
- "1 3 5 7 9 11 13 15 17 19 \n",
- "Tallene i 3-gangen mellom 12 og 25:\n",
- "12 15 18 21 24 \n"
- ]
- }
- ],
- "source": [
- "#Oddetall fra til\n",
- "\n",
- "#Oddetall i gange\n",
- "\n",
- "#tallsekvens\n",
- "\n",
- "#telle baklengs med gitt intervall fra til\n",
- "\n",
- "print(\"Oddetallene fra 1 til 20:\")\n",
- "def oddetall_fra_til(fra, til):\n",
- " for number in range(fra, til + 1, 2):\n",
- " print(number, end = \" \")\n",
- " \n",
- "oddetall_fra_til(1,20)\n",
- "print()\n",
- "\n",
- "print(\"Tallene i 3-gangen mellom 12 og 25:\")\n",
- "def tre_gangen(fra,til):\n",
- " for number in range(fra,til,3):\n",
- " print(number, end = \" \")\n",
- "\n",
- "tre_gangen(12,25)\n",
- "\n",
- "#Fullfør funksjonen under:\n",
- "\n",
- "def x_gangen(x): # Tar in x, og returnerer de 10 første tallene i x-gangen\n",
- " for number in range(0): ###\n",
- " print(number, end = \" \")\n",
- " print()\n",
- "x_gangen(5)\n",
- "\n"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {
- "run_control": {
- "frozen": true
- }
- },
- "source": [
- "## e)\n",
- "Lag et funksjon, print_numbers(start, stop), som printer tallene fra start til og med stop. Bruk en forløkke i funksjonen.\n",
- "\n",
- "***Skriv koden din her:***"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 2,
- "metadata": {
- "ExecuteTime": {
- "end_time": "2019-07-02T12:45:50.308821Z",
- "start_time": "2019-07-02T12:37:38.116Z"
- }
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "1\n",
- "2\n",
- "3\n",
- "4\n",
- "5\n"
- ]
- }
- ],
- "source": []
- },
- {
- "cell_type": "markdown",
- "metadata": {
- "deletable": false,
- "run_control": {
- "frozen": true
- }
- },
- "source": [
- "## f) \n",
- "Lag et funksjon print_numbers_reversed(start,stop), som printer ut tallene fra stop til start. Her skal start være et mindre tall enn stop. Bruk en forløkke.\n",
- "\n",
- "***Skriv koden din her:***"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 4,
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "15\n",
- "14\n",
- "13\n",
- "12\n",
- "11\n",
- "10\n",
- "9\n",
- "8\n",
- "7\n",
- "6\n",
- "5\n",
- "4\n",
- "3\n",
- "2\n",
- "1\n"
- ]
- }
- ],
- "source": []
- },
- {
- "cell_type": "markdown",
- "metadata": {
- "heading_collapsed": true,
- "run_control": {
- "frozen": true
- }
- },
- "source": []
- },
- {
- "cell_type": "markdown",
- "metadata": {
- "deletable": false,
- "hidden": true,
- "run_control": {
- "frozen": true
- }
- },
- "source": [
- "## Evig while-løkke\n",
- "Hvis en while-løkke ikke blir stoppet kan den kjøre evig. Et eksempel er en løkke som starter ***while True*** ; da vil betingelsen alltid være sann uansett hva som skjer inni løkka. Løkka vist under vil printe Jeg elsker ITGK! et uendelig antall ganger.\n",
- "\n",
- "Det vil vanligvis gå greit å stoppe programmet likevel, enten ved å trykke Ctrl-C eller ved å lukke vinduet der koden kjører... men **lagre for sikkerhets skyld alle filer du jobber med før du eksperimenterer med å kjøre en evig løkke**.\n",
- "\n",
- "Eksempel på en evig løkke:"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "ExecuteTime": {
- "end_time": "2019-07-02T12:45:50.310736Z",
- "start_time": "2019-07-02T12:40:47.558Z"
- },
- "hidden": true
- },
- "outputs": [],
- "source": [
- "while True:\n",
- " print(\"Jeg elsker ITGK!\")"
- ]
}
],
"metadata": {
diff --git a/lectures/chap3/lab/lab-3.md b/lectures/chap3/lab/lab-3.md
index dab0423d365a2264558afe3812aa02c1aa204921..9fc70457e4740c1d2855a2f24603ad9d7c749b72 100644
--- a/lectures/chap3/lab/lab-3.md
+++ b/lectures/chap3/lab/lab-3.md
@@ -7,8 +7,6 @@
### Læringsaktiviteter
-* [Sammenligning ac strenger](sammenligning_av_strenger.ipynb)
+* [Sammenligning av strenger](sammenligning_av_strenger.ipynb)
* [Introduksjon til løkker](intro_til_lokker.ipynb)
-* [Oppsamlingsløkker](mer_om_lokker.ipynb)
-* [Nøstede løkker](nostede_lokker.ipynb)
* [Gjettelek](gjett_tallet.ipynb)
diff --git a/lectures/chap3/lab/mer_om_lokker.ipynb b/lectures/chap3/lab/mer_om_lokker.ipynb
deleted file mode 100644
index f25684cf3a1861e690788c9896626fe3f58d409a..0000000000000000000000000000000000000000
--- a/lectures/chap3/lab/mer_om_lokker.ipynb
+++ /dev/null
@@ -1,433 +0,0 @@
-{
- "cells": [
- {
- "attachments": {},
- "cell_type": "markdown",
- "metadata": {
- "deletable": false,
- "run_control": {
- "frozen": true
- }
- },
- "source": [
- "# Mer om løkker - oppsamlingsløkker\n",
- "\n",
- "**Læringsmål:**\n",
- "\n",
- "* Løkker\n",
- "\n",
- "I denne oppgaven ser vi spesielt på løkker som samler opp et resultat underveis. Hvis du har programmert noe før, vil dette være enkle oppgaver, men for deg som er helt uerfaren, se gjerne på følgende tutorial om oppsamlingsløkker før du setter i gang:"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {
- "deletable": false,
- "editable": false,
- "heading_collapsed": true,
- "run_control": {
- "frozen": true
- }
- },
- "source": [
- "### Tutorial om oppsamlingsløkker"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {
- "deletable": false,
- "editable": false,
- "hidden": true,
- "run_control": {
- "frozen": true
- }
- },
- "source": [
- "Ofte brukes løkker til å samle opp et resultat (f.eks. en tallverdi) som vi er interessert i å finne. Et enkelt eksempel på en oppsamlingsløkke, er følgende som summerer alle tallene fra og med 1 til og med 100 (som egentlig er en unødvendig løkke å kjøre siden resultatet er kjent på forhånd, men greit å bruke som illustrasjon):"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "hidden": true
- },
- "outputs": [],
- "source": [
- "summen = 0\n",
- "for i in range(1, 101):\n",
- " summen += i # summen = summen + i\n",
- "print(\"Summen av tallene 1-100:\", summen)"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {
- "deletable": false,
- "editable": false,
- "hidden": true,
- "run_control": {
- "frozen": true
- }
- },
- "source": [
- "range() må ha 101 som sluttverdi fordi den er til men ikke med, dvs. hvis tallet 100 skal være med i summen. Variabelen **summen** er den som brukes til å samle opp resultatet underveis. Det kunne ha vært fristende å kalle variabelen bare sum, men dette er navnet på en standardfunksjon i Python og dermed ikke lurt å bruke som variabelnavn. Merk deg at summen må defineres **før** løkka, og der gis verdien 0 (fordi vi ikke har summert inn noen av tallene ennå). Dette fordi vi inni løkka ønsker å utføre summen = summen + 1 (som kortere kan skrives summen += 1), og et slikt uttrykk hvor summen også fins på høyre side av = kan bare fungere hvis den allerede har fått en verdi. Måten dette programmet funker på, er altså at vi starter med å gi summen verdi 0. Så begynner løkka, med i = 1, og vi legger til i (dvs. 1) til summen som da blir 1. Så blir i 2, som legges til summen, som nå blir 3. Så i=3, summen = 6. Så i=4, summen = 10, osv. Siste gang løkka kjøres er i=100 og summen blir 5050, så avslutter løkka og vi printer resultatet på skjermen.\n",
- "\n",
- "Tilsvarende hvis vi skulle gange sammen alle tallene 1-20:"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "hidden": true
- },
- "outputs": [],
- "source": [
- "produktet = 1\n",
- "for i in range(1, 20):\n",
- " produktet *= i # produktet = produktet * i\n",
- "print(\"Produktet av tallene 1-20:\", produktet)"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {
- "deletable": false,
- "editable": false,
- "hidden": true,
- "run_control": {
- "frozen": true
- }
- },
- "source": [
- "Strukturelt er dette temmelig likt - en viktig forskjell er at når vi skal gange, blir riktig startverdi 1 (som er det tallet som ikke påvirker et produkt) mens det var 0 for summering.\n",
- "\n",
- "Til slutt et lite eksempel der det passer bedre med while enn med for, fordi vi ikke aner antall repetisjoner:"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "hidden": true
- },
- "outputs": [],
- "source": [
- "print(\"Skriv inn ett og ett positivt heltall.\")\n",
- "print(\"For å avslutte, skriv et negativt tall (dette telles ikke med).\")\n",
- "tall = int(input(\"Tall: \"))\n",
- "storst = tall # første tall er størst, inntil annet bevist\n",
- "antall = 0\n",
- " \n",
- "while tall >= 0:\n",
- " if tall > storst:\n",
- " storst = tall\n",
- " antall += 1\n",
- " tall = int(input(\"Tall: \"))\n",
- " \n",
- "print(\"Du skrev inn\", antall, \"tall.\")\n",
- "print(\"Det største var\", storst)"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {
- "deletable": false,
- "editable": false,
- "hidden": true,
- "run_control": {
- "frozen": true
- }
- },
- "source": [
- "Her skriver brukeren inn en serie tall fra tastaturet - og gir et negativt tall for å avslutte - og programmets oppgave til slutt er å kunne fortelle hvor mange tall som ble skrevet inn (bortsett fra det negative), og hva som var det største av tallene. For å telle opp antallet, har vi variabelen antall som settes til 0 før løkka, og deretter økes med 1 for hver runde av løkka. For å finne det største tallet, antar vi før løkka at det første tallet også er det største. (Vi må uansett lese det første tallet før løkka, for at while-testen skal funke). Deretter tester vi for hver runde av løkka om det sist innleste tallet er større enn det som var størst hittil, i så fall gis variabelen storst verdien til dette nye tallet i stedet. Variabelen storst vil dermed til en hver tid inneholde den største verdien hittil."
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {
- "deletable": false,
- "editable": false,
- "run_control": {
- "frozen": true
- }
- },
- "source": [
- "### a)"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {
- "deletable": false,
- "run_control": {
- "frozen": true
- }
- },
- "source": [
- "Lag en funksjon som ved hjelp av en løkke ber brukeren om å taste inn x heltall, som vist i eksemplet på kjøring under. x tas inn som brukerinput. Til slutt skal funksjonen returnere summen av tallene.\n",
- "\n",
- "Eksempel på kjøring:\n",
- "```\n",
- "Hvor mange tall vil du summere? 7\n",
- "Skriv inn et heltall: 6\n",
- "Skriv inn et heltall: 4\n",
- "Skriv inn et heltall: 7\n",
- "Skriv inn et heltall: 3\n",
- "Skriv inn et heltall: 2\n",
- "Skriv inn et heltall: 456\n",
- "Skriv inn et heltall: 99\n",
- "Summen av tallene ble 577\n",
- "```\n",
- "\n",
- "***Skriv koden din her:***"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "\n"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {
- "deletable": false,
- "editable": false,
- "heading_collapsed": true,
- "run_control": {
- "frozen": true
- }
- },
- "source": [
- "#### Hint"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {
- "deletable": false,
- "editable": false,
- "hidden": true,
- "run_control": {
- "frozen": true
- }
- },
- "source": [
- "Du vil trenge en variabel til å summere inn ett og ett nytt tall for hver runde av løkka. Husk at denne variabelen må være opprettet og gitt en passende startverdi før løkka, ellers vil du ikke klare å bruke den i løkka."
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {
- "deletable": false,
- "editable": false,
- "run_control": {
- "frozen": true
- }
- },
- "source": [
- "### b)"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {
- "deletable": false,
- "run_control": {
- "frozen": true
- }
- },
- "source": [
- "Lag en funksjon som multipliserer sammen alle tallene fra 1,2,3,... og avslutter når produktet er større enn 1000.\n",
- "\n",
- "***Skriv koden din her:***"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 5,
- "metadata": {
- "ExecuteTime": {
- "end_time": "2019-07-02T12:56:17.761917Z",
- "start_time": "2019-07-02T12:56:17.756785Z"
- }
- },
- "outputs": [
- {
- "data": {
- "text/plain": [
- "5040"
- ]
- },
- "execution_count": 5,
- "metadata": {},
- "output_type": "execute_result"
- }
- ],
- "source": [
- "\n",
- " "
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {
- "deletable": false,
- "editable": false,
- "heading_collapsed": true,
- "run_control": {
- "frozen": true
- }
- },
- "source": [
- "#### Hint 2"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {
- "deletable": false,
- "editable": false,
- "hidden": true,
- "run_control": {
- "frozen": true
- }
- },
- "source": [
- "Du vet ikke på forhånd hvor lenge du kan multiplisere tallene før du får et produkt større enn 1000, så her kan det være lurt å bruke en while-løkke med produkt mindre enn 1000 som betingelse. Svaret skal bli 5040. Som for oppgave (a) vil du trenge en variabel til å gange inn ett og ett nytt tall for hver runde av løkka, og som må ha fått en passende startverdi før løkka. Merk at passende startverdi for en variabel som skal samle opp et produkt, vil være et annet tall enn det man bruker som startverdi for å samle opp en sum."
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {
- "deletable": false,
- "editable": false,
- "run_control": {
- "frozen": true
- }
- },
- "source": [
- "### c)"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {
- "deletable": false,
- "run_control": {
- "frozen": true
- }
- },
- "source": [
- "Lag en funksjon, quiztion(q, a) som stiller brukeren det samme spørsmålet q, om og om igjen, helt til det korrekte svaret blir skrevet. Funksjonen tar inn spørsålet q og svaret a som tekststrenger. Når rett svar er tastet inn av bruker skal programmet fortelle hvor mange forsøk som ble brukt. Eksempel på kjøring vist nedenfor, men du kan godt bytte ut med et spørsmål med annen tematikk, noe du selv er interessert i. Se ***hint 3*** dersom du står fast.\n",
- "\n",
- "Eksempel på kjøring:\n",
- "\n",
- "```\n",
- "quiztion(\"Hva heter hovedstaden til Niue\", \"Alofi\")\n",
- "\n",
- "Hva heter hovedstaden til Niue? Niue City\n",
- "Det var feil, prøv igjen.\n",
- "Hva heter hovedstaden til Niue? Niuania\n",
- "Det var feil, prøv igjen.\n",
- "Hva heter hovedstaden til Niue? Apia\n",
- "Det var feil, prøv igjen.\n",
- "Hva heter hovedstaden til Niue? Alofi\n",
- "Korrekt!! Du brukte 4 forsøk.\n",
- "```\n",
- "\n",
- "***Skriv koden din her:***"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 4,
- "metadata": {
- "ExecuteTime": {
- "end_time": "2019-07-02T13:03:21.820001Z",
- "start_time": "2019-07-02T13:03:21.814887Z"
- }
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Hva er hovedstaden til Niue? alofi\n",
- "Det var feil, prøv igjen.\n",
- "Hva er hovedstaden til Niue? alfoi\n",
- "Det var feil, prøv igjen.\n",
- "Hva er hovedstaden til Niue? alfoi\n",
- "Det var feil, prøv igjen.\n",
- "Hva er hovedstaden til Niue? Alofi\n",
- "Korrekt!! Du brukte 3 forsøk.\n"
- ]
- }
- ],
- "source": []
- },
- {
- "cell_type": "markdown",
- "metadata": {
- "deletable": false,
- "editable": false,
- "heading_collapsed": true
- },
- "source": [
- "#### Hint 3"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {
- "deletable": false,
- "editable": false,
- "hidden": true
- },
- "source": [
- "Du vet ikke hvor mange ganger brukeren svarer feil så det kan være lurt med en while-løkke hvor betingelsen er at brukerens svar != riktig svar."
- ]
- }
- ],
- "metadata": {
- "celltoolbar": "Edit Metadata",
- "kernelspec": {
- "display_name": "Python 3",
- "language": "python",
- "name": "python3"
- },
- "language_info": {
- "codemirror_mode": {
- "name": "ipython",
- "version": 3
- },
- "file_extension": ".py",
- "mimetype": "text/x-python",
- "name": "python",
- "nbconvert_exporter": "python",
- "pygments_lexer": "ipython3",
- "version": "3.7.4"
- },
- "toc": {
- "base_numbering": 1,
- "nav_menu": {},
- "number_sections": false,
- "sideBar": true,
- "skip_h1_title": false,
- "title_cell": "Table of Contents",
- "title_sidebar": "Contents",
- "toc_cell": false,
- "toc_position": {},
- "toc_section_display": true,
- "toc_window_display": false
- }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}
diff --git a/lectures/chap3/lab/nostede_lokker.ipynb b/lectures/chap3/lab/nostede_lokker.ipynb
deleted file mode 100644
index 9c540fe03a2538f4f21974c123a589f5a8080213..0000000000000000000000000000000000000000
--- a/lectures/chap3/lab/nostede_lokker.ipynb
+++ /dev/null
@@ -1,433 +0,0 @@
-{
- "cells": [
- {
- "attachments": {},
- "cell_type": "markdown",
- "metadata": {
- "deletable": false,
- "run_control": {
- "frozen": true
- }
- },
- "source": [
- "# Intro til nøstede løkker\n",
- "\n",
- "**Læringsmål:**\n",
- "\n",
- "* Nøstede løkker\n",
- "\n",
- "I denne oppgaven skal du lære hvordan vi kan benytte oss av en løkke inne i en annen løkke. "
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {
- "hidden": true,
- "run_control": {
- "frozen": true
- }
- },
- "source": [
- "### Intro til nøstede løkker\n",
- "Nøstede løkker vil si løkker som er inni andre løkker. Et eksempel på en nøstet løkke er en dobbel løkke, som vil si at det er en løkke inni en annen løkke. Doble løkker brukes mye i programmering, typisk når man skal løse problemer som på en eller annen måte er todimensjonale, f.eks. knyttet til matriser eller todimensjonale tabeller med tall. Todimensjonal her kan bety rent visuelt (f.eks. at man skal tegne noe på en skjerm og må oppdatere fargen i hvert punkt i et rutenett av piksler), men behøver ikke å ha noen visuell betydning. Det kan være snakk om dimensjoner av informasjon på en mer abstrakt måte. F.eks. kan de to dimensjonene være tall og verdier i kortstokken, vi kan da generere en hel kortstokk ved en dobbel løkke som følger:"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 14,
- "metadata": {
- "ExecuteTime": {
- "end_time": "2019-07-02T13:13:16.212772Z",
- "start_time": "2019-07-02T13:13:16.199788Z"
- },
- "hidden": true
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "♠A ♠2 ♠3 ♠4 ♠5 ♠6 ♠7 ♠8 ♠9 ♠10 ♠J ♠Q ♠K \n",
- "♣A ♣2 ♣3 ♣4 ♣5 ♣6 ♣7 ♣8 ♣9 ♣10 ♣J ♣Q ♣K \n",
- "♥A ♥2 ♥3 ♥4 ♥5 ♥6 ♥7 ♥8 ♥9 ♥10 ♥J ♥Q ♥K \n",
- "♦A ♦2 ♦3 ♦4 ♦5 ♦6 ♦7 ♦8 ♦9 ♦10 ♦J ♦Q ♦K \n",
- "\n"
- ]
- }
- ],
- "source": [
- "\n",
- "def format_card_deck():\n",
- " \n",
- " farger = ['♠', '♣', '♥', '♦']\n",
- " verdier = ['A', '2', '3', '4', '5', '6', '7', '8',\n",
- " '9', '10', 'J', 'Q', 'K']\n",
- " outer_string = \"\"\n",
- " \n",
- " for farge in farger: # Traverse the farger-array\n",
- " inner_string = \"\"\n",
- " for verdi in verdier: # Traverse the verdier-array\n",
- " inner_string += farge + verdi + \" \" # Add the current farge and verdi, in addition to spacing\n",
- " outer_string += inner_string + \"\\n\" # add all the values of one farge to the result, and start at a new line\n",
- " \n",
- " return outer_string\n",
- "\n",
- "print(format_card_deck())\n",
- "\n",
- " "
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {
- "deletable": false,
- "hidden": true,
- "run_control": {
- "frozen": true
- }
- },
- "source": [
- "Den innerste løkka går 13 runder hver gang den kjører fordi det er 13 elementer i sekvensen som gis til for-løkka (verdier). Den legger til hver av kortene i en farge til en indre streng. Denne strengen legges til en ytre streng når den indre forløkken er ferdig. Dermed får vi alle kortene av en sort hver gang den indre forløkken er ferdig å kjøre. Merk \"\\n\" i den ytre strengen. Dette gjør at vi skifter linje mellom hver gang den fullførte indre strengen legges til den ytre strengen. Den ytre løkka går 4 ganger, en for hver farge i kortstokken"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## a)"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {
- "deletable": false,
- "run_control": {
- "frozen": true
- }
- },
- "source": [
- "**Eksempel på nøstet løkke med print**"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 6,
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Jeg elsker ITGK! Jeg elsker ITGK! Jeg elsker ITGK! \n",
- "Jeg elsker ITGK! Jeg elsker ITGK! Jeg elsker ITGK! \n",
- "Jeg elsker ITGK! Jeg elsker ITGK! Jeg elsker ITGK! \n",
- "Jeg elsker ITGK! Jeg elsker ITGK! Jeg elsker ITGK! \n",
- "Jeg elsker ITGK! Jeg elsker ITGK! Jeg elsker ITGK! \n"
- ]
- }
- ],
- "source": [
- "for x in range(5):\n",
- " for y in range(3):\n",
- " print(\"Jeg elsker ITGK! \", end=\" \")\n",
- " print()"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "**Under følger en funksjon og bygging av tekststreng som gir samme output som løkkene over:**"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 16,
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Jeg elsker ITGK! Jeg elsker ITGK! Jeg elsker ITGK! \n",
- "Jeg elsker ITGK! Jeg elsker ITGK! Jeg elsker ITGK! \n",
- "Jeg elsker ITGK! Jeg elsker ITGK! Jeg elsker ITGK! \n",
- "Jeg elsker ITGK! Jeg elsker ITGK! Jeg elsker ITGK! \n",
- "Jeg elsker ITGK! Jeg elsker ITGK! Jeg elsker ITGK! \n",
- "\n"
- ]
- }
- ],
- "source": [
- "def nested_loop_example():\n",
- " \n",
- " result_string = \"\"\n",
- " \n",
- " for x in range(5):\n",
- " inner_string = \"\"\n",
- " \n",
- " for y in range(3):\n",
- " inner_string += \"Jeg elsker ITGK! \"\n",
- " \n",
- " result_string += inner_string + \"\\n\"\n",
- " return result_string\n",
- "\n",
- "print(nested_loop_example())"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {
- "deletable": false,
- "run_control": {
- "frozen": true
- }
- },
- "source": [
- "Denne utskriften trenger man strengt tatt ikke dobbel løkke for å få til; selve utskriften gir riktig nok et todimensjonalt inntrykk, men siden den underliggende informasjonen ikke er todimensjonal men derimot konstant (samme utskrift \"Jeg elsker ITGK!\" i alle tilfeller), er det også greit mulig å klare dette med enkel løkke, eller helt uten løkker, som følger:"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 3,
- "metadata": {
- "ExecuteTime": {
- "end_time": "2019-07-02T13:15:07.223226Z",
- "start_time": "2019-07-02T13:15:07.215744Z"
- }
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Jeg elsker ITGK! Jeg elsker ITGK! Jeg elsker ITGK!\n",
- "Jeg elsker ITGK! Jeg elsker ITGK! Jeg elsker ITGK!\n",
- "Jeg elsker ITGK! Jeg elsker ITGK! Jeg elsker ITGK!\n",
- "Jeg elsker ITGK! Jeg elsker ITGK! Jeg elsker ITGK!\n",
- "Jeg elsker ITGK! Jeg elsker ITGK! Jeg elsker ITGK!\n",
- "Jeg elsker ITGK! Jeg elsker ITGK! Jeg elsker ITGK! \n",
- "Jeg elsker ITGK! Jeg elsker ITGK! Jeg elsker ITGK! \n",
- "Jeg elsker ITGK! Jeg elsker ITGK! Jeg elsker ITGK! \n",
- "Jeg elsker ITGK! Jeg elsker ITGK! Jeg elsker ITGK! \n",
- "Jeg elsker ITGK! Jeg elsker ITGK! Jeg elsker ITGK! \n",
- "\n"
- ]
- }
- ],
- "source": [
- "# Løsning med enkel løkke:\n",
- "for x in range(5):\n",
- " print(\"Jeg elsker ITGK! Jeg elsker ITGK! Jeg elsker ITGK!\")\n",
- "\n",
- "# Løsning uten løkker; \"\\n\" er tegnet for linjeskift (newline på engelsk)\n",
- "print(((\"Jeg elsker ITGK! \" * 3) + \"\\n\") * 5)"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {
- "deletable": false,
- "run_control": {
- "frozen": true
- }
- },
- "source": [
- "Koden over vil skrive ut “Jeg elsker ITGK!” tre ganger ved siden av hverandre fem ganger nedover. Dette skjer på to ulike måter, derav 10 linjer i outputen. \n",
- "\n",
- "Hvis vi nå endrer litt på kravene til programmet, så det skal handle om flere studenter enn \"Jeg\" og flere emner enn \"ITGK\", vil vi ha et genuint todimensjonalt problem (én dimensjon er studenter, en annen emner) hvor dobbel løkke vil være klart enkleste løsning. **Din oppgave: kopier funksjonen nested_loop_example(), endre programmet så det gir utskrift som vist nedenfor**. Fra forrige oppgave skal altså Jeg byttes ut med Stud <nummer>, og ITGK skal byttes ut med Emne <nummer>. Brukeren skal angi ønsket antall for både studenter og emner, 4 og 3 er bare eksempler.\n",
- "\n",
- "```\n",
- "print(nested_loop_example())\n",
- "Hvor mange studenter? 4\n",
- "Hvor mange emner? 3\n",
- "Stud 1 elsker Emne 1 ; Stud 1 elsker Emne 2 ; Stud 1 elsker Emne 3 ;\n",
- "Stud 2 elsker Emne 1 ; Stud 2 elsker Emne 2 ; Stud 2 elsker Emne 3 ;\n",
- "Stud 3 elsker Emne 1 ; Stud 3 elsker Emne 2 ; Stud 3 elsker Emne 3 ;\n",
- "Stud 4 elsker Emne 1 ; Stud 4 elsker Emne 2 ; Stud 4 elsker Emne 3 ;\n",
- "```\n",
- "\n",
- "**EKSTRA UTFORDRING** (ikke nødvendig for å få godkjent (a)): For å gjøre programmet litt mindre tørt og abstrakt, kan du prøve å endre så det skriver fornavn på personer i stedet for \"Stud x\", og navn på faktiske emner i stedet for Emne y - jfr eksempel med kortstokk i teksten \"Intro til nøstede løkker\" øverst i denne oppgaven. For å gjøre det mindre forutsigbart, kan du dessuten bruke funksjonen random() for å generere tilfeldige tall for hver runde av løkka, og ha en if-setning for å velge verb basert på verdien av dette. F.eks. \"elsker\" bare hvis tallet ble > 0.9, og gradvis litt mer beskjedne verb til lavere tallverdien var."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": []
- },
- {
- "cell_type": "markdown",
- "metadata": {
- "deletable": false,
- "editable": false,
- "run_control": {
- "frozen": true
- }
- },
- "source": [
- "## b)"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {
- "deletable": false,
- "run_control": {
- "frozen": true
- }
- },
- "source": [
- "Lag en funksjon som returnerer en tekststreng med alle klokkeslett i løpet av et døgn på en fin måte. Du trenger kun å tenke på timer og minutter. Klokkeslettene skal gå fra 0:0 til 23:59 som vist nedenfor.\n",
- "\n",
- "Eksempel på kjøring av kode:\n",
- "\n",
- "```python\n",
- "print(klokkeslett())\n",
- "\n",
- "0:0\n",
- "0:1\n",
- "0:2\n",
- ".\n",
- ". # Alle klokkeslett i mellom her skal skrives ut\n",
- ".\n",
- "23:58\n",
- "23:59```\n",
- "\n",
- "***Skriv koden din her:***"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "ExecuteTime": {
- "end_time": "2019-07-02T13:21:25.863928Z",
- "start_time": "2019-07-02T13:21:25.855403Z"
- }
- },
- "outputs": [],
- "source": []
- },
- {
- "cell_type": "markdown",
- "metadata": {
- "deletable": false,
- "editable": false,
- "run_control": {
- "frozen": true
- }
- },
- "source": [
- "## c)"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {
- "deletable": false,
- "run_control": {
- "frozen": true
- }
- },
- "source": [
- "Bruk doble løkker til å lage en funksjon som returnerer alle tallene i den lille gangetabellen, dvs. lag to for-løkker opp til 11 og multipliser variabelen x fra den ene løkken med variabelen y fra den andre løkken og bygg det på en indre streng i den innerste løkken. Du trenger ikke å tenke på formatet til utskriften.\n",
- "\n",
- "Eksempel på kjøring:\n",
- "\n",
- "```python\n",
- "print(gangetabellen())\n",
- "1\n",
- "2\n",
- "3\n",
- "4\n",
- "5\n",
- ".\n",
- ".\n",
- ".\n",
- "60\n",
- "70\n",
- "80\n",
- "90\n",
- "100\n",
- "```\n",
- "***Skriv koden din her:***"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "ExecuteTime": {
- "end_time": "2019-07-02T13:22:00.046861Z",
- "start_time": "2019-07-02T13:22:00.042947Z"
- }
- },
- "outputs": [],
- "source": [
- "\n",
- " "
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {
- "deletable": false,
- "run_control": {
- "frozen": true
- }
- },
- "source": [
- "**Bonus**: Forsøk å legg inn \"\\n\" etter den innerste løkken i c) har kjørt (dvs. på samme innrykk som innerste for, men nedenfor linjen hvor inner_string blir utvidet med tall. Legg også til et mellomrom etter str(i*j)' ' på slutten av print-funksjonen som printer ut tallene. Ser du nå at det ligner mer på en gangetabell?"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": []
- }
- ],
- "metadata": {
- "celltoolbar": "Edit Metadata",
- "kernelspec": {
- "display_name": "Python 3.9.12 ('SmartHouseMaster')",
- "language": "python",
- "name": "python3"
- },
- "language_info": {
- "codemirror_mode": {
- "name": "ipython",
- "version": 3
- },
- "file_extension": ".py",
- "mimetype": "text/x-python",
- "name": "python",
- "nbconvert_exporter": "python",
- "pygments_lexer": "ipython3",
- "version": "3.9.12"
- },
- "toc": {
- "base_numbering": 1,
- "nav_menu": {},
- "number_sections": false,
- "sideBar": true,
- "skip_h1_title": false,
- "title_cell": "Table of Contents",
- "title_sidebar": "Contents",
- "toc_cell": false,
- "toc_position": {},
- "toc_section_display": true,
- "toc_window_display": false
- },
- "vscode": {
- "interpreter": {
- "hash": "53b29c5bb29b0e4a11959d726fa093ba7b17a1c34d9f75eec3a80fb5fbaf0624"
- }
- }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}
diff --git a/lectures/chap3/lab/sammenligning_av_strenger.ipynb b/lectures/chap3/lab/sammenligning_av_strenger.ipynb
index c8a77f6cbefb99b378792c9b1c98e6bbaadb2e5c..4c380834f563f2441ddc583848df91e04833c141 100644
--- a/lectures/chap3/lab/sammenligning_av_strenger.ipynb
+++ b/lectures/chap3/lab/sammenligning_av_strenger.ipynb
@@ -329,180 +329,6 @@
"metadata": {},
"outputs": [],
"source": []
- },
- {
- "cell_type": "markdown",
- "metadata": {
- "deletable": false,
- "editable": false,
- "heading_collapsed": true,
- "run_control": {
- "frozen": true
- }
- },
- "source": [
- "#### Hint (trykk pil til venstre)"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {
- "deletable": false,
- "editable": false,
- "hidden": true,
- "run_control": {
- "frozen": true
- }
- },
- "source": [
- "Om man ønsker å sortere navnene alfabetisk, kan man bruke `<` eller `>`. For navnene Ola og Ole vil Ole bli sett på som større enn Ola, siden `'e'` er representert av et større tall enn `'a'`. "
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {
- "deletable": false,
- "editable": false,
- "heading_collapsed": true,
- "run_control": {
- "frozen": true
- }
- },
- "source": [
- "#### Bruk av æ, ø og å i oppgave b)"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {
- "deletable": false,
- "editable": false,
- "hidden": true,
- "run_control": {
- "frozen": true
- }
- },
- "source": [
- "I Python3 brukes Unicode-tabellen til representasjon av bokstaver, og mens verdiene for bokstavene a-z er de samme som i ASCII-tabellen, er det litt annerledes for æ, ø og å. Disse kommer i en litt annen rekkefølge enn vi er vant med og har følgende verdier:\n",
- "\n",
- "\n",
- "`'å'` - 229 \n",
- "`'Å'` - 197 \n",
- "`'æ'` - 230 \n",
- "`'Æ'` - 198 \n",
- "`'ø'` - 248 \n",
- "`'Ø'` - 216 \n",
- "\n",
- "\n",
- "Dette kan medføre at koden i oppgave b) ikke alltid vil gi korrekt svar, siden 'å' kommer før 'æ' og 'ø' i ASCII-tabellen, men etter 'æ' og 'ø' i det norske alfabetet.\n",
- "\n",
- "(Frivillig) Om du ønsker kan du endre på koden din slik at dette blir tatt hensyn til. Her må du nok benytte deg av stoff som ikke er gjennomgått enda."
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {
- "deletable": false,
- "editable": false,
- "run_control": {
- "frozen": true
- }
- },
- "source": [
- "## c)"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {
- "deletable": false,
- "editable": false,
- "run_control": {
- "frozen": true
- }
- },
- "source": [
- "Hva vil kodesnuttene under skrive ut til skjerm?\n",
- "\n",
- "```python\n",
- "#Kodesnutt 1:\n",
- "if 'k' < 'b':\n",
- " print('k er mindre enn b')\n",
- "else:\n",
- " print('k er større enn b')\n",
- " \n",
- " \n",
- "#Kodesnutt 2:\n",
- "ny = \"New York\"\n",
- "la = \"Los Angeles\"\n",
- " \n",
- "if ny < la:\n",
- " print(ny)\n",
- " print(la)\n",
- "else:\n",
- " print(la)\n",
- " print(ny)\n",
- " \n",
- " \n",
- "#Kodesnutt 3:\n",
- "d1 = \"DRuEr\"\n",
- "d2 = \"drUer\"\n",
- "if d1.lower() < d2.lower():\n",
- " print(d1)\n",
- " print(d2)\n",
- "else:\n",
- " print(d2.lower())\n",
- "```\n",
- "\n",
- "**Svar for kodesnutt 1 (Trykk på teksten under for å skrive):**"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "Svar 1: < dobbeltklikk her>"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {
- "deletable": false,
- "editable": false,
- "run_control": {
- "frozen": true
- }
- },
- "source": [
- "___Svar for Kodesnutt 2:___"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "Svar 2: < dobbeltklikk her>"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {
- "deletable": false,
- "editable": false,
- "run_control": {
- "frozen": true
- }
- },
- "source": [
- "___Svar for kodesnutt 3:___"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "Svar 3: < dobbeltklikk her>"
- ]
}
],
"metadata": {