diff --git a/lectures/chap3/lab/lf/gjett_tallet.ipynb b/lectures/chap3/lab/lf/gjett_tallet.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..2a10a7ae343977ea0827315073409451f32a37c6
--- /dev/null
+++ b/lectures/chap3/lab/lf/gjett_tallet.ipynb
@@ -0,0 +1,207 @@
+{
+ "cells": [
+ {
+ "attachments": {},
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "# Gjettelek\n",
+ "\n",
+ "**Læringsmål:**\n",
+ "\n",
+ "* Løkker\n",
+ "* Betingelser\n",
+ "* Innebygde funksjoner\n",
+ "\n",
+ "\n",
+ "I denne oppgaven skal du lage en funnksjon som genererer et tilfeldig heltall i et gitt intervall, og deretter lar brukeren gjette på hvilket tall dette er. Dette bør gjøres ved bruk av løkker. Hele funksjonen skrives i ett kodevindu, altså under deloppgave a).\n",
+ "\n",
+ "\n",
+ "\n",
+ "I denne oppgaven må du benytte deg av biblioteket random. Derfor skal koden din starte med `import random`. \n",
+ "Eksempel på bruk av random.randint()\n",
+ "\n",
+ "```python\n",
+ "tilfeldigTall = random.randint(1,50) #gir deg et tilfeldig tall fra og med 1, til og med 50\n",
+ "tall = random.randint(a,b) #gir deg et tilfeldig tall mellom a og b. (Fra og med a, til og med b)\n",
+ "```\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "**a)** Be brukeren om å velge en nedre og en øvre grense for tall han eller hun skal gjette på. Lagre disse to opplysningene i to variabler.\n",
+ "\n",
+ "***Skriv koden din her:***"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2019-07-02T14:02:57.358551Z",
+ "start_time": "2019-07-02T14:02:57.352636Z"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Oppgi en nedre grense: 1\n",
+ "Oppgi en øvre grense: 50\n",
+ "Make a guess? 25\n",
+ "The correct number is higher\n",
+ "Make a guess? 37\n",
+ "The correct number is higher\n",
+ "Make a guess? 45\n",
+ "The correct number is higher\n",
+ "Make a guess? 49\n",
+ "The correct number is lower\n",
+ "Make a guess? 47\n",
+ "Correct, well done! \n"
+ ]
+ }
+ ],
+ "source": [
+ "# Svar\n",
+ "import random\n",
+ "a = int(input(\"Oppgi en nedre grense: \"))\n",
+ "b = int(input(\"Oppgi en øvre grense: \"))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "**b)** Lag en funksjon, *gjettelek(a,b)* som tar inn verdiene i deloppgave a). Lag så en variabel tilfeldigTall i som genererer et tilfeldig tall i intervallet mellom den øvre og den nedre grensen som brukeren har satt. Fortsett å skriv i samme felt som i oppgave a."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# Svar\n",
+ "import random\n",
+ "a = int(input(\"Oppgi en nedre grense: \"))\n",
+ "b = int(input(\"Oppgi en øvre grense: \"))\n",
+ "\n",
+ "\n",
+ "def gjettelek(a, b):\n",
+ " tilfeldig_tall = random.randint(a, b)\n",
+ " print(\"Random number: \" + tilfeldig_tall)\n",
+ "\n",
+ "\n",
+ "gjettelek(a, b)\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "**c)** Skriv en while-løkke som kjører så lenge brukeren ikke har gjettet riktig svar. Brukeren skal få tilbakemelding for hvert gjett om han eller hun gjettet for lavt, for høyt eller riktig. Fortsett å skriv i samme felt som i oppgave a og b.\n",
+ "\n",
+ "Eksempel på kjøring:\n",
+ "```python\n",
+ "Gi en nedre grense for det tilfeldige tallet: 1\n",
+ "Gi en øvre grense for det tilfeldige tallet: 100\n",
+ "Make a guess 50\n",
+ "The correct number is lower\n",
+ "Make a guess 25\n",
+ "The correct Number is higher\n",
+ "Make a guess 37\n",
+ "The correct number is lower\n",
+ "Make a guess 32\n",
+ "You guessed correct!```"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# Svar \n",
+ "import random\n",
+ "a = int(input(\"Oppgi en nedre grense: \"))\n",
+ "b = int(input(\"Oppgi en øvre grense: \"))\n",
+ "\n",
+ "\n",
+ "def gjettelek(a, b):\n",
+ " tilfeldig_tall = random.randint(a, b)\n",
+ " guess = int(input(\"Make a guess? \"))\n",
+ " while guess != tilfeldig_tall:\n",
+ " if tilfeldig_tall > guess:\n",
+ " print(\"The correct number is higher\")\n",
+ " else:\n",
+ " print(\"The correct number is lower\")\n",
+ " guess = int(input(\"Make a guess? \"))\n",
+ " print(\"Correct, well done! \")\n",
+ "\n",
+ "\n",
+ "gjettelek(a, b)"
+ ]
+ }
+ ],
+ "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/lf/intro_til_lokker.ipynb b/lectures/chap3/lab/lf/intro_til_lokker.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..cd93db2f19a7af504e3f1439e711ebc4800c349a
--- /dev/null
+++ b/lectures/chap3/lab/lf/intro_til_lokker.ipynb
@@ -0,0 +1,378 @@
+{
+ "cells": [
+ {
+ "attachments": {},
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "# Intro til løkker\n",
+ "\n",
+ "**Læringsmål:**\n",
+ "\n",
+ "* Løkker\n",
+ "* Velge egnet løkkekonstruksjon (for eller while) etter behov\n",
+ "\n",
+ "\n",
+ "I denne oppgaven skal du lære å skrive kode hvor handlinger repeteres ved hjelp av løkker."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "heading_collapsed": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "### Intro om løkker"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "hidden": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Noe av det datamaskiner er best på, er gjentatte handlinger i høyt tempo. Dette er også et vanlig behov.\n",
+ "* Et firma skal utbetale lønn til alle sine ansatte hver måned.\n",
+ "* Et digitalt eksamenssystem skal vise spørsmål til, og motta svar fra, alle studenter som tar eksamen. \n",
+ "* Et system som styrer industrielt produksjonsutstyr skal motta informasjon fra en rekke sensorer hvert eneste sekund, om trykk, temperatur, osv., og gjøre handlinger basert på verdiene.\n",
+ "* Utstyr på et sykehus skal overvåke pasienters hjerterytme osv. sekund for sekund, og kunne slå alarm hvis noe er unormalt.\n",
+ "* Utstyr for opptak av musikk skal kunne sample lyden tusenvis eller millionvis av ganger per sekund.\n",
+ "* Et program for å vise video på en mobilskjerm må likeledes kunne oppdatere fargen i hver piksel på skjermen mange ganger i sekundet.\n",
+ "\n",
+ "Du har kanskje erfaring med bruk av regneark? Der er det vanlig hvis man skal bruke samme formel på alle radene i en tabell at man **kopierer** formelen nedover. \n",
+ "Å kopiere samme kodesetning flere ganger er mulig i Python også, men bare praktisk hvis antall repetisjoner er lavt og kjent på forhånd.\n",
+ "Eksemplet nedenfor viser et slikt tilfelle, hvor en kodelinje er gjentatt 3 ganger."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "hidden": true
+ },
+ "outputs": [],
+ "source": [
+ "print(\"Hipp\")\n",
+ "print(\"Hipp\")\n",
+ "print(\"Hipp\")\n",
+ "print(\"Hurra!\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "hidden": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Samme utskrift kan oppnås med løkke:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "hidden": true
+ },
+ "outputs": [],
+ "source": [
+ "for i in range(3):\n",
+ " print(\"Hipp!\")\n",
+ "print(\"Hurra!\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "hidden": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "**for <variabel> in range(3)**: gjør at påfølgende kodesetning(er) med innrykk blir repetert 3 ganger.\n",
+ "\n",
+ "print(\"Hurra!\") som ikke har innrykk, er ikke del av løkka, og vil derfor bare bli utført en gang, etter at løkka er ferdig.\n",
+ "\n",
+ "Det fins to typer løkker i Python, **for**-løkke som vist over, og **while**-løkke. Vi kunne ha klart oss med bare while-løkke, eksemplet ville da ha blitt:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "hidden": true
+ },
+ "outputs": [],
+ "source": [
+ "i = 0\n",
+ "while i < 3:\n",
+ " print(\"Hipp\")\n",
+ " i = i + 1 # eller: i += 1\n",
+ "print(\"Hurra!\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "hidden": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "while er noe mer tungvint her, vi må eksplisitt øke i med 1 for hver runde, som er implisitt i for-løkka. \n",
+ "\n",
+ "while-løkka vil fortsette så lenge betingelsen (her: i < 3) er sann, den vil derfor kjøre når i er 0, 1, 2, men deretter stoppe når i blir 3. Som i for-løkka gjør dette at Hipp skrives 3 ganger.\n",
+ "\n",
+ "I andre situasjoner er while-løkke derimot bedre enn for-løkke. Generelt gjelder følgende:\n",
+ "\n",
+ "* **for-løkke** egner seg når vi har et **kjent antall repetisjoner**. Eksempel fra den virkelige verden: hver måned skal et firma utbetale lønn til alle sine ansatte. Firmaet og dets datasystem vet (forhåpentligvis) hvor mange ansatte det har, dermed har løkka \"for alle ansatte, beregn og utbetal lønn\" et kjent antall repetisjoner når lønningsdagen kommer.\n",
+ "* **while-løkke** er derimot nødvendig hvis **maks antall repetisjoner er uvisst** når løkka starter og vi først finner ut underveis når løkka skal avsluttes. F.eks.\n",
+ " * brukeren bestemmer underveis, f.eks. \"Try again\" / \"Quit\" - vi aner ikke hvor mange ganger brukeren vil forsøke. Eller et program for lydopptak: løkka som sampler lyden, starter når brukeren klikker på \"Record\" og skal fortsette til brukeren trykker \"Stop\" - og vi aner ikke hvor mange sekunder eller minutter det vil ta.\n",
+ " * numerisk løsning av matematiske likninger, hvor stoppkriteriet er at vi skal ha nådd en viss presisjon. Hvis vi ikke aner på forhånd hvor mange iterasjoner som trengs for å nå denne presisjonen, vil while-løkke være best.\n",
+ " * produksjonsutstyr i en fabrikk skal kjøre som normalt med mindre sensordata indikerer en krisesituasjon, og da gå over til en alternativ nødprosedyre. Vi aner ikke om det går tusen sekunder, eller millioner av sekunder... kanskje inntreffer krisesituasjonen slett ikke. Dermed vil antall repetisjoner av løkka for normal oppførsel være ukjent når den starter, som tilsier while-løkke.\n",
+ "\n",
+ "Under er forskjellen vist ved to ytterligere varianter av Hurra-programmet vårt. Kopier gjerne denne koden inn i editoren din og kjør den for å se hvordan den virker."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "hidden": true
+ },
+ "outputs": [],
+ "source": [
+ "# hvis brukeren skal bestemme antall på forhånd:\n",
+ "antall = int(input(\"Hvor mange Hipp?\" ))\n",
+ "for i in range(antall):\n",
+ " print(\"Hipp\")\n",
+ "print(\"Hurra!\")\n",
+ " \n",
+ "# hvis brukeren skal bestemme seg for å slutte underveis:\n",
+ "print(\"Slå Enter direkte etter Hipp for å legge til flere Hipp,\")\n",
+ "print(\"eller mellomrom så Enter for å avslutte: \")\n",
+ "while input(\"Hipp\") == \"\":\n",
+ " pass\n",
+ "print(\"Hurra!\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "hidden": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Linje 1-5 viser en variant med **for**-løkke. Siden brukeren gir inn på forhånd antall Hipp som ønskes, er **antall repetisjoner kjent**, og **for-løkke enklest.**\n",
+ "\n",
+ "Linje 7-12 viser derimot en variant hvor brukeren bestemmer underveis i løkka om vi skal fortsette eller avslutte, da er det best med **while** siden **antall repetisjoner er ukjent.**\n",
+ "\n",
+ " * brukeren velger å fortsette ved å trykke Enter direkte etter Hipp; dette vil gi en helt tom streng \"\" som resultat, slik at betingelsen i while vil være sann. Så lenge den er sann, fortsetter løkka med å gjøre ny input() som gjør at ledeteksten \"Hipp\" kommer på skjermen på ny.\n",
+ " \n",
+ " * brukeren velger å avslutte ved å skrive inn et blankt tegn og deretter slå Enter. Dette vil gi strengen \" \" som er forskjellig fra \"\", da blir betingelsen usann, og løkka avsluttes, og programmet går videre med å skrive \"Hurra\".\n",
+ "\n",
+ "I while-løkka er den eneste handlingen vi ønsker å utføre, den input() og sammenligning som står i betingelsen. Da trenger vi egentlig ingen innmat. Man er imidlertid nødt til å ha minst en setning inni ei løkke.\n",
+ "Derfor **pass**, som er et beskyttet ord i Python for å gjøre ingenting. De fleste løkker vil ha mer kompliserte gjøremål og derfor også trenge en eller flere setninger inni som gjør noe."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "## a)\n",
+ "Koden under viser en funksjon som repeterer en for-løkke 3 ganger. For hver runde blir brukeren bedt om å beskrive seg selv med et adjektiv, hvorpå maskinen disser brukeren ved å si at den er snillere, smartere etc.\n",
+ "\n",
+ "(Trikset her er bare å legge til \"ere\" bak adjektivet, så det vil ikke bli grammatisk korrekt for adjektiv som bøyes annerledes.)\n",
+ "\n",
+ "***Kjør koden for å se hvordan den virker. Endre så koden slik at programmet først spør brukeren hvor mange repetisjoner som ønskes, og deretter utfører programmet med ønsket antall repetisjoner av løkka.***\n",
+ "\n",
+ "Eksempel på kjøring:\n",
+ "\n",
+ "```python \n",
+ "Hvor mange adjektiv vil du gi? 2\n",
+ "Beskriv deg selv med et adjektiv? snill\n",
+ "Hah, du snill!? Jeg er mye snillere!\n",
+ "Beskriv deg selv med et adjektiv? ond\n",
+ "Hah, du ond!? Jeg er mye ondere!\n",
+ "Takk for nå!\n",
+ "```"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2019-07-02T12:12:32.923751Z",
+ "start_time": "2019-07-02T12:12:22.141490Z"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "def diss_brukeren_n_ganger(n):\n",
+ "\n",
+ " for i in range(n):\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",
+ "n = int(input(\"Hvor mange adjektiv vil du gi? \"))\n",
+ "diss_brukeren_n_ganger(n)\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "hidden": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "**Hint:** I stedet for tallet 3 i for-løkken, må verdien på variablen n samsvare med antall iterasjoner som skal kjøres. I tillegg må verdien på n konverteres til et heltall (*int*)."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "## b)\n",
+ "Koden under viser en while-løkke som utfører samme type brukerdialog som i (a), med 3 repetisjoner. Kjør den for å se hvordan det virker. **Endre nå funksjonen diss_brukeren_gjentatte_ganger() så løkka ikke kjører akkurat 3 ganger, men så mange ganger brukeren vil**, hvor brukeren kan bestemme dette underveis ved å gi et tomt svar (dvs. bare slå Enter) for å slutte. Da vil input()-setningen resultere i en tom streng, \"\".\n",
+ "\n",
+ "Eksempel på kjøring:\n",
+ "\n",
+ "```python\n",
+ "Slå Enter uten å skrive noe når du vil avslutte.\n",
+ "Beskriv deg selv med et adjektiv? snill\n",
+ "Hah, du snill!? Jeg er mye snillere!\n",
+ "Beskriv deg selv med et adjektiv? smart\n",
+ "Hah, du smart!? Jeg er mye smartere!\n",
+ "Beskriv deg selv med et adjektiv? flittig\n",
+ "Hah, du flittig!? Jeg er mye flittigere!\n",
+ "Beskriv deg selv med et adjektiv?\n",
+ "Takk for nå!\n",
+ "```\n",
+ "\n",
+ "Fjerde gang spørsmålet om adjektiv ble stilt, slo brukeren her bare Enter uten å skrive inn noen tegn, da avsluttet løkka og programmet gikk videre med å skrive \"Takk for nå\""
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Hah, du !? Jeg er mye ere!\n",
+ "Takk for nå!\n"
+ ]
+ }
+ ],
+ "source": [
+ "def diss_brukeren_gjentatte_ganger():\n",
+ " adj = \" \"\n",
+ " while adj != \"\":\n",
+ " adj = input(\"Beskriv deg selv med et adjektiv? \")\n",
+ " print(\"Hah, du\", adj + \"!? Jeg er mye\", adj + \"ere!\")\n",
+ " print(\"Takk for nå!\")\n",
+ "\n",
+ "\n",
+ "diss_brukeren_gjentatte_ganger()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "hidden": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "**Hint:**\n",
+ "I eksemplet måtte vi sette i = 0 før vi kan utføre testen i < 3 i while-løkken. Hvis ikke i hadde fått noen verdi, ville testen gi feilmelding. Likeledes, hvis du skal teste på at adj != \"\" må adj ha fått en verdi før denne testen skjer. Altså må du gjøre den første input til adj før while-løkka starter.\n",
+ "\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å."
+ ]
+ }
+ ],
+ "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.11.2"
+ },
+ "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/lf/lab-3.md b/lectures/chap3/lab/lf/lab-3.md
new file mode 100644
index 0000000000000000000000000000000000000000..9fc70457e4740c1d2855a2f24603ad9d7c749b72
--- /dev/null
+++ b/lectures/chap3/lab/lf/lab-3.md
@@ -0,0 +1,12 @@
+# Lab-3
+
+### Læringsutbytte
+
+* Sammenligne strenger
+* Velge egnet løkkekonstruksjon (for eller while) etter behov
+
+### Læringsaktiviteter
+
+* [Sammenligning av strenger](sammenligning_av_strenger.ipynb)
+* [Introduksjon til løkker](intro_til_lokker.ipynb)
+* [Gjettelek](gjett_tallet.ipynb)
diff --git a/lectures/chap3/lab/lf/sammenligning_av_strenger.ipynb b/lectures/chap3/lab/lf/sammenligning_av_strenger.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..b7f084e6402085860410f3bafb6558c65b444ed4
--- /dev/null
+++ b/lectures/chap3/lab/lf/sammenligning_av_strenger.ipynb
@@ -0,0 +1,396 @@
+{
+ "cells": [
+ {
+ "attachments": {},
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "# Sammenligning av strenger\n",
+ "\n",
+ "**Læringsmål:**\n",
+ "- Betingelser\n",
+ "- Kodeforståelse\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "heading_collapsed": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "## Generelt om sammenligning av strenger\n",
+ "Trykk på pilen til venstre for å lese"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "hidden": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "\n",
+ "Når man sammenligner to strenger i Python vil strengene sammenlignes karakter for karakter. F.eks. vil et program som sammenligner strengene `\"Ola\"` og `\"Ole\"` og sjekker om de er like, først sammenligne `'O'` mot `'O'`, så `'l'` mot `'l'`, og til slutt `'a'` mot `'e'`. Det er først ved sammenligningen av `'a'` mot `'e'` at det vil bli returnert `False`."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2019-07-01T13:28:36.030253Z",
+ "start_time": "2019-07-01T13:28:36.020435Z"
+ },
+ "hidden": true
+ },
+ "outputs": [],
+ "source": [
+ "a = \"Ola\"\n",
+ "b = \"Ole\"\n",
+ " \n",
+ "print(\"Sammenligner\", a, \"og\", b)\n",
+ "if a == b:\n",
+ " print(\"Navnene er like\")\n",
+ "else:\n",
+ " print(\"Navnene er IKKE like\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "hidden": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Om man derimot sammenligner navnene Markus og Marcus, vil testen av betingelsen returnere `False` når `'k'` blir sammenlignet med `'c'`. Det betyr at `'u'` mot `'u'` og `'s'` mot `'s'` ikke blir sjekket."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2019-07-01T13:30:06.268914Z",
+ "start_time": "2019-07-01T13:30:06.261563Z"
+ },
+ "hidden": true
+ },
+ "outputs": [],
+ "source": [
+ "a = \"Markus\"\n",
+ "b = \"Marcus\"\n",
+ " \n",
+ "print(\"Sammenligner\", a, \"og\", b)\n",
+ "if a == b:\n",
+ " print(\"Navnene er like\")\n",
+ "else:\n",
+ " print(\"Navnene er IKKE like\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "hidden": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Prøv gjerne ut koden over med andre verdier selv. Andre eksempler på kjøring kan være:\n",
+ "```python\n",
+ "# a = \"Ann\", b = \"Anne\"\n",
+ "Sammenligner Ann og Anne\n",
+ "Navnene er IKKE like\n",
+ "```\n",
+ "```python \n",
+ "# a = \"Anders\", b = \"Anders\"\n",
+ "Sammenligner Anders og Anders\n",
+ "Navnene er like\n",
+ "```\n",
+ " \n",
+ "```python\n",
+ "# a = \"Anders\", b = \"anders\"\n",
+ "Sammenligner Anders og anders\n",
+ "Navnene er IKKE like\n",
+ "```\n",
+ "\n",
+ "Som du ser i siste kjøring, skiller Python mellom store og små bokstaver, og en stor A er ikke det samme som en liten a. Dette kommer av at tegnene i strengene lagres som tall, og det er disse tallene som sammenlignes. I ASCII er karakterene A til Z representert med tallene 65 til 90, og karakterene a til z er representert med tallene 97 til 122."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "## a)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Du skal nå lage et program som sammenligner to matvarer, og sjekker om de er like. Det skal ikke spille noen rolle om matvarenavnene som sendes inn har store eller små bokstaver, dvs. at `\"druer\"` og `\"DrUer\"` skal regnes som like matvarer (se Hint). Det trengs ikke å ta hensyn til entall og flertall, dvs. at `\"druer\"` og `\"drue\"` regnes som to forskjellige matvarer.\n",
+ "\n",
+ "**Eksempel på kjøring:**\n",
+ "\n",
+ "```\n",
+ "Sammenligner druer og DrUer\n",
+ "Det er samme matvare\n",
+ "```\n",
+ "\n",
+ "```\n",
+ "Sammenligner druer og drue\n",
+ "Dette er to forskjellige matvarer\n",
+ "```\n",
+ "\n",
+ "```\n",
+ "Sammenligner TomAT og ToMat\n",
+ "Det er samme matvare\n",
+ "``` \n",
+ "\n",
+ "```\n",
+ "Sammenligner tomat og potet\n",
+ "Dette er to forskjellige matvarer\n",
+ "```\n",
+ "\n",
+ "___Skriv din kode her:___"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# Svar\n",
+ "a = \"druer\"\n",
+ "b = \"DrUer\"\n",
+ "c = \"drue\"\n",
+ " \n",
+ "print(\"Sammenligner\",a,\"og\",b)\n",
+ "if a.lower() == b.lower():\n",
+ " print(\"Det er samme matvare\")\n",
+ "else:\n",
+ " print(\"Dette er to forskjellige matvarer\")\n",
+ "\n",
+ "print(\"Sammenligner\",a,\"og\",c)\n",
+ "if a.lower() == c.lower():\n",
+ " print(\"Det er samme matvare\")\n",
+ "else:\n",
+ " print(\"Dette er to forskjellige matvarer\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2019-07-01T13:52:20.851486Z",
+ "start_time": "2019-07-01T13:52:20.846135Z"
+ },
+ "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": [
+ "`str.lower()` returnerer en kopi av strengen bestående av små bokstaver.\n",
+ "\n",
+ "Dvs., om du har en variabel `a = \"DrUer\"`, vil `a.lower()` gi strengen `\"druer\"`. Men husk, `a.lower()` endrer ikke på variabelen `a`, så man må enten lage en ny variabel `b = a.lower()` og bruke variabelen `b` i sjekken, eller så kan man bruke `a.lower()` direkte i sjekken i stedet for `a`.\n",
+ "\n",
+ "Eksempel som viser bruk av `str.lower()`:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "hidden": true
+ },
+ "outputs": [],
+ "source": [
+ "a = \"DrUer\"\n",
+ " \n",
+ "print(a) #Output: \"DrUer\"\n",
+ "a.lower() #retunerer strengen \"druer\", men endrer ikke på variabelen a\n",
+ "print(a) #Output: \"DrUer\"\n",
+ "print(a.lower()) #Output: \"druer\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "heading_collapsed": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "#### Fremgangsmåte"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "hidden": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "1. Lag to variabler (`a` og `b`) som representerer hver sin streng.\n",
+ "2. Skriv hvilke variabler du sammenligner ut til skjerm.\n",
+ "3. Bruk en if-else-setning med betingelsen `a.lower() == b.lower()` for å sammenligne strengene, og skriv ut om det er samme vare eller to forskjellige varer til skjerm."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "## b)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "I denne oppgaven skal du lage et program som tar inn to navn og sorterer dem i alfabetisk rekkefølge. Du trenger ikke ta hensyn til små og store bokstaver i denne oppgaven.\n",
+ "\n",
+ "**Eksempel på kjøring:**\n",
+ "```\n",
+ "Første navn: Ole\n",
+ "Andre navn: Ola\n",
+ "Under følger navnene i alfabetisk rekkefølge:\n",
+ "Ola\n",
+ "Ole\n",
+ "```\n",
+ "\n",
+ "```\n",
+ "Første navn: Bob Bernt\n",
+ "Andre navn: Bob Arne\n",
+ "Under følger navnene i alfabetisk rekkefølge:\n",
+ "Bob Arne\n",
+ "Bob Bernt\n",
+ "```\n",
+ "\n",
+ "___Skriv din kode her:___"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "navn1 = input(\"Første navn: \")\n",
+ "navn2 = input(\"Andre navn: \")\n",
+ " \n",
+ "print(\"Under følger navnene i alfabetisk rekkefølge:\")\n",
+ "if navn1 < navn2: # > og < sjekker alfabetisk rekkefølge\n",
+ " print(navn1)\n",
+ " print(navn2)\n",
+ "else:\n",
+ " print(navn2)\n",
+ " print(navn1)\n"
+ ]
+ }
+ ],
+ "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.11.2"
+ },
+ "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
+}