From bffaa3a1ccb0319d5c329c2ca3119c7ea4388f17 Mon Sep 17 00:00:00 2001 From: olerid <olerid02@gmail.com> Date: Mon, 25 Sep 2023 16:42:58 +0200 Subject: [PATCH] =?UTF-8?q?La=20til=20=C3=B8ving=205=20og=20LF=20til=20?= =?UTF-8?q?=C3=B8ving=202?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../Oving2/Andregradsligning - lf.ipynb | 106 ++++ .../Oving2/Betingede funksjoner.ipynb | 74 +++ .../Oving2/Billettpriser og rabatter lf.ipynb | 115 ++++ Losningsforslag/Oving2/Epletigging lf.ipynb | 98 ++++ .../Oving2/Forbrytelse og straff lf.ipynb | 240 +++++++++ ...e operatorer og logiske uttrykk - lf.ipynb | 61 +++ .../Sammenligning av strenger - lf.ipynb | 66 +++ Losningsforslag/Oving2/Sjakkbrett - lf.ipynb | 139 +++++ Losningsforslag/Oving2/Skatteetaten lf.ipynb | 98 ++++ .../Oving2/Tekstbasert spill lf.ipynb | 57 ++ ...yper if-setninger l\303\270sning lf.ipynb" | 102 ++++ .../Oving2/\303\205rstider - lf.ipynb" | 75 +++ Ovinger/Oving5/Chattebot.ipynb | 243 +++++++++ Ovinger/Oving5/Gangetabell og lister.ipynb | 250 +++++++++ Ovinger/Oving5/Generelt om lister.ipynb | 504 ++++++++++++++++++ Ovinger/Oving5/Intro til numpy-arrays.ipynb | 299 +++++++++++ Ovinger/Oving5/Kodeforstaelse.ipynb | 466 ++++++++++++++++ Ovinger/Oving5/Lett og blandet.ipynb | 283 ++++++++++ Ovinger/Oving5/Lister og lokker.ipynb | 385 +++++++++++++ Ovinger/Oving5/Lotto.ipynb | 435 +++++++++++++++ Ovinger/Oving5/Matriseaddisjon.ipynb | 207 +++++++ Ovinger/Oving5/Tannfeen.ipynb | 183 +++++++ Ovinger/Oving5/Teoridelen paa eksamen.ipynb | 192 +++++++ Ovinger/Oving5/Vektorer.ipynb | 457 ++++++++++++++++ Ovinger/Oving5/_Oving5.ipynb | 86 +++ 25 files changed, 5221 insertions(+) create mode 100644 Losningsforslag/Oving2/Andregradsligning - lf.ipynb create mode 100644 Losningsforslag/Oving2/Betingede funksjoner.ipynb create mode 100644 Losningsforslag/Oving2/Billettpriser og rabatter lf.ipynb create mode 100644 Losningsforslag/Oving2/Epletigging lf.ipynb create mode 100644 Losningsforslag/Oving2/Forbrytelse og straff lf.ipynb create mode 100644 Losningsforslag/Oving2/Logiske operatorer og logiske uttrykk - lf.ipynb create mode 100644 Losningsforslag/Oving2/Sammenligning av strenger - lf.ipynb create mode 100644 Losningsforslag/Oving2/Sjakkbrett - lf.ipynb create mode 100644 Losningsforslag/Oving2/Skatteetaten lf.ipynb create mode 100644 Losningsforslag/Oving2/Tekstbasert spill lf.ipynb create mode 100644 "Losningsforslag/Oving2/Ulike typer if-setninger l\303\270sning lf.ipynb" create mode 100644 "Losningsforslag/Oving2/\303\205rstider - lf.ipynb" create mode 100644 Ovinger/Oving5/Chattebot.ipynb create mode 100644 Ovinger/Oving5/Gangetabell og lister.ipynb create mode 100644 Ovinger/Oving5/Generelt om lister.ipynb create mode 100644 Ovinger/Oving5/Intro til numpy-arrays.ipynb create mode 100644 Ovinger/Oving5/Kodeforstaelse.ipynb create mode 100644 Ovinger/Oving5/Lett og blandet.ipynb create mode 100644 Ovinger/Oving5/Lister og lokker.ipynb create mode 100644 Ovinger/Oving5/Lotto.ipynb create mode 100644 Ovinger/Oving5/Matriseaddisjon.ipynb create mode 100644 Ovinger/Oving5/Tannfeen.ipynb create mode 100644 Ovinger/Oving5/Teoridelen paa eksamen.ipynb create mode 100644 Ovinger/Oving5/Vektorer.ipynb create mode 100644 Ovinger/Oving5/_Oving5.ipynb diff --git a/Losningsforslag/Oving2/Andregradsligning - lf.ipynb b/Losningsforslag/Oving2/Andregradsligning - lf.ipynb new file mode 100644 index 0000000..0fe24a9 --- /dev/null +++ b/Losningsforslag/Oving2/Andregradsligning - lf.ipynb @@ -0,0 +1,106 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "import math\n", + "\n", + "def andregradsligning(a, b, c):\n", + " d = b**2 - 4*a*c\n", + " streng = \"\" \n", + "\n", + " #Kode for Ã¥ fÃ¥ rett fortegn/unngÃ¥ dobbelt fortegn i utskrift. MÃ¥ ikke ha dette.\n", + " if b<0:\n", + " if c<0:\n", + " streng += f\"Andregradsligningen {a}x^2 - {-b}x - {-c} har\"\n", + " else:\n", + " streng += f\"Andregradsligningen {a}x^2 - {-b}x + {c} har\"\n", + " else:\n", + " if c<0:\n", + " streng += f\"Andregradsligningen {a}x^2 + {b}x - {-c} har\"\n", + " else:\n", + " streng += f\"Andregradsligningen {a}x^2 + {b}x + {c} har\"\n", + "\n", + " if d < 0.0:\n", + " streng += \" to imaginære løsninger.\"\n", + " elif d > 0.0:\n", + " x1 = (-b+math.sqrt(d))/(2*a)\n", + " x2 = (-b-math.sqrt(d))/(2*a)\n", + " streng += f\" de to reelle løsningene {round(x1, 2)} og {round(x2, 2)}.\"\n", + " else:\n", + " x = -b/(2*a)\n", + " streng += f\" en reell dobbeltrot {round(x, 2)}.\"\n", + " \n", + " return streng\n", + "\n", + "#Stjerne-oppgaven:\n", + "def andregradsligning_b(a, b, c):\n", + " d = b**2 - 4*a*c\n", + " streng = \"\"\n", + " \n", + " #Kode for Ã¥ fÃ¥ rett fortegn/unngÃ¥ dobbelt fortegn i utskrift. MÃ¥ ikke ha dette.\n", + " if b<0:\n", + " if c<0:\n", + " streng += f\"Andregradsligningen {a}x^2 - {-b}x - {-c} har\"\n", + " else:\n", + " streng += f\"Andregradsligningen {a}x^2 - {-b}x + {c} har\"\n", + " else:\n", + " if c<0:\n", + " streng += f\"Andregradsligningen {a}x^2 + {b}x - {-c} har\"\n", + " else:\n", + " streng += f\"Andregradsligningen {a}x^2 + {b}x + {c} har\"\n", + "\n", + " if d < 0.0:\n", + " streng += f\" de to reelle løsningene {round(x1, 2)} og {round(x2, 2)}.\"\n", + " elif d > 0.0:\n", + " if b <= 0:\n", + " x1 = (-b+math.sqrt(d))/(2*a)\n", + " x2 = c/(a*x1)\n", + " else:\n", + " x2 = (-b-math.sqrt(d))/(2*a)\n", + " x1 = c/(a*x2)\n", + " streng += f\" de to reelle løsningene {round(x1, 2)} og {round(x2, 2)}.\"\n", + " else:\n", + " x = -b/(2*a)\n", + " streng += f\" en reell dobbeltrot {round(x, 2)}.\"\n", + " return streng\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3.10.6 64-bit", + "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.10.6" + }, + "vscode": { + "interpreter": { + "hash": "aee8b7b246df8f9039afb4144a1f6fd8d2ca17a180786b69acc140d282b71a49" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Losningsforslag/Oving2/Betingede funksjoner.ipynb b/Losningsforslag/Oving2/Betingede funksjoner.ipynb new file mode 100644 index 0000000..f3ea1af --- /dev/null +++ b/Losningsforslag/Oving2/Betingede funksjoner.ipynb @@ -0,0 +1,74 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "statewide-stack", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy\n", + "import math" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "extreme-convert", + "metadata": {}, + "outputs": [], + "source": [ + "########### Oppgave a) ###########\n", + "\n", + "def f(x):\n", + " if x == 0:\n", + " return 0\n", + " return x**2 * math.sin(1/x)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "systematic-indicator", + "metadata": {}, + "outputs": [], + "source": [ + "########### Oppgave b) ###########\n", + "\n", + "def hastighet(tid):\n", + " if tid < 10:\n", + " return tid * 9.8\n", + " return 10 * 9.8" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ultimate-idaho", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "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.9.2" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/Losningsforslag/Oving2/Billettpriser og rabatter lf.ipynb b/Losningsforslag/Oving2/Billettpriser og rabatter lf.ipynb new file mode 100644 index 0000000..bfe77ac --- /dev/null +++ b/Losningsforslag/Oving2/Billettpriser og rabatter lf.ipynb @@ -0,0 +1,115 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 51, + "metadata": {}, + "outputs": [], + "source": [ + "#Oppgave a\n", + "def billettpris_d(dager):\n", + " if dager >= 14:\n", + " return \"Du kan fÃ¥ minipris: 199,-\"\n", + " else:\n", + " return \"For sent for minipris; fullpris 440,-\"\n", + "\n", + "#Oppgave b\n", + "def billettpris_b(dager, onsker_minipris):\n", + " if dager >= 14:\n", + " if onsker_minipris == 'J' or onsker_minipris == 'j':\n", + " return \"Du kan fÃ¥ minipris og ønsker dette, billettpris: 199,-\"\n", + " else:\n", + " return \"Du kan fÃ¥ minipris, men ønsker ikke det. Da tilbyr vi fullpris: 440,-\"\n", + " else:\n", + " return \"For sent for minipris; fullpris 440,-\"\n", + "\n", + "#Oppgave c\n", + "def billettpris_c(dager, onsker_minipris, status):\n", + " mini = True\n", + " pris = 440\n", + " \n", + " print(status)\n", + " if dager >= 14:\n", + " if onsker_minipris.upper() == 'J':\n", + " pris = 199\n", + " return f\"Du kan fÃ¥ minipris og ønsker dette: billettpris: {pris},-\"\n", + " else:\n", + " mini = False\n", + " \n", + " if status == 'barn':\n", + " pris = pris * 0.5\n", + " elif (status == 'militær' or status == 'student' or status == 'senior'):\n", + " pris = pris * 0.75\n", + " \n", + " if mini:\n", + " if pris < 440:\n", + " return f\"Du kan ikke fÃ¥ minipris. Du fÃ¥r rabatt grunnet at du er {status} - billetpris: {pris},-\"\n", + " else:\n", + " return f\"Du kan ikke fÃ¥ minipris, og mÃ¥ betale fullpris - billetpris: {pris},-\"\n", + " else:\n", + " if pris < 440:\n", + " return f\"Du kan fÃ¥ minipris, men ønsker ikke det. Du fÃ¥r rabatt grunnet at du er {status} - billetpris: {pris},-\"\n", + " else:\n", + " return f\"Du kan fÃ¥ minipris, men ønsker ikke det. Du mÃ¥ betale fullpris - billetpris: {pris},-\"\n", + "\n", + "#Oppgave d\n", + "def billettpris_d(dager, onsker_minipris, student, status):\n", + " pris = 440\n", + " mini = True\n", + " \n", + " if dager >= 14:\n", + " if onsker_minipris.upper() == 'J':\n", + " pris = 199\n", + " else:\n", + " mini = False\n", + "\n", + " if student.upper() == \"J\":\n", + " stud = True\n", + " else:\n", + " stud = False\n", + " \n", + " if pris == 199:\n", + " if stud:\n", + " pris = pris * 0.9\n", + " else:\n", + " if stud:\n", + " pris = pris * 0.75\n", + "\n", + " if status == 'barn':\n", + " pris = pris * 0.5\n", + " elif status == 'militær' or status == 'senior':\n", + " pris = pris * 0.75\n", + " \n", + " return f\"Du mÃ¥ betale: {pris},-\"\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "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.9.2" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Losningsforslag/Oving2/Epletigging lf.ipynb b/Losningsforslag/Oving2/Epletigging lf.ipynb new file mode 100644 index 0000000..34fc939 --- /dev/null +++ b/Losningsforslag/Oving2/Epletigging lf.ipynb @@ -0,0 +1,98 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "#Oppgave a\n", + "def test_gavmildhet_a(antall_epler, antall_gis_bort):\n", + " streng = \"Dette er et program for Ã¥ teste din sjenerøsitet.\\n\"\n", + "\n", + " if antall_epler == 0:\n", + " streng += \"Æsj, det sier du bare for Ã¥ slippe Ã¥ gi noe!\"\n", + " return streng\n", + " else:\n", + " streng += f\"Du er villig til Ã¥ gi bort {antall_gis_bort} epler.\\n\"\n", + " if antall_gis_bort < antall_epler / 2:\n", + " streng += \"Du beholder det meste for deg selv...\\n\"\n", + " else:\n", + " streng += \"Takk, det var snilt!\\n\"\n", + " streng += \"Du har nÃ¥\", har - gir, \"epler igjen.\"\n", + " return streng\n", + " \n", + "#Oppgave b\n", + "def test_gavmildhet_b(antall_epler, antall_gis_bort):\n", + " streng = \"Dette er et program for Ã¥ teste din sjenerøsitet.\\n\"\n", + "\n", + " if antall_epler == 0:\n", + " streng += \"Æsj, det sier du bare for Ã¥ slippe Ã¥ gi noe!\"\n", + " return streng\n", + " else:\n", + " streng += f\"Du er villig til Ã¥ gi bort {antall_gis_bort} epler.\\n\"\n", + " if antall_gis_bort < antall_epler / 2:\n", + " streng += \"Du beholder det meste for deg selv...\\n\"\n", + " else:\n", + " streng += \"Takk, det var snilt!\\n\"\n", + " rest = antall_epler - antall_gis_bort\n", + " if rest == 1:\n", + " tekst = \"eple\"\n", + " else:\n", + " tekst = \"epler\"\n", + " streng += f\"Du har nÃ¥ {rest} {tekst} igjen.\"\n", + " return streng\n", + " \n", + "#Oppgave c\n", + "def test_gavmildhet_c(antall_epler, antall_gis_bort):\n", + " streng = \"Dette er et program for Ã¥ teste din sjenerøsitet.\\n\"\n", + "\n", + " if antall_epler == 0:\n", + " streng += \"Æsj, det sier du bare for Ã¥ slippe Ã¥ gi noe!\"\n", + " return streng\n", + " else:\n", + " streng += f\"Du er villig til Ã¥ gi bort {antall_gis_bort} epler.\\n\"\n", + " if antall_gis_bort < antall_epler / 2:\n", + " streng += \"Du beholder det meste for deg selv...\\n\"\n", + " else:\n", + " streng += \"Takk, det var snilt!\\n\"\n", + " rest = antall_epler - antall_gis_bort\n", + " if rest >= 0:\n", + " if rest == 1:\n", + " tekst = \"eple\"\n", + " else:\n", + " tekst = \"epler\"\n", + " streng += f\"Du har nÃ¥ {rest} {tekst} igjen.\"\n", + " else:\n", + " streng += f\"Du har nÃ¥ 0 epler igjen. Gi med de {-rest} du skylder meg neste gang.\"\n", + " return streng" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3.10.6 64-bit", + "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.10.6" + }, + "vscode": { + "interpreter": { + "hash": "aee8b7b246df8f9039afb4144a1f6fd8d2ca17a180786b69acc140d282b71a49" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Losningsforslag/Oving2/Forbrytelse og straff lf.ipynb b/Losningsforslag/Oving2/Forbrytelse og straff lf.ipynb new file mode 100644 index 0000000..5abe823 --- /dev/null +++ b/Losningsforslag/Oving2/Forbrytelse og straff lf.ipynb @@ -0,0 +1,240 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "a)\n", + "\n", + "Syntaksfeilene i denne koden inkluderer et glemt kolon, at de to nederste linjene er innrykket feil, og flere feil med operatorer som skal være == (i stedet brukt =, ett sted = =)\n", + "\n", + "Korrigert kode blir:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# leser inn data\n", + "prom = float(input(\"Hvor stor var promillen? \"))\n", + "motor = input(\"Var farkosten en motorvogn? (j/n) \")\n", + "f = input(\"Var personen fører av vognen? (j/n) \")\n", + "leds = input(\"Var personen ledsager ved øvekjøring? (j/n) \")\n", + "n = input(\"Var det nødrett? (j/n) \")\n", + " \n", + "# vurderer straffbarhet\n", + "if prom < 0.2 and motor == \"j\" and f == \"j\" or leds == \"j\" and n == \"n\":\n", + " print(\"Det var straffbar promillekjøring.\")\n", + "else:\n", + " print(\"Ikke straffbart, ingen bot.\")\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "b) \n", + "\n", + "Den første feilen er at det stÃ¥r prom < 0.2, skulle ha stÃ¥tt prom > 0.2 nÃ¥r dette er i betingelsen for at det skal være straffbart.\n", + "\n", + "Den andre feilen er relatert til operatorpresedens. Slik den sammensatte betingelsen i if-setningen stÃ¥r i utgangspunktet, vil Python først evaluere prom>0.2 and motor==\"j\", deretter leds==\"j\" and n==\"n\", og sÃ¥ ta or mellom disse to (or gjøres sist fordi den har lavest presedens). Med or er det nok at en av sidene er sann, dermed kan programmet komme til konklusjon straffbar hvis mistenkte var ledsager og det ikke var nødrett - helt uavhengig av hvilken verdi som er gitt for promille. Den enkleste og mest intuitive mÃ¥ten Ã¥ fikse dette pÃ¥ er Ã¥ sette parentes rundt (f==\"j\" or leds==\"j\") siden disse hører sammen - enten var man fører eller ledsager i bilen. Parentesene vil gjøre at dette blir evaluert først og deretter kombinert med and med resten av betingelsen. Med and mÃ¥ begge sider være sanne." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# leser inn data\n", + "prom = float(input(\"Hvor stor var promillen? \"))\n", + "motor = input(\"Var farkosten en motorvogn? (j/n) \")\n", + "f = input(\"Var personen fører av vognen? (j/n) \")\n", + "leds = input(\"Var personen ledsager ved øvekjøring? (j/n) \")\n", + "n = input(\"Var det nødrett? (j/n) \")\n", + " \n", + "# vurderer straffbarhet\n", + "if prom > 0.2 and motor == \"j\" and (f == \"j\" or leds == \"j\") and n == \"n\":\n", + " print(\"Det var straffbar promillekjøring.\")\n", + "else:\n", + " print(\"Ikke straffbart, ingen bot.\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "c) \n", + "\n", + "En løsning her er Ã¥ endre rekkefølge pÃ¥ betingelsene i if-elif-setningen. NÃ¥r operatoren er >, bør den første betingelsen være den med høyest verdi, da vil situasjoner med lavere verdi fortsatt oppfanges av de neste betingelsene." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "prom = float(input(\"Hvor stor var promillen? \"))\n", + "if prom > 0.5:\n", + " print(\"Bot: en halv brutto mÃ¥nedslønn, samt fengsel.\")\n", + "elif prom > 0.4:\n", + " print(\"Forelegg: 10000,-\")\n", + "elif prom > 0.2:\n", + " print(\"Forelegg: 6000,-\")\n", + "else:\n", + " print(\"Ikke straffbart, ingen bot.\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "En annen mulig løsning ville være Ã¥ beholde verdiene i samme rekkefølge som de sto i det opprinnelige programmet, mens bruke motsatt operator (<=). Igjen er poenget at hvis den første betingelsen feiler, mÃ¥ det fortsatt være mulig Ã¥ komme videre til de neste." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "prom = float(input(\"Hvor stor var promillen? \"))\n", + "if prom <= 0.2:\n", + " print(\"Ikke straffbart, ingen bot.\")\n", + "elif prom <= 0.4:\n", + " print(\"Forelegg: 6000,-\")\n", + "elif prom <= 0.5:\n", + " print(\"Forelegg: 10000,-\")\n", + "else:\n", + " print(\"Bot: en halv brutto mÃ¥nedslønn, samt fengsel.\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "d) Problemet i den gitte koden var\n", + "\n", + " \n", + "i) tidl == \"j\" er ikke i seg selv nok til Ã¥ fÃ¥ inndratt førerkortet pÃ¥ livstid; det mÃ¥ skje en gjentatt promillekjøring. Første betingelse etter kommentaren #vurderer inndragning mÃ¥ derfor starte\n", + "\n", + "ii) videre nedover er det satt opp som en serie frittstÃ¥ende if-setninger. Disse blir dermed vurdert hver for seg. SÃ¥ med høy promille (f.eks. 1.3), vil programmet først skrive \"...minst 2 Ã¥r\" men deretter fortsette med ogsÃ¥ Ã¥ skrive 20-22 med, 18 mnd. osv. Løsningen her blir at det ikke mÃ¥ stÃ¥ som frittstÃ¥ende setninger men i en if-elif-struktur. Med dette blir betingelsen prom>0.2 stÃ¥ende to steder, men første gang er det i sammenheng med at man er tidligere dømt, mens nederst vil det da være at det kun var snakk om promille > 0.2 uten noen andre komplikasjoner." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# leser inn data\n", + "prom = float(input(\"Hvor stor var promillen? \"))\n", + "nekt = input(\"Nektet Ã¥ samarbeide ved legetest? (j/n) \")\n", + "tidl = input(\"Tidligere dømt for promillekjøring? (j/n) \")\n", + "if tidl == \"j\":\n", + " aar = int(input(\"Antall Ã¥r siden siste domfellelse: \"))\n", + "else:\n", + " aar = 999\n", + " \n", + "# vurderer inndragning av førerkort\n", + "if prom > 0.2 and tidl == \"j\" or nekt == \"j\" and aar < 5:\n", + " print(\"Førerkort inndras for alltid.\")\n", + "elif prom > 1.2 or nekt == \"j\":\n", + " print(\"Førerkort inndras minst 2 Ã¥r.\")\n", + "elif prom > 0.8:\n", + " print(\"Førerkort inndras 20-22 mnd.\")\n", + "elif prom > 0.5:\n", + " print(\"Førerkort inndras vanligvis 18 mnd.\")\n", + "elif prom > 0.2:\n", + " print(\"Førerkort inndras inntil 1 Ã¥r.\")\n", + "else:\n", + " print(\"Ingen inndragning av førerkort.\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "e) Her er det flere mÃ¥ter Ã¥ gjøre det pÃ¥. De fleste av utfallene nÃ¥r det gjelder inndragning av førerkortet gjelder hvis det var promillekjøring, og mÃ¥ derfor befinne seg inni if-setningen som fastslÃ¥r at det var et motorkjøretøy, at vedkommende var ansvarlig fører, at det ikke var nødrett. Samtidig mÃ¥ noen betingelser vedrørende nekting av legetest ogsÃ¥ testes selv om det ikke var promillekjøring, dvs. i else-delen nederst. Merk at nekt==\"j\" mÃ¥ være begge steder; hvis det var promillekjøring kan det utgjøre en forverrende omstendighet mhp inndragning av førerkort, og hvis det ikke var promille, kan det likevel føre til inndragning. Det er derfor vanskelig Ã¥ fÃ¥ til her en løsning hvor man printer bÃ¥de bot og inndragning samme sted i if-strukturen. F.eks. kunne det ha vært fristende Ã¥ printe bÃ¥de halv mÃ¥nedslønn og 18 med pÃ¥ samme betingelse prom > 0.5. Problemet med dette ville være at det fins situasjoner hvor en promille pÃ¥ f.eks. 0.6 likevel skal føre til mye lenger inndragning av førerkortet, nemlig hvis det var en gjentakelse, eller hvis man nektet Ã¥ samarbeide ved legetest. Man mÃ¥tte da evt. ha lagt til and tidl == \"n\" pÃ¥ hver eneste av disse testene. \n", + "\n", + "**Hele programmet**" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# leser inn data\n", + "prom = float(input(\"Hvor stor var promillen? \"))\n", + "motor = input(\"Var farkosten en motorvogn? (j/n) \")\n", + "f = input(\"Var personen fører av vognen? (j/n) \")\n", + "leds = input(\"Var personen ledsager ved øvekjøring? (j/n) \")\n", + "n = input(\"Var det nødrett? (j/n) \")\n", + "nekt = input(\"Nektet Ã¥ samarbeide ved legetest? (j/n) \")\n", + "tidl = input(\"Tidligere dømt for promillekjøring? (j/n) \")\n", + "if tidl == \"j\":\n", + " aar = int(input(\"Antall Ã¥r siden siste domfellelse: \"))\n", + "else:\n", + " aar = 999\n", + " \n", + "# vurderer straffbarhet\n", + "if prom > 0.2 and motor == \"j\" and (f == \"j\" or leds == \"j\") and n == \"n\":\n", + " print(\"Det var straffbar promillekjøring.\")\n", + " # vurderer bot\n", + " if prom > 0.5:\n", + " print(\"Bot: en halv brutto mÃ¥nedslønn, samt fengsel.\")\n", + " elif prom > 0.4:\n", + " print(\"Forelegg: 10000,-\")\n", + " else:\n", + " print(\"Forelegg: 6000,-\")\n", + " \n", + " # vurderer inndragning\n", + " if tidl == \"j\":\n", + " print(\"Førerkort inndras for alltid.\")\n", + " elif prom > 1.2 or nekt == \"j\":\n", + " print(\"Førerkort inndras minst 2 Ã¥r.\")\n", + " elif prom > 0.8:\n", + " print(\"Førerkort inndras 20-22 mnd.\")\n", + " elif prom > 0.5:\n", + " print(\"Førerkort inndras vanligvis 18 mnd.\")\n", + " else:\n", + " print(\"Førerkort inndras inntil 1 Ã¥r.\")\n", + "else:\n", + " print(\"Ikke straffbar promillekjøring, ingen bot.\")\n", + " # vurderer mulig inndragning selv om det ikke var straffbar kjøring\n", + " if nekt == \"j\":\n", + " print(\"Men da mistenkte slo seg vrang ved legetesten,\")\n", + " if aar < 5:\n", + " print(\"<5 Ã¥r etter en promilledom, inndras førerkort pÃ¥ livstid.\")\n", + " else:\n", + " print(\"inndras førerkortet i 2 Ã¥r.\")\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.9.2" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Losningsforslag/Oving2/Logiske operatorer og logiske uttrykk - lf.ipynb b/Losningsforslag/Oving2/Logiske operatorer og logiske uttrykk - lf.ipynb new file mode 100644 index 0000000..b1891e6 --- /dev/null +++ b/Losningsforslag/Oving2/Logiske operatorer og logiske uttrykk - lf.ipynb @@ -0,0 +1,61 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#oppgave a\n", + "True: 1, 3, 5\n", + "False: 2, 4\n", + " \n", + " \n", + "#oppgave b\n", + "\n", + "def gyldige_tall(a, b): \n", + " if ((a>70 and a<90) or (a>40 and not a>50)) and (70<b<90 or (b>40 and b<50)):\n", + " return \"Tallene er begge i gyldige intervall!\"\n", + " else:\n", + " return \"Minst ett av tallene er utenfor et gyldig intervall :(\"\n", + "\"\"\" \n", + "eventuelt:\n", + "if ((a>70 and a<90) or (a>40 and not a>50)) and ((70<b and b<90) or (b>40 and b<50)):\n", + " ...\n", + "(Flere mulige løsninger, men minimal retting gir øverste)\n", + "\"\"\"\n", + " \n", + "#oppgave c\n", + "...\n", + "if p<0 or p>10:\n", + " ...\n", + " \n", + "#oppgave d\n", + "...\n", + "if not elsker_pannekaker or p<0 or p>10:\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.9.2" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Losningsforslag/Oving2/Sammenligning av strenger - lf.ipynb b/Losningsforslag/Oving2/Sammenligning av strenger - lf.ipynb new file mode 100644 index 0000000..c8d3b16 --- /dev/null +++ b/Losningsforslag/Oving2/Sammenligning av strenger - lf.ipynb @@ -0,0 +1,66 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#oppgave a\n", + "a = \"druer\"\n", + "b = \"DrUer\"\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", + " \n", + " \n", + "#oppgave b\n", + "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:\n", + " print(navn1)\n", + " print(navn2)\n", + "else:\n", + " print(navn2)\n", + " print(navn1)\n", + " \n", + " \n", + "#oppgave c\n", + "Kodesnutt 1:\n", + " k er større enn b\n", + "Kodesnutt 2:\n", + " Los Angeles\n", + " New York\n", + "Kodesnutt 3:\n", + " druer" + ] + } + ], + "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.3" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Losningsforslag/Oving2/Sjakkbrett - lf.ipynb b/Losningsforslag/Oving2/Sjakkbrett - lf.ipynb new file mode 100644 index 0000000..53d61d8 --- /dev/null +++ b/Losningsforslag/Oving2/Sjakkbrett - lf.ipynb @@ -0,0 +1,139 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "a) Løsning med sammensatt betingelse og nøstet if-setning:" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "def farge_pÃ¥_posisjon_a(pos):\n", + " \n", + " bokstav = pos[0]\n", + " tall = int(pos[1])\n", + " \n", + " if bokstav == 'a' or bokstav == 'c' or bokstav == 'e' or bokstav == 'g':\n", + " if tall % 2 == 0:\n", + " return \"Hvit\"\n", + " else:\n", + " return \"Svart\"\n", + " else:\n", + " if tall % 2 == 0:\n", + " return \"Svart\"\n", + " else:\n", + " return \"Hvit\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Den litt lange if-testen av fire ulike bokstaver vil kunne skrives enklere ved bruk av in-operatoren og en streng med alle aktuelle bokstaver:\n", + "\n", + "if bokstav in 'aceg': (og resten av koden som før)\n", + "\n", + " \n", + "\n", + "En enda mye kortere løsning kan imidlertid oppnÃ¥s ved Ã¥ utnytte bokstavenes ASCII-nummer, som finnes ved standardfunksjonen ord(). ord('a') har verdien 97, ord('b') 98, ord('c') 99, osv.\n", + "\n", + "Vi merker oss at a1 er svart; 97+1 er 98, altsÃ¥ et partall. Mer generelt er det slik at alle ruter hvor summen av bokstavens ASCII-verdi og radens nummer er partall, vil være svarte, mens sum som er oddetall vil være hvite ruter.\n", + "\n", + "Dette vil funke ogsÃ¥ for store bokstaver, siden ord('A) er 65, ord('B') 66, osv.\n", + "\n", + "Løsning med ord()" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "def farge_pÃ¥_posisjon_a2(pos): \n", + " bokstav = pos[0]\n", + " tall = int(pos[1])\n", + "\n", + " # Svart rute: bokstavs ascii-verdi + radnummer blir partall\n", + " # Hvit rute: summen blir oddetall\n", + " if (ord(bokstav) + tall) % 2 == 0:\n", + " return \"Svart\"\n", + " else:\n", + " return \"Hvit\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "b)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def farge_pÃ¥_posisisjon_b(pos):\n", + " if len(pos) == 2:\n", + " ch = pos[0]\n", + " if ('A'<= ch <='H' or 'a' <= ch <='h') and '1'<=pos[1]<='8':\n", + " #input OK\n", + " tall = int(pos[1])\n", + " if (ord(ch) + tall) % 2 == 0:\n", + " print(\"Svart\")\n", + " else:\n", + " print(\"Hvit\")\n", + " else:\n", + " print(\"Feil input.\")\n", + " print(\"Første tegn mÃ¥ være en bokstav A-H eller a-h\")\n", + " print(\"Andre tegn mÃ¥ være et tall 1-8\")\n", + " else:\n", + " print(\"Feil lengde pÃ¥ input, skal være 2 tegn.\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Her er det viktig at testen len(pos)==2 gjøres først. Hvis vi først prøver Ã¥ teste bokstaver og tall ved Ã¥ se pÃ¥ pos[0] og pos[1] vil dette feile i tilfelle bruker skrev inn null tegn (slo Enter med en gang).\n", + "\n", + "Likeledes er det lurt Ã¥ teste tegnet pos[1] mellom '1' og '8' heller enn Ã¥ konvertere til tall med int() og teste at tallet er mellom 1 og 8. Hvis bruker har skrevet noe annet enn et tall som andre tegn (f.eks. enda en bokstav), vil int() komme til Ã¥ feile.\n", + "\n", + "Merk ogsÃ¥ at det trengs parentes rundt de to betingelsene som tester at vi er mellom A-H eller a-h. Dette fordi or har lavere presedens enn and. Hvis vi fjerner denne parentesen, vil testen i praksis bli\n", + "\n", + "* at bokstaven - her variabelen ch - er mellom A-H\n", + "* ELLER at bokstaven er mellom a-h og tallet mellom 1-8\n", + "\n", + "Dvs. hvis det kommer stor bokstav vil vi da unnlate Ã¥ teste pÃ¥ tallet, sÃ¥ A9 (f.eks.) vil gÃ¥ gjennom og gi svaret Svart, heller enn Ã¥ gi feilmelding som det egentlig skulle." + ] + } + ], + "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.9.2" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Losningsforslag/Oving2/Skatteetaten lf.ipynb b/Losningsforslag/Oving2/Skatteetaten lf.ipynb new file mode 100644 index 0000000..5798b63 --- /dev/null +++ b/Losningsforslag/Oving2/Skatteetaten lf.ipynb @@ -0,0 +1,98 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "#a)\n", + "\n", + "def skattepliktig_beløp_a(leieinntekt, prosent_utleid):\n", + " print('INFO: Denne funksjonen besvarer om utleie av boligen din er skattepliktig.')\n", + " \"\"\"Skriv koden din her\"\"\"\n", + " if leieinntekt > 20000 and prosent_utleid > 50:\n", + " beløp = leieinntekt\n", + " else:\n", + " beløp = 0\n", + " \n", + " return f\"Skattepliktig beløp er: {beløp}kr\"" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + " \n", + "#b) \n", + "def skattepliktig_beløp_b():\n", + " boligtype = input(\"Skriv inn type annen bolig (Sekundærbolig/Fritidsbolig) du har leid ut: \")\n", + " \n", + " if boligtype == \"Sekundærbolig\":\n", + " belop = int(input(\"Skriv inn leieinntekt for sekundærboligen: \"))\n", + " elif boligtype == \"Fritidsbolig\":\n", + " formal = input(\"Skriv inn formÃ¥let med fritidsboligen(e): \")\n", + " antall_boliger = int(input(\"Skriv inn antallet fritidsboliger du leier ut: \"))\n", + " inntekt_per = int(input(\"Skriv inn utleieinntekten pr. fritidsbolig: \"))\n", + " \n", + " if formal == \"Fritid\":\n", + " if inntekt_per < 10000:\n", + " belop = 0\n", + " else:\n", + " skatt_per = inntekt_per - 10000\n", + " belop_per = int(0.85*skatt_per)\n", + " belop = belop_per * antall_boliger\n", + " \n", + " else:\n", + " belop = inntekt_per * antall_boliger\n", + " else:\n", + " print(\"Du har skrevet inn feil boligtype.\")\n", + " \n", + " return f\"Skappepliktig beløp er pÃ¥: {belop}\"\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "#c)\n", + "\n", + "#Vi lar denne være opp til studenten. Ideelt sett kombinerer vedkommende if-setningene fra ovenstÃ¥ende kode \n", + "#til et stort, helhetlig skript. Første nøkkelbetingelse blir hvorvidt boligen er en primærbolig eller en \n", + "#sekundær-/fritidsbolig. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "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.9.2" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Losningsforslag/Oving2/Tekstbasert spill lf.ipynb b/Losningsforslag/Oving2/Tekstbasert spill lf.ipynb new file mode 100644 index 0000000..ad1585a --- /dev/null +++ b/Losningsforslag/Oving2/Tekstbasert spill lf.ipynb @@ -0,0 +1,57 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Du stÃ¥r ved enden av en vei, foran et hus med en lukket dør, det er en postkasse foran huset\n", + "Hva gjør du?GÃ¥r tilbake\n", + "Du snur deg og vandrer hjem igjen. Du kjøper en is pÃ¥ veien.\n" + ] + } + ], + "source": [ + "#disse er bare eksempler pÃ¥ hvordan en kan tenke, oppgaven kan gjøres pÃ¥ vilt forskjellige mÃ¥ter.\n", + "\n", + "#a, b, c, d\n", + "\n", + "print(\"Du stÃ¥r ved enden av en vei, foran et hus med en lukket dør, det er en postkasse foran huset\")\n", + "a = input(\"Hva gjør du?\").lower()\n", + "if a == \"gÃ¥r tilbake\" or a == \"gÃ¥r andre veien\":\n", + " print(\"Du snur deg og vandrer hjem igjen. Du kjøper en is pÃ¥ veien.\")\n", + "elif a == \"Ã¥pner døren\" or a == \"Ã¥pne døren\":\n", + " print(\"Døren er lÃ¥st\")\n", + "elif a == \"Ã¥pner postkassen\" or a == \"Ã¥pne postkassen\":\n", + " print(\"Du finner en nøkkel i postkassen\")\n", + "else:\n", + " print(\"Ikke en støttet kommando\")" + ] + } + ], + "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.3" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git "a/Losningsforslag/Oving2/Ulike typer if-setninger l\303\270sning lf.ipynb" "b/Losningsforslag/Oving2/Ulike typer if-setninger l\303\270sning lf.ipynb" new file mode 100644 index 0000000..1098a24 --- /dev/null +++ "b/Losningsforslag/Oving2/Ulike typer if-setninger l\303\270sning lf.ipynb" @@ -0,0 +1,102 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#oppgave a\n", + "def kake_ut_av_ovnen_losning(tid):\n", + " print(f\"Kaken har vært i ovnen i {tid} minutter.\")\n", + " if tid >= 50:\n", + " print(\"Kaken kan tas ut av ovnen.\")\n", + " print(\"Tips til servering: vanilje.\")\n", + " \n", + " \n", + "#oppgave b\n", + "\n", + "def antall_epler_per_barn(epler, barn):\n", + " if barn > 0:\n", + " # Antall epler til hvert barn\n", + " antall_per = epler // barn\n", + " print (f\"Da blir det {antall_per} epler til hvert barn.\")\n", + " # Antall epler det er igjen etter at barna har fÃ¥tt sine epler\n", + " antall_rest = epler % barn\n", + " print (f\"Og du fÃ¥r igjen {antall_per} epler til deg selv.\")\n", + " \n", + " \n", + " print(\"Takk for i dag!\")\n", + " \n", + " \n", + "#oppgave c\n", + "def kan_stemme_c(alder):\n", + " if alder >= 18:\n", + " return \"Du kan stemme:)\"\n", + " else:\n", + " return \"Du kan ikke stemme ennÃ¥\"\n", + " \n", + " \n", + "#oppgave d\n", + "def kan_stemme_d(alder):\n", + " if alder >= 18:\n", + " print(\"Du kan stemme bÃ¥de ved lokalvalg og Stortingsvalg.\")\n", + " elif alder >= 16:\n", + " print(\"Du kan stemme ved lokalvalg men ikke ved Stortingsvalg.\")\n", + " else:\n", + " print(\"Du kan ikke stemme ennÃ¥\")\n", + "\n", + "# Eventuell variant der det returneres\n", + "def kan_stemme_d_2(alder):\n", + " if alder >= 18:\n", + " return\"Du kan stemme bÃ¥de ved lokalvalg og Stortingsvalg.\"\n", + " elif alder >= 16:\n", + " return \"Du kan stemme ved lokalvalg men ikke ved Stortingsvalg.\"\n", + " else:\n", + " return \"Du kan ikke stemme ennÃ¥\"\n", + " \n", + " \n", + "#oppgave e\n", + "def billettpris(alder): \n", + " if alder < 3:\n", + " return \"Billetten er gratis\"\n", + " elif alder < 12:\n", + " return \"Billettpris: 30kr\"\n", + " elif alder < 26:\n", + " return \"Billettpris: 50kr\"\n", + " elif alder < 67:\n", + " return \"Billettpris: 80kr\"\n", + " else:\n", + " return \"Billettpris: 40kr\"" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "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.9.2" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git "a/Losningsforslag/Oving2/\303\205rstider - lf.ipynb" "b/Losningsforslag/Oving2/\303\205rstider - lf.ipynb" new file mode 100644 index 0000000..f809d76 --- /dev/null +++ "b/Losningsforslag/Oving2/\303\205rstider - lf.ipynb" @@ -0,0 +1,75 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "def arstid(m, d):\n", + " if m == 'mars':\n", + " if d<20:\n", + " return \"Vinter\"\n", + " else:\n", + " return \"VÃ¥r\"\n", + " elif m == 'juni':\n", + " if d<21:\n", + " return \"VÃ¥r\"\n", + " else:\n", + " return \"Sommer\"\n", + " elif m == 'september':\n", + " if d<22:\n", + " return \"Sommer\"\n", + " else:\n", + " return \"Høst\"\n", + " elif m == 'desember':\n", + " if d<21:\n", + " return \"Høst\"\n", + " else:\n", + " return \"Vinter\"\n", + " elif m == 'april' or m == 'mai':\n", + " return \"VÃ¥r\"\n", + " elif m == 'juli' or m == 'august':\n", + " return \"Sommer\"\n", + " elif m == 'oktober' or m == 'november':\n", + " return \"Høst\"\n", + " else:\n", + " return \"Vinter\"\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3.10.6 64-bit", + "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.10.6" + }, + "vscode": { + "interpreter": { + "hash": "aee8b7b246df8f9039afb4144a1f6fd8d2ca17a180786b69acc140d282b71a49" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Ovinger/Oving5/Chattebot.ipynb b/Ovinger/Oving5/Chattebot.ipynb new file mode 100644 index 0000000..8794c70 --- /dev/null +++ b/Ovinger/Oving5/Chattebot.ipynb @@ -0,0 +1,243 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "<nav class=\"navbar navbar-default\">\n", + " <div class=\"container-fluid\">\n", + " <div class=\"navbar-header\">\n", + " <a class=\"navbar-brand\" href=\"_Oving5.ipynb\">Øving 5</a>\n", + " </div>\n", + " <ul class=\"nav navbar-nav\">\n", + " <li ><a href=\"Generelt%20om%20lister.ipynb\">Generelt om lister</a></li>\n", + " <li ><a href=\"Lett%20og%20blandet.ipynb\">Lett og blandet</a></li>\n", + " <li ><a href=\"Intro%20til%20numpy-arrays.ipynb\">Intro til numpy-arrays</a></li>\n", + " <li ><a href=\"Kodeforstaelse.ipynb\">KodeforstÃ¥else</a></li>\n", + " <li ><a href=\"Vektorer.ipynb\">Vektorer</a></li>\n", + " <li ><a href=\"Lister%20og%20lokker.ipynb\">Lister og løkker</a></li>\n", + " <li ><a href=\"Teoridelen%20paa%20eksamen.ipynb\">Teoridelen pÃ¥ eksamen</a></li>\n", + " <li ><a href=\"Gangetabell%20og%20lister.ipynb\">Gangetabell og lister</a></li>\n", + " <li ><a href=\"Lotto.ipynb\">Lotto</a></li>\n", + " <li ><a href=\"Tannfeen.ipynb\">Tannfeen</a></li>\n", + " <li class=\"active\"><a href=\"Chattebot.ipynb\">Chattebot</a></li>\n", + " <li ><a href=\"Matriseaddisjon.ipynb\">Matriseaddisjon</a></li>\n", + " </ul>\n", + " </div>\n", + "</nav>\n", + "\n", + "# Chattebot\n", + "\n", + "**LæringsmÃ¥l:**\n", + "\n", + "* Lister\n", + "\n", + "\n", + "**I denne oppgaven skal du skrive et større program. For denne typen oppgaver kan det være mer praktisk Ã¥ laste ned python og eventuelt en IDE (Et omrÃ¥de man programmerer i pÃ¥ sin egen maskin). Ta derfor en kikk [her](https://docs.google.com/document/d/17tS0maWyzORUsIjmCVEszfqrl2X4By-Cy2Sw3ENG5lA/edit?usp=sharing) før du begynner. Det er fortsatt mulig Ã¥ gjøre oppgaven i Jupyter dersom du ikke ønsker Ã¥ jobbe lokalt, selv om det ikke er anbefalt.**\n", + "\n", + "I denne oppgaven skal du lage et program som simulerer en datavenn du kan snakke med, en sÃ¥kalt \"chatbot\".\n", + "\n", + "**Oppgave:** Skriv koden som mangler for Ã¥ fullføre programmet.\n", + "\n", + "Hovedfunksjonen til programmet er følgende:\n", + "\n", + "Spørre brukeren om navnet.\n", + "Stille et tilfeldig spørsmÃ¥l fra en liste av spørsmÃ¥l til brukeren der navnet inngÃ¥r.\n", + "La brukeren fÃ¥ svare.\n", + "Stille et tilfeldig oppfølgingsspørsmÃ¥l, der svaret fra brukeren er med.\n", + "Gi en tilfeldig kommentar til brukeren.\n", + "Programmet skal avsluttes ved at brukeren gir svaret “hadeâ€. Kildekoden er godt dokumentert med kommentarer og alle steder som mangler kode er markert med “MANGLER KODE HER!!!â€. Kildekoden er gitt under, sÃ¥ start med Ã¥ kopiere og lime denne inn i en python fil, eventuelt jobb direkte i kodeboksen.\n", + "\n", + "Husk: **pass** i starten av while-løkken mÃ¥ fjernes nÃ¥r dere begynner Ã¥ skrive koden deres. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# vim:set fileencoding=latin-1:\n", + "import random # Importerer modulen random (generere tilfeldige tall)\n", + " \n", + "# Funksjon: pick_sentence\n", + "# Beskrivelse: Plukker ut en tilfeldig tekststreng fra en liste av tekstsetninger\n", + "# Input: En liste av tekststrenger\n", + "# Ouput: En tekststreng\n", + "def pick_sentence(sentences):\n", + " return sentences[random.randint(0, len(sentences)-1)]\n", + " \n", + "# Funksjon: print_sentence\n", + "# Beskrivelse: Skriver ut tre tekststrenger pÃ¥ ei linje til konsoll.\n", + "# Det skal være mellomrom (space) mellom tekststreng en og to.\n", + "# Det skal ikke være mellomrom (space) mellom tekststreng to og tre.\n", + "# Input: Tre tekststrenger\n", + "# Output: Ingen\n", + "# Kommentar: MANGER KODE HER!!!!\n", + " \n", + " \n", + "# Funksjon: intro_text\n", + "# Beskrivelse: Skriver en velkomsttekst til konsoll som skal inneholde:\n", + "# 20 linjeskift\n", + "# Setningen: \"Hei, jeg heter HAL og vil gjerne snakke med deg.\"\n", + "# Setningen: \"Ikke start svar med stor bokstav og bruk hele setninger.\"\n", + "# Setningen: \"Skriv 'hade' hvis du vil avslutte samtalen\"\n", + "# Setningen: \"**************************************************\"\n", + "# 1 linjeskift\n", + "# Input: Ingen\n", + "# Output: Ingen\n", + "# Kommentar: MANGLER KODE HER!!!\n", + " \n", + " \n", + "# Funksjon: main\n", + "# Beskrivelse: Hovedfunksjonen i programmet\n", + "# Input: Ingen\n", + "# Output: Ingen\n", + "def main():\n", + " # Initialisering av variabler\n", + " answer = \"ikke hade\" # Sørger for at while-løkka kjører første gang\n", + " \n", + " # En liste av spørsmÃ¥l\n", + " questions = ['Hva gjør du', 'Hvordan gÃ¥r det', 'Hvorfor heter du',\n", + " 'Liker du Ã¥ hete', 'Føler du deg bra', 'Hva har du gjort idag',\n", + " 'Hva tenker du om framtida', 'Hva gjør deg glad', 'Hva gjør deg trist']\n", + " \n", + " # En liste av oppfølgningsspørsmÃ¥l\n", + " follow_ups = ['Hvorfor sier du', 'Hva mener du med', 'Hvor lenge har du sagt',\n", + " 'Hvilke tanker har du om', 'Kan du si litt mer om',\n", + " 'NÃ¥r tenkte du første gang pÃ¥']\n", + " \n", + " # En liste av responser\n", + " responses = ['Fint du sier det', 'Det skjønner jeg godt', 'SÃ¥ dumt da', 'Føler meg ogsÃ¥ sÃ¥nn',\n", + " 'Blir trist av det du sier', 'SÃ¥ bra', 'Du er jammen frekk']\n", + " \n", + " # Skriv velkomsttekst til konsoll vha. funksjonen intro_text\n", + " # MANGLER KODE HER!!!\n", + " \n", + " # Spør brukeren om navnet og lagre svaret i en variabel\n", + " # MANGLER KODE HER!!!\n", + " \n", + " # Programmet kjører i løkke helt til brukeren svarer \"hade\"\n", + " while answer != \"hade\":\n", + " pass\n", + " \n", + " # NB: All kode her mÃ¥ skrives med to innrykk!!!\n", + " \n", + " # Plukk ut et tilfeldig spørsmÃ¥l fra lista questions\n", + " # ved hjelp av funksjonen pick_sentence\n", + " # MANGLER KODE HER!!!\n", + " \n", + " # Skriv spørsmÃ¥let etterfulgt av navnet til brukeren\n", + " # og et spørsmÃ¥lstegn ved hjelp av funksjonen print_sentence\n", + " # MANGLER KODE HER!!!\n", + " \n", + " # Spør brukeren om et svar med teksten \"Svar: \" og lagre\n", + " # resultatet i en variabel\n", + " # MANGLER KODE HER!!!\n", + " \n", + " # Plukk ut et tilfeldig oppfølgingsspørsmÃ¥l fra lista follow_ups\n", + " # ved hjelp av funksjonen pick_sentence\n", + " # MANGLER KODE HER!!!\n", + " \n", + " # Skriv oppfølgningsspørsmÃ¥let sammen med svaret fra brukeren\n", + " # og et spørsmÃ¥lstegn ved hjelp av funksjonen print_sentence\n", + " # MANGLER KODE HER!!!\n", + " \n", + " # Spør brukeren om et svar med teksten \"Svar: \" uten Ã¥ lagre\n", + " # resultatet til variabel\n", + " # MANGLER KODE HER!!!\n", + " \n", + " # Plukk ut en tilfeldig respons fra lista responses\n", + " # ved hjelp av funksjonen pick_sentence\n", + " # MANGLER KODE HER!!!\n", + " \n", + " # Skriv reponsen sammen med navnet til brukeren\n", + " # og et punktum (\".\") ved hjelp av funksjonen print_sentence\n", + " # MANGLER KODE HER!!!\n", + " \n", + "main()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "**Eksempel pÃ¥ kjøring:**\n", + "\n", + "```\n", + "Hei , Jeg heter HAL og vil gjerne snakke med deg!\n", + " Ikke start svar med stor bokstav og bruk hele setninger .\n", + " Skriv 'hade ' hvis du vil avslutte \n", + " **************************************************\n", + "Hva heter du? Bob Bernt\n", + "Hvorfor heter du Bob Bernt?\n", + " Svar : mamma liker det navnet\n", + "Hvilke tanker har du om mamma liker det navnet?\n", + " Svar : litt ekkelt\n", + "SÃ¥ bra Bob Bernt.\n", + "Hva gjør deg trist Bob Bernt?\n", + " Svar : ikke noe mer sjokolade\n", + "Hvorfor sier du ikke noe mer sjokolade?\n", + " Svar : hæ?\n", + "SÃ¥ dumt da Bob Bernt.\n", + " Hva tenker du om framtida Bob Bernt?\n", + " Svar : hade\n", + "Hva mener du med hade?\n", + " Svar : ku\n", + "Blir trist av det du sier Bob Bernt.\n", + "```" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3.10.6 64-bit", + "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.10.6" + }, + "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": "aee8b7b246df8f9039afb4144a1f6fd8d2ca17a180786b69acc140d282b71a49" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Ovinger/Oving5/Gangetabell og lister.ipynb b/Ovinger/Oving5/Gangetabell og lister.ipynb new file mode 100644 index 0000000..b22069b --- /dev/null +++ b/Ovinger/Oving5/Gangetabell og lister.ipynb @@ -0,0 +1,250 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "<nav class=\"navbar navbar-default\">\n", + " <div class=\"container-fluid\">\n", + " <div class=\"navbar-header\">\n", + " <a class=\"navbar-brand\" href=\"_Oving5.ipynb\">Øving 5</a>\n", + " </div>\n", + " <ul class=\"nav navbar-nav\">\n", + " <li ><a href=\"Generelt%20om%20lister.ipynb\">Generelt om lister</a></li>\n", + " <li ><a href=\"Lett%20og%20blandet.ipynb\">Lett og blandet</a></li>\n", + " <li ><a href=\"Intro%20til%20numpy-arrays.ipynb\">Intro til numpy-arrays</a></li>\n", + " <li ><a href=\"Kodeforstaelse.ipynb\">KodeforstÃ¥else</a></li>\n", + " <li ><a href=\"Vektorer.ipynb\">Vektorer</a></li>\n", + " <li ><a href=\"Lister%20og%20lokker.ipynb\">Lister og løkker</a></li>\n", + " <li ><a href=\"Teoridelen%20paa%20eksamen.ipynb\">Teoridelen pÃ¥ eksamen</a></li>\n", + " <li ><a href=\"Gangetabell%20og%20lister.ipynb\">Gangetabell og lister</a></li>\n", + " <li ><a href=\"Lotto.ipynb\">Lotto</a></li>\n", + " <li ><a href=\"Tannfeen.ipynb\">Tannfeen</a></li>\n", + " <li class=\"active\"><a href=\"Chattebot.ipynb\">Chattebot</a></li>\n", + " <li ><a href=\"Matriseaddisjon.ipynb\">Matriseaddisjon</a></li>\n", + " </ul>\n", + " </div>\n", + "</nav>\n", + "\n", + "# Gangetabell og lister\n", + "\n", + "**LæringsmÃ¥l:**\n", + "\n", + "* Løkker\n", + "* Lister\n", + "\n", + "\n" + ] + }, + { + "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": [ + "Lag en funksjon separate(numbers, threshold) som tar inn to argumenter:\n", + "\n", + "* numbers: en liste med heltall\n", + "* threshold: et heltall\n", + "\n", + "Funksjonen skal returnere to lister: den første listen skal inneholde alle elementer fra **numbers** som er mindre enn **threshold**, og den andre listen skal inneholde alle elementer fra **numbers** som er større enn eller lik **threshold**.\n", + "\n", + " \n", + "En matrise er et rektangulært sett av elementer ordnet i rader og kolonner. Radene er de horisontale linjene, og kolonnene er de vertikale linjene.\n", + "\n", + "I Python representerer vi dette med lister som inneholder lister. Elementet øverst til venstre i eksempelet under (med verdi 1) er i rad 1, kolonne 1." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "matrise = [\n", + "[1, 2, 3],\n", + "[4, 5, 6],\n", + "[7, 8, 9]]" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "Elementene i matrisen kan hentes ut pÃ¥ følgende mÃ¥te: **matrise[radnr][kolnr]**. \n", + "\n", + "*Husk at radnummer og kolonnenummer er null-indeksert (begynner pÃ¥ 0) i Python i motsetning til matematisk notasjon der de er 1-indeksert!*\n", + "\n", + "***Skriv koden din i boksen under.***" + ] + }, + { + "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, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "Lag en funksjon **multiplication_table(n)** som tar inn et heltall n som parameter og returnerer gangetabellen fra 1 til n som en matrise med n rader og n kolonner.\n", + "\n", + "***Skriv koden din i boksen under.***" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "Har du implementert funksjon riktig skal koden under printe følgende matrise:\n", + "\n", + "\n", + "```\n", + "[[1, 2, 3, 4],\n", + " [2, 4, 6, 8],\n", + " [3, 6, 9, 12],\n", + " [4, 8, 12, 16]]\n", + " ```" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "print(multiplication_table(4))" + ] + }, + { + "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": [ + "Man kan legge til elementer (som ogsÃ¥ kan være lister) pÃ¥ slutten av en liste med **liste.append(element)**." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3.8.5 32-bit", + "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.8.5" + }, + "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": "03299db1fae60594c2125507d91406fcab8a4e5ee4ae8637248853dec3226cad" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Ovinger/Oving5/Generelt om lister.ipynb b/Ovinger/Oving5/Generelt om lister.ipynb new file mode 100644 index 0000000..743fac2 --- /dev/null +++ b/Ovinger/Oving5/Generelt om lister.ipynb @@ -0,0 +1,504 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "<nav class=\"navbar navbar-default\">\n", + " <div class=\"container-fluid\">\n", + " <div class=\"navbar-header\">\n", + " <a class=\"navbar-brand\" href=\"_Oving5.ipynb\">Øving 5</a>\n", + " </div>\n", + " <ul class=\"nav navbar-nav\">\n", + " <li ><a href=\"Generelt%20om%20lister.ipynb\">Generelt om lister</a></li>\n", + " <li ><a href=\"Lett%20og%20blandet.ipynb\">Lett og blandet</a></li>\n", + " <li ><a href=\"Intro%20til%20numpy-arrays.ipynb\">Intro til numpy-arrays</a></li>\n", + " <li ><a href=\"Kodeforstaelse.ipynb\">KodeforstÃ¥else</a></li>\n", + " <li ><a href=\"Vektorer.ipynb\">Vektorer</a></li>\n", + " <li ><a href=\"Lister%20og%20lokker.ipynb\">Lister og løkker</a></li>\n", + " <li ><a href=\"Teoridelen%20paa%20eksamen.ipynb\">Teoridelen pÃ¥ eksamen</a></li>\n", + " <li ><a href=\"Gangetabell%20og%20lister.ipynb\">Gangetabell og lister</a></li>\n", + " <li ><a href=\"Lotto.ipynb\">Lotto</a></li>\n", + " <li ><a href=\"Tannfeen.ipynb\">Tannfeen</a></li>\n", + " <li class=\"active\"><a href=\"Chattebot.ipynb\">Chattebot</a></li>\n", + " <li ><a href=\"Matriseaddisjon.ipynb\">Matriseaddisjon</a></li>\n", + " </ul>\n", + " </div>\n", + "</nav>\n", + "\n", + "# Generelt om lister\n", + "\n", + "**LæringsmÃ¥l:**\n", + "\n", + "* Lister\n", + "\n", + "\n", + "I denne oppgaven skal vi bli kjent med hvordan lister fungerer i Python ved Ã¥ opprette enkle lister, endre pÃ¥ dem, og skrive ut listene til konsollen. " + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "heading_collapsed": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "### Generelt om lister" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Lister er en mye brukt datastruktur for Ã¥ tilordne én variabel en rekke med verdier. Lister kan blant annet inneholde tall, strenger eller andre lister.\n", + "\n", + "For Ã¥ opprette en tom liste i Python skriver vi []. VilkÃ¥rlig lange lister kan lages ved Ã¥ skrive [a, b, c, ... ], der a, b, og c er elementer i listen. For eksempel:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-03T07:01:11.287280Z", + "start_time": "2019-07-03T07:01:11.230243Z" + }, + "hidden": true + }, + "outputs": [], + "source": [ + "min_liste = [4,'elementer','i','listen']" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Hvert element i en liste har en indeks, som beskriver posisjonen elementet har i listen. Denne brukes nÃ¥r vi skal endre eller finne et element i en liste.\n", + "\n", + "Lister i Python er nullindeksert, det vil si at det første elementet har indeks 0, det neste elementet har indeks 1, osv. Ved Ã¥ skrive liste[index] kan vi finne eller endre elementer i en liste. Dvs. at min_liste[0] er 4, min_liste[1] er 'elementer', min_liste[2] er 'i' og min_liste[3] er 'listen'.\n", + "\n", + "For eksempel: (**Prøv gjerne Ã¥ endre pÃ¥ koden og se hva som skjer**)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-03T07:01:58.309772Z", + "start_time": "2019-07-03T07:01:58.301527Z" + }, + "hidden": true + }, + "outputs": [], + "source": [ + "min_liste = [4,'elementer','i','listen']\n", + "print(min_liste[0]) # koden skriver ut elementet pÃ¥ posisjon 0 i listen: 4\n", + "min_liste[1] = 'ting'\n", + "print(min_liste[1]) # koden skriver ut elementet pÃ¥ posisjon 1 i listen: ting" + ] + }, + { + "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": [ + "Lag en liste **my_first_list** med alle heltallene fra og med 1 til og med 6.\n", + "\n", + "Eksempel pÃ¥ kjøring:\n", + "\n", + "```python\n", + "print(my_first_list)\n", + "[1, 2, 3, 4, 5, 6]\n", + "```\n", + "***Skriv koden din i boksen under.***" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-03T07:04:40.859385Z", + "start_time": "2019-07-03T07:04:40.850440Z" + } + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "### Lengde av lister" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "For Ã¥ finne lengden pÃ¥ en liste er det nyttig Ã¥ benytte seg av den innebygde funksjonen, len(). Dersom vi tar len(min_liste) vil dette være lik 4 dersom min_liste er lik som under Generelt om lister. Lengden er altsÃ¥ lik antall elementer i listen. Ettersom en liste er nullindeksert vil indeksen til det siste elementet alltid være lik lengden-1. For eksempel vil det siste elementet i min_liste være pÃ¥ indeks 3 nÃ¥r lengden er 4. En annen mÃ¥te Ã¥ fÃ¥ ut det siste elementet i en liste er Ã¥ tenke at det siste elementet har indeks -1, da vil det nest siste elementet ha indeks -2 osv." + ] + }, + { + "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": [ + "Skriv ut det siste elementet i listen til skjerm. **Husk at du kan bruke listen fra forrige oppgave uten Ã¥ definere my_first_list pÃ¥ nytt.**\n", + "\n", + "(obs: dette kan gjøres pÃ¥ to forskjellige mÃ¥ter)\n", + "\n", + "Eksempel pÃ¥ kjøring:\n", + "```python\n", + "6\n", + "```\n", + "***Skriv koden din i boksen under.***" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-03T07:08:45.565459Z", + "start_time": "2019-07-03T07:08:45.558296Z" + } + }, + "outputs": [], + "source": [] + }, + { + "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": [ + "c) Bytt ut det nest siste elementet (5) med tekststrengen 'pluss'.\n", + "\n", + "Eksempel pÃ¥ kjøring:\n", + "\n", + "```python\n", + "print(my_first_list)\n", + "[1, 2, 3, 4, 'pluss', 6]\n", + "```\n", + "\n", + "***Skriv koden din i boksen under.***" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "heading_collapsed": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "### Slicing av lister" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "La oss si at vi har en liste som inneholder 5 elementer, for eksempel" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-03T07:14:14.588974Z", + "start_time": "2019-07-03T07:14:14.582646Z" + }, + "hidden": true + }, + "outputs": [], + "source": [ + "bokstaver = ['a', 'b', 'c', 'd', 'e']" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-03T07:14:21.095731Z", + "start_time": "2019-07-03T07:14:21.084154Z" + }, + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Vi ønsker en ny liste som kun inneholder de første 3 elementene, dvs. 'a', 'b' og 'c', og den listen skal hete bokstaver_abc." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "bokstaver_abc = bokstaver[:3]\n", + "print(bokstaver_abc)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "En generell formel for slicing er:\n", + "\n", + "nyListe = liste[start:slutt]\n", + "\n", + "hvor start er indeksen til det første tallet du ønsker Ã¥ ha med, og slutt er indeksen+1 til det siste tallet du ønsker Ã¥ ha med. AltsÃ¥ er den formelen skrevet som \"fra og med\" start og \"til, men ikke med\" slutt. Dersom man ikke skriver noe pÃ¥ start som i eksempelet over, vil programmet anta at du mener fra starten av listen, og dersom du ikke skriver noe pÃ¥ slutt vil programmet anta at du mener frem til listen er ferdig." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "### d)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "Lag en ny liste **my_second_list** som skal inneholde de tre siste elementene i **my_first_list**.\n", + "\n", + "Eksempel pÃ¥ kjøring:\n", + "\n", + "```python\n", + "print(my_second_list)\n", + "[4, 'pluss', 6]```\n", + "\n", + "***Skriv koden din i boksen under.***" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-03T07:17:15.542842Z", + "start_time": "2019-07-03T07:17:15.536871Z" + } + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "### e)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "Skriv ut my_second_list og tekststrengen 'er lik 10' til skjerm.\n", + "\n", + "Eksempel pÃ¥ kjøring:\n", + "\n", + "```python\n", + "[4, 'pluss', 6] er lik 10\n", + "```\n", + "\n", + "***Skriv koden din i boksen under.***" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3.10.6 64-bit", + "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.10.6" + }, + "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": "aee8b7b246df8f9039afb4144a1f6fd8d2ca17a180786b69acc140d282b71a49" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Ovinger/Oving5/Intro til numpy-arrays.ipynb b/Ovinger/Oving5/Intro til numpy-arrays.ipynb new file mode 100644 index 0000000..51530fd --- /dev/null +++ b/Ovinger/Oving5/Intro til numpy-arrays.ipynb @@ -0,0 +1,299 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "<nav class=\"navbar navbar-default\">\n", + " <div class=\"container-fluid\">\n", + " <div class=\"navbar-header\">\n", + " <a class=\"navbar-brand\" href=\"_Oving5.ipynb\">Øving 5</a>\n", + " </div>\n", + " <ul class=\"nav navbar-nav\">\n", + " <li ><a href=\"Generelt%20om%20lister.ipynb\">Generelt om lister</a></li>\n", + " <li ><a href=\"Lett%20og%20blandet.ipynb\">Lett og blandet</a></li>\n", + " <li ><a href=\"Intro%20til%20numpy-arrays.ipynb\">Intro til numpy-arrays</a></li>\n", + " <li ><a href=\"Kodeforstaelse.ipynb\">KodeforstÃ¥else</a></li>\n", + " <li ><a href=\"Vektorer.ipynb\">Vektorer</a></li>\n", + " <li ><a href=\"Lister%20og%20lokker.ipynb\">Lister og løkker</a></li>\n", + " <li ><a href=\"Teoridelen%20paa%20eksamen.ipynb\">Teoridelen pÃ¥ eksamen</a></li>\n", + " <li ><a href=\"Gangetabell%20og%20lister.ipynb\">Gangetabell og lister</a></li>\n", + " <li ><a href=\"Lotto.ipynb\">Lotto</a></li>\n", + " <li ><a href=\"Tannfeen.ipynb\">Tannfeen</a></li>\n", + " <li class=\"active\"><a href=\"Chattebot.ipynb\">Chattebot</a></li>\n", + " <li ><a href=\"Matriseaddisjon.ipynb\">Matriseaddisjon</a></li>\n", + " </ul>\n", + " </div>\n", + "</nav>\n", + "\n", + "# Numpy Arrays\n", + "\n", + "**LæringsmÃ¥l:**\n", + "\n", + "* Lister\n", + "* Numpy\n", + "\n", + " \n", + "\n", + "\n", + "Denne oppgaven er obligatorisk, og er en kjapp introduksjon til en form for lister som ofte gir bedre ytelse og kjøretid enn Pythons innebygde lister. Dette gjelder særlig nÃ¥r man har matrisestrukturer og skal jobbe med store datasett.\n", + "\n", + "NumPy-arrays finnes i pakken numpy, som kan importeres i Jupyter ved Ã¥ skrive f.eks import numpy as np.\n", + "```python\n", + "import numpy as np #numpy as np gjør at vi bare trenger Ã¥ skrive np.array() og ikke numpy.array() etc.\n", + "```\n", + "\n", + "For Ã¥ løse deloppgavene kan det være lurt Ã¥ se pÃ¥ [dokumentasjonen til NumPy](https://numpy.org/doc/stable/reference/). " + ] + }, + { + "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": [ + "Bruk funksjonene **np.array()** og **np.dot()** for Ã¥ lage en funksjon areOrthogonal(a,b) som tar inn to vanlige lister som representerer to vektorer, konverterer dem til Numpy-arrays og deretter sjekker om vektorene er ortogonale. Funksjonen returnerer altsÃ¥ den boolske verdien True dersom de er ortogonale, og False hvis ikke.\n", + "\n", + "*NB: Du kan anta at de to input-vektorene er av samme lengde og kun inneholder tall.*\n", + "\n", + "***Skriv koden din i boksen under.***" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "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": [ + "Husk fra R2 (ev. 3MX for de som hadde det...) at to vektorer er ortogonale dersom prikkproduktet deres er lik 0." + ] + }, + { + "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": [ + "Bruk *kun* numpy-funksjonene `np.arange()`, `np.transpose()` og `arr.reshape()` (der **arr** er et objekt av typen numpy.ndarray) for Ã¥ skape den følgende matrisen. \n", + "\n", + "Start med Ã¥ lese om [np.arange()](https://docs.scipy.org/doc/numpy/reference/generated/numpy.arange.html), [np.reshape()](https://docs.scipy.org/doc/numpy-1.10.1/reference/generated/numpy.reshape.html) og [np.transpose()](https://docs.scipy.org/doc/numpy/reference/generated/numpy.transpose.html). Du skal bruke disse funksjonene i rekkefølge med riktig input for Ã¥ fÃ¥ resultet nedenfor (**ikke lag arrayen med np.array()**). \n", + "\n", + "```python\n", + "array([[ 1, 6, 11],\n", + " [ 2, 7, 12],\n", + " [ 3, 8, 13],\n", + " [ 4, 9, 14],\n", + " [ 5, 10, 15]])\n", + " ```\n", + " \n", + "***Skriv koden din i boksen under.***" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "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": [ + "Oppgaven under viser et eksempel pÃ¥ hvordan man kan plotte ting i python. Oppgaven din er Ã¥ kjøre koden og prøve Ã¥ forstÃ¥ hvordan den fungerer.\n", + "\n", + "Koden plotter jordens omløpsbane rundt solen ved bruk av den numeriske algoritmen; Euler-Cromer. Her ser vi for oss et todimensjonalt koordinatsystem med Solen i origo og Jorden som kretser rundt Solen med radius lik 1. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-03T11:17:37.086757Z", + "start_time": "2019-07-03T11:17:36.002193Z" + } + }, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "%matplotlib inline\n", + " \n", + "def EulerCromer( tmax, x0, y0, v0, u0, m, tau):\n", + " # tmax er tiden jorden bruker rundt solen\n", + " # x0 og y0 er startbetingelser for jordens posisjon\n", + " # v0 og u0 er starbetingelser for farten til jorden\n", + " # m er massen til jorden og tau er steglengden.\n", + " \n", + " N = int(round(tmax/tau)) #np.zeros(N) lager en liste bestÃ¥ende av bare 0ere av lengde N\n", + " x = np.zeros(N)\n", + " y = np.zeros(N)\n", + " u = np.zeros(N)\n", + " v = np.zeros(N)\n", + " radiuser = np.zeros(N)\n", + " \n", + " # startbetingelser\n", + " u[0] = u0\n", + " v[0] = v0\n", + " x[0] = x0\n", + " y[0] = y0\n", + " radiuser[0] = np.sqrt((x[0]) ** 2 + (y[0]) ** 2)\n", + " \n", + " for n in range(1, N):\n", + " u[n] = u[n - 1] - 4 * np.pi ** 2 * x[n - 1] * tau / (radiuser[n - 1] ** 3)\n", + " v[n] = v[n - 1] - 4 * np.pi ** 2 * y[n - 1] * tau / (radiuser[n - 1] ** 3)\n", + " x[n] = x[n - 1] + u[n] * tau\n", + " y[n] = y[n - 1] + v[n] * tau\n", + " radiuser[n] = np.sqrt((x[n]) ** 2 + (y[n]) ** 2)\n", + " \n", + " \n", + " return x, y # posisjons- og farts-lister\n", + " \n", + "# startbetingelser:\n", + "x0 = 1 # Tenk deg at solen er i origo og at jorden starter i posisjon(1,0)\n", + "y0 = 0\n", + "u0 = 0 # startfarten i x-retning er 0\n", + "v0 = 2*3.1415623 # startfarten i y-retning er 2*pi\n", + "m = 1 / 333480 # dette er massen til Jorden i forhold til massen til Solen\n", + "tmax = 1 # Omløpstiden rundt Solen er 1(Ã¥r)\n", + "tau = 0.01 # denne skrittlengden er sÃ¥pass liten at plottet blir fint nok\n", + " \n", + "x1, y1 = EulerCromer(tmax, x0, y0, v0, u0, m, tau)\n", + " \n", + "# Plotter banen til planeten rundt sola\n", + "plt.figure()\n", + "plt.plot(x1, y1)\n", + "circle = plt.Circle((0, 0), radius=0.06, fc='yellow')\n", + "plt.gca().add_patch(circle)\n", + "plt.xlabel(r'x [AU]')\n", + "plt.ylabel(r'y [AU]')\n", + "plt.show()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3.10.6 64-bit", + "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.10.6" + }, + "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": "aee8b7b246df8f9039afb4144a1f6fd8d2ca17a180786b69acc140d282b71a49" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Ovinger/Oving5/Kodeforstaelse.ipynb b/Ovinger/Oving5/Kodeforstaelse.ipynb new file mode 100644 index 0000000..2b30fd9 --- /dev/null +++ b/Ovinger/Oving5/Kodeforstaelse.ipynb @@ -0,0 +1,466 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "<nav class=\"navbar navbar-default\">\n", + " <div class=\"container-fluid\">\n", + " <div class=\"navbar-header\">\n", + " <a class=\"navbar-brand\" href=\"_Oving5.ipynb\">Øving 5</a>\n", + " </div>\n", + " <ul class=\"nav navbar-nav\">\n", + " <li ><a href=\"Generelt%20om%20lister.ipynb\">Generelt om lister</a></li>\n", + " <li ><a href=\"Lett%20og%20blandet.ipynb\">Lett og blandet</a></li>\n", + " <li ><a href=\"Intro%20til%20numpy-arrays.ipynb\">Intro til numpy-arrays</a></li>\n", + " <li ><a href=\"Kodeforstaelse.ipynb\">KodeforstÃ¥else</a></li>\n", + " <li ><a href=\"Vektorer.ipynb\">Vektorer</a></li>\n", + " <li ><a href=\"Lister%20og%20lokker.ipynb\">Lister og løkker</a></li>\n", + " <li ><a href=\"Teoridelen%20paa%20eksamen.ipynb\">Teoridelen pÃ¥ eksamen</a></li>\n", + " <li ><a href=\"Gangetabell%20og%20lister.ipynb\">Gangetabell og lister</a></li>\n", + " <li ><a href=\"Lotto.ipynb\">Lotto</a></li>\n", + " <li ><a href=\"Tannfeen.ipynb\">Tannfeen</a></li>\n", + " <li class=\"active\"><a href=\"Chattebot.ipynb\">Chattebot</a></li>\n", + " <li ><a href=\"Matriseaddisjon.ipynb\">Matriseaddisjon</a></li>\n", + " </ul>\n", + " </div>\n", + "</nav>\n", + "\n", + "# KodeforstÃ¥else\n", + "\n", + "**LæringsmÃ¥l:**\n", + "\n", + "* KodeforstÃ¥else\n", + "* Innebygde funksjoner\n", + "* lister\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "**a)** Hva returneres i koden under nÃ¥r A= [1,2,3,5,7,9]?\n", + "\n", + "Forklar med én setning hva funksjonen gjør." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "```python\n", + "def myst(A):\n", + " L=len(A)-1\n", + " for i in range(len(A)//2):\n", + " t=A[i]\n", + " A[i] = A[L-i]\n", + " A[L-i]=t\n", + " return A\n", + "```\n", + "\n", + "Dobbeltklikk pÃ¥ teksten under og skriv svaret ditt i boksen som kommer opp." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Svar: < dobbeltklikk her>" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "**b)** Forklar med én setning hva funksjonen myst3([1,2,3,4,5,6,7,8,9,10]) med kode som vist under gjør." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "```python\n", + "import random\n", + "def myst3(a):\n", + " b =[0]*len(a)\n", + " for c in range(len(a)):\n", + " d = random.randint(0,len(a)-1)\n", + " b[c] = a[d]\n", + " del a[d] #del fjerner et bestemt element i listen, her fjerner det a[d].\n", + " return b\n", + "```\n", + "Dobbeltklikk pÃ¥ teksten under og skriv svaret ditt i boksen som kommer opp." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Svar: < dobbelklikk her>" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "**c)** Hva kommer koden til Ã¥ printe?" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "```python\n", + "liste = [4, 9, 6, 3, 8, 7, 5]\n", + "print(liste[-2:6])\n", + "```\n", + "\n", + "Dobbeltklikk pÃ¥ teksten under og skriv svaret ditt i boksen som kommer opp." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Svar: < dobbeltklikk her>" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "**d)** Endre følgende kode slik at den fungerer, og kommenter hva som var feil." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-03T07:54:52.891140Z", + "start_time": "2019-07-03T07:54:52.443003Z" + } + }, + "outputs": [], + "source": [ + "navn = ('Carina', 'erik', 'Magnus', 'Miriam')\n", + "navn[1] = 'Erik'\n", + "print(navn)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "Dobbeltklikk pÃ¥ teksten under og skriv svaret ditt i boksen som kommer opp." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Svar: < dobbeltklikk her>" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "**e)** Hva printes i koden under? Det holder ikke Ã¥ kopiere koden og kjøre den, du mÃ¥ forklare hva som skjer underveis." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "```python\n", + "liste1 = [1,3,2,5,4,6]\n", + "liste1.sort()\n", + "liste2 = [7, 8, 9]\n", + "liste3 = liste1+liste2\n", + "liste3.insert(9, 10)\n", + "liste3.remove(1)\n", + "liste3.reverse()\n", + "print(liste3)\n", + "```\n", + "\n", + "Dobbeltklikk pÃ¥ teksten under og skriv svaret ditt i boksen som kommer opp." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Svar: < dobbeltklikk her>" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "**f)** Hva printes i koden under? Det holder ikke Ã¥ kopiere koden og kjøre den, du mÃ¥ forklare hva som skjer underveis." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "```python\n", + "import nympy as np\n", + "liste1 = [1,3,2]\n", + "A = np.array(liste1)\n", + "B = np.array([5,4,6])\n", + "C = A*2\n", + "print(B+C)\n", + "```\n", + "\n", + "Dobbeltklikk pÃ¥ teksten under og skriv svaret ditt i boksen som kommer opp." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Svar: < dobbeltklikk her>" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "heading_collapsed": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "### Noen innebygde funksjoner" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "insert(indexNummer, element) legger til element pÃ¥ indeksen indexNummer i en liste.\n", + "\n", + "Eksempel:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "liste = [1,2,3,4,'hei', 5]\n", + "liste.insert(3, 'pannekake') #liste = [1, 2, 3, 'pannekake', 4, 'hei', 5]" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "sort() sorterer elementene i en liste etter størrelse, med den minste verdien lengst til venstre." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "liste = [2,3,1,4,6]\n", + "liste.sort() #liste = [1,2,3,4,6]" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "remove(element) fjerner element fra listen." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "liste = [1,2,3,5]\n", + "liste.remove(3) # liste = [1,2,5]" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "reverse() reverserer listen, dvs. at listen blir speilet." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "liste = [1,2,3,5,7]\n", + "liste.reverse() #liste = [7,5,3,2,1]" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3.10.6 64-bit", + "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.10.6" + }, + "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": "aee8b7b246df8f9039afb4144a1f6fd8d2ca17a180786b69acc140d282b71a49" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Ovinger/Oving5/Lett og blandet.ipynb b/Ovinger/Oving5/Lett og blandet.ipynb new file mode 100644 index 0000000..c40c3f3 --- /dev/null +++ b/Ovinger/Oving5/Lett og blandet.ipynb @@ -0,0 +1,283 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "<nav class=\"navbar navbar-default\">\n", + " <div class=\"container-fluid\">\n", + " <div class=\"navbar-header\">\n", + " <a class=\"navbar-brand\" href=\"_Oving5.ipynb\">Øving 5</a>\n", + " </div>\n", + " <ul class=\"nav navbar-nav\">\n", + " <li ><a href=\"Generelt%20om%20lister.ipynb\">Generelt om lister</a></li>\n", + " <li ><a href=\"Lett%20og%20blandet.ipynb\">Lett og blandet</a></li>\n", + " <li ><a href=\"Intro%20til%20numpy-arrays.ipynb\">Intro til numpy-arrays</a></li>\n", + " <li ><a href=\"Kodeforstaelse.ipynb\">KodeforstÃ¥else</a></li>\n", + " <li ><a href=\"Vektorer.ipynb\">Vektorer</a></li>\n", + " <li ><a href=\"Lister%20og%20lokker.ipynb\">Lister og løkker</a></li>\n", + " <li ><a href=\"Teoridelen%20paa%20eksamen.ipynb\">Teoridelen pÃ¥ eksamen</a></li>\n", + " <li ><a href=\"Gangetabell%20og%20lister.ipynb\">Gangetabell og lister</a></li>\n", + " <li ><a href=\"Lotto.ipynb\">Lotto</a></li>\n", + " <li ><a href=\"Tannfeen.ipynb\">Tannfeen</a></li>\n", + " <li class=\"active\"><a href=\"Chattebot.ipynb\">Chattebot</a></li>\n", + " <li ><a href=\"Matriseaddisjon.ipynb\">Matriseaddisjon</a></li>\n", + " </ul>\n", + " </div>\n", + "</nav>\n", + "\n", + "\n", + "# Lett og blandet om lister\n", + "\n", + "**LæringsmÃ¥l:**\n", + "\n", + "* Lister\n", + "\n", + "\n", + "Les om innebygde funksjoner i Python [her](https://docs.python.org/3/library/functions.html), og mer om lister i Python [her](https://docs.python.org/3/tutorial/datastructures.html). Merk at kun noen av disse er pensum, og det vil bli utdelt et noksÃ¥ utfyllende \"formelark\" pÃ¥ eksamen.\n", + "\n" + ] + }, + { + "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": [ + "Lag en funksjon **is_six_at_edge()**, som tar inn en liste med heltall som parameter og returnerer **True** dersom **6** er det første eller det siste elementet i listen. Funksjonen returnerer ellers **False**.\n", + "NB! Funksjonen skal ogsÃ¥ returnere True hvis lista starter **og** slutter pÃ¥ 6. \n", + "\n", + "Eksempel pÃ¥ kjøring:\n", + "```python\n", + "print(is_six_at_edge([1,2,3,4,5,6]))\n", + "True\n", + ">>> \n", + "print(is_six_at_edge([1,2,3,4,5,6,7]))\n", + "False\n", + "```\n", + "***Skriv koden din i boksen under.***" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "heading_collapsed": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "#### Sum og lengde av en liste" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "sum(listen) returnerer den totale summen av alle elementene i listen, for eksempel sum([1,2,3,4]) = 1+2+3+4 = 10.\n", + "\n", + "len(listen) returnerer antall elementer i listen, for eksempel len([1,2,3,4])=4." + ] + }, + { + "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": [ + "Bruk den innebygde funksjonen [sum()](https://docs.python.org/3/library/functions.html#sum), samt len() for Ã¥ lage en funksjon average() som tar inn en liste med tall som parameter og returnerer gjennomsnittsverdien til tallene i listen.\n", + "\n", + "Eksempel pÃ¥ kjøring:\n", + "```python\n", + "print(average([1,3,5,7,9,11]))\n", + "6```\n", + "\n", + "***Skriv koden din i boksen under.***" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-03T07:34:53.293133Z", + "start_time": "2019-07-03T07:34:53.286516Z" + } + }, + "outputs": [], + "source": [] + }, + { + "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": [ + "Bruk den innebygde metoden [**.sort()**](https://docs.python.org/3/howto/sorting.html) for Ã¥ lage en funksjon **median()** som tar inn en liste og finner medianen av listen og returnerer den. Husk at medianen er det midterste elementet i en sortert rekkefølge av listens elementer. \n", + "*NB! Du kan anta at det er et oddetall antall elementer i listen!*\n", + "\n", + "Eksempel pÃ¥ kjøring:\n", + "```python\n", + "print(median([1,2,4,5,7,9,10]))\n", + "5\n", + ">>> \n", + "print(median([1,4,2,5,3]))\n", + "3\n", + "```\n", + "***Skriv koden din i boksen under.***" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-03T07:38:17.625880Z", + "start_time": "2019-07-03T07:38:17.620974Z" + } + }, + "outputs": [], + "source": [] + }, + { + "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": [ + "Ved Ã¥ skrive **my_list.sort()** sorterer du elementene i listen **my_list**. b) og c) kan ogsÃ¥ løses ved hjelp av numpy.arrays. Da kan man bruke noen av de mange innebygde funksjonene som [numpy.mean(a)](https://numpy.org/doc/stable/reference/generated/numpy.mean.html) og [numpy.median(a)](https://numpy.org/doc/stable/reference/generated/numpy.median.html)." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3.10.6 64-bit", + "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.10.6" + }, + "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": "aee8b7b246df8f9039afb4144a1f6fd8d2ca17a180786b69acc140d282b71a49" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Ovinger/Oving5/Lister og lokker.ipynb b/Ovinger/Oving5/Lister og lokker.ipynb new file mode 100644 index 0000000..e54333a --- /dev/null +++ b/Ovinger/Oving5/Lister og lokker.ipynb @@ -0,0 +1,385 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "<nav class=\"navbar navbar-default\">\n", + " <div class=\"container-fluid\">\n", + " <div class=\"navbar-header\">\n", + " <a class=\"navbar-brand\" href=\"_Oving5.ipynb\">Øving 5</a>\n", + " </div>\n", + " <ul class=\"nav navbar-nav\">\n", + " <li ><a href=\"Generelt%20om%20lister.ipynb\">Generelt om lister</a></li>\n", + " <li ><a href=\"Lett%20og%20blandet.ipynb\">Lett og blandet</a></li>\n", + " <li ><a href=\"Intro%20til%20numpy-arrays.ipynb\">Intro til numpy-arrays</a></li>\n", + " <li ><a href=\"Kodeforstaelse.ipynb\">KodeforstÃ¥else</a></li>\n", + " <li ><a href=\"Vektorer.ipynb\">Vektorer</a></li>\n", + " <li ><a href=\"Lister%20og%20lokker.ipynb\">Lister og løkker</a></li>\n", + " <li ><a href=\"Teoridelen%20paa%20eksamen.ipynb\">Teoridelen pÃ¥ eksamen</a></li>\n", + " <li ><a href=\"Gangetabell%20og%20lister.ipynb\">Gangetabell og lister</a></li>\n", + " <li ><a href=\"Lotto.ipynb\">Lotto</a></li>\n", + " <li ><a href=\"Tannfeen.ipynb\">Tannfeen</a></li>\n", + " <li class=\"active\"><a href=\"Chattebot.ipynb\">Chattebot</a></li>\n", + " <li ><a href=\"Matriseaddisjon.ipynb\">Matriseaddisjon</a></li>\n", + " </ul>\n", + " </div>\n", + "</nav>\n", + "\n", + "# Lister og løkker\n", + "\n", + "**LæringsmÃ¥l:**\n", + "\n", + "* Lister\n", + "\n", + "* Løkker\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "heading_collapsed": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "### Iterering gjennom en liste" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "For Ã¥ iterere/gÃ¥ gjennom elementene i en liste brukes løkker, og dette gjøres hovedsakelig pÃ¥ to ulike mÃ¥ter:\n", + "\n", + "1) For-løkker, ved Ã¥ bruke range()-funksjonen og indekser.\n", + "\n", + "Eksempel:" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1\n", + "2\n", + "3\n", + "4\n", + "5\n" + ] + } + ], + "source": [ + "liste = [1,2,3,4,5]\n", + "lengde = len(liste) #5\n", + "for x in range(lengde):\n", + " print(liste[x])" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "2) For-in-løkker, som henter ut ett og ett element av en liste." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1\n", + "2\n", + "3\n", + "4\n", + "5\n" + ] + } + ], + "source": [ + "liste = [1,2,3,4,5]\n", + "for x in liste:\n", + " print(x)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Disse metodene brukes om hverandre, og det er lurt Ã¥ kunne bruke begge. Begge gir samme output. **Kjør dem selv for Ã¥ verifisere med ctr + enter**" + ] + }, + { + "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": [ + "Lag en liste **number_list** med alle heltallene fra 0 til og med 99.\n", + "\n", + "Eksempel pÃ¥ kjøring:\n", + "\n", + "```python\n", + ">>>print(number_list)\n", + "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10,..., 99]\n", + "```\n", + "***Skriv svaret ditt i boksen under.***" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-03T08:50:15.387298Z", + "start_time": "2019-07-03T08:50:15.193943Z" + } + }, + "outputs": [], + "source": [] + }, + { + "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": [ + "For Ã¥ legge til et nytt **element** til en liste (**my_list**) kan du bruke den innebygde funksjonen \"append\" slik: my_list.append(element)." + ] + }, + { + "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": [ + "Summer sammen alle tall i listen som er delelig pÃ¥ 3 eller 10. (Summen skal bli 1953)\n", + "\n", + "***Skriv svaret ditt i boksen under.***" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-03T08:51:59.090936Z", + "start_time": "2019-07-03T08:51:58.991126Z" + } + }, + "outputs": [], + "source": [] + }, + { + "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": [ + "Bytt plass pÃ¥ alle nabo partall og oddetall i listen. (listen skal nÃ¥ være: [1, 0, 3, 2, 5, 4, 7, 6, 9, 8,..., 98])\n", + "\n", + "***Skriv svaret ditt i boksen under.***" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "### d)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "Lag en ny liste **reversed_list** som inneholder elementene i **number_list** i motsatt rekkefølge. (Merk: uten Ã¥ bruke innebygde funksjoner i Python)\n", + "\n", + "Dersom du nÃ¥ printer listen skal du fÃ¥:\n", + " \n", + "```python\n", + "[98, 99, 96, 97, 94, 95, 92, 93, 90, 91, 88, 89, 86, 87, 84, 85, 82, 83, 80, 81, 78, 79, 76, 77, 74, 75, 72, 73, 70, 71, 68, 69, 66, 67, 64, 65, 62, 63, 60, 61, 58, 59, 56, 57, 54, 55, 52, 53, 50, 51, 48, 49, 46, 47, 44, 45, 42, 43, 40, 41, 38, 39, 36, 37, 34, 35, 32, 33, 30, 31, 28, 29, 26, 27, 24, 25, 22, 23, 20, 21, 18, 19, 16, 17, 14, 15, 12, 13, 10, 11, 8, 9, 6, 7, 4, 5, 2, 3, 0, 1]\n", + "```\n", + "\n", + "***Skriv svaret ditt i boksen under.***" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3.10.6 64-bit", + "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.10.6" + }, + "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": "aee8b7b246df8f9039afb4144a1f6fd8d2ca17a180786b69acc140d282b71a49" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Ovinger/Oving5/Lotto.ipynb b/Ovinger/Oving5/Lotto.ipynb new file mode 100644 index 0000000..6452b61 --- /dev/null +++ b/Ovinger/Oving5/Lotto.ipynb @@ -0,0 +1,435 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "<nav class=\"navbar navbar-default\">\n", + " <div class=\"container-fluid\">\n", + " <div class=\"navbar-header\">\n", + " <a class=\"navbar-brand\" href=\"_Oving5.ipynb\">Øving 5</a>\n", + " </div>\n", + " <ul class=\"nav navbar-nav\">\n", + " <li ><a href=\"Generelt%20om%20lister.ipynb\">Generelt om lister</a></li>\n", + " <li ><a href=\"Lett%20og%20blandet.ipynb\">Lett og blandet</a></li>\n", + " <li ><a href=\"Intro%20til%20numpy-arrays.ipynb\">Intro til numpy-arrays</a></li>\n", + " <li ><a href=\"Kodeforstaelse.ipynb\">KodeforstÃ¥else</a></li>\n", + " <li ><a href=\"Vektorer.ipynb\">Vektorer</a></li>\n", + " <li ><a href=\"Lister%20og%20lokker.ipynb\">Lister og løkker</a></li>\n", + " <li ><a href=\"Teoridelen%20paa%20eksamen.ipynb\">Teoridelen pÃ¥ eksamen</a></li>\n", + " <li ><a href=\"Gangetabell%20og%20lister.ipynb\">Gangetabell og lister</a></li>\n", + " <li ><a href=\"Lotto.ipynb\">Lotto</a></li>\n", + " <li ><a href=\"Tannfeen.ipynb\">Tannfeen</a></li>\n", + " <li class=\"active\"><a href=\"Chattebot.ipynb\">Chattebot</a></li>\n", + " <li ><a href=\"Matriseaddisjon.ipynb\">Matriseaddisjon</a></li>\n", + " </ul>\n", + " </div>\n", + "</nav>\n", + "\n", + "# Lotto\n", + "\n", + "**LæringsmÃ¥l:**\n", + "\n", + "* Lister\n", + "* Tilfeldige tall\n", + "\n", + "\n", + "I denne oppgaven lage du lage en lottosimulator. \n", + "\n", + "Reglene er som følger:\n", + "\n", + "* Det trekkes ut 7 lottotall og 3 tilleggstall fra og med 1 til og med 34. Alle tallene som trekkes skal være unike.\n", + "* Premier deles ut basert pÃ¥ følgende tabell:\n", + "\n", + "Premiergruppe|Premie (kr)\n", + ":---|---\n", + "7 rette\t|2 749 455\n", + "6 rette + 1 tilleggstall\t|102 110\n", + "6 rette\t|3 385\n", + "5 rette\t|95\n", + "4 rette + 1 tilleggstall\t|45" + ] + }, + { + "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": [ + "Lag en liste som heter `numbers` og som inneholder alle heltall fra og med 1 til og med 34.\n", + "\n", + "***Skriv koden din i boksen under.***" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-03T10:21:03.176781Z", + "start_time": "2019-07-03T10:21:03.167560Z" + } + }, + "outputs": [], + "source": [] + }, + { + "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": [ + "Lag en liste som heter `myGuess` med 7 tall. Denne listen inneholder tallene som du tipper.\n", + "\n", + "***Skriv koden din i boksen under.***" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-03T10:21:45.639510Z", + "start_time": "2019-07-03T10:21:45.634558Z" + } + }, + "outputs": [], + "source": [] + }, + { + "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": [ + "Lag en funksjon som tar inn `n` som argument og som trekker ut `n` tall ut av listen `numbers` og legger de i en egen liste. \n", + "For Ã¥ gjøre ting tilfeldig: `import random` og `random.randint(n,N)` gir tilfeldige tall fra og med n til og med N.\n", + "\n", + "Eksempel pÃ¥ kjøring:\n", + "\n", + "```python\n", + ">>>print(drawNumbers(numbers, 7))\n", + "[16, 33, 5, 20, 7, 4, 8]\n", + "```\n", + "\n", + "***Skriv koden din i boksen under.***" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-03T10:25:33.636784Z", + "start_time": "2019-07-03T10:25:33.631639Z" + } + }, + "outputs": [], + "source": [] + }, + { + "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": [ + "Hint: Bruk funksjonene `pop()` og `append()` for Ã¥ fjerne og legge til elementer i en liste. Husk at pop fjerner et element i en indeks i lista, den fjerner ikke tallet. SÃ¥ numbers.pop(rand_num) fjerner elementet pÃ¥ indeks rand_num - altsÃ¥ hvis rand_num er 13 fjernes tallet pÃ¥ indeks 13, ikke tallet 13!" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "### d)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "Lag funksjonen `compList` som sammenligner to lister med tall. Antall like tall i listene skal returneres.\n", + "\n", + "Eksempel pÃ¥ kjøring:\n", + "\n", + "```python\n", + ">>>print(compList(drawNumbers(numbers,7),myGuess))\n", + "1\n", + "```\n", + "\n", + "***Skriv koden din i boksen under.***" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-03T10:28:03.696473Z", + "start_time": "2019-07-03T10:28:03.691094Z" + } + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "### e)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "Lag en funksjon som tar inn antall like tall og like tilleggstall, og returnerer premien du har vunnet.\n", + "\n", + "Eksempel pÃ¥ kjøring:\n", + "\n", + "```python\n", + ">>>print(Winnings(7,1))\n", + "2749455\n", + ">>>print(Winnings(5,2))\n", + "95\n", + ">>>print(Winnings(3,1))\n", + "0\n", + "```\n", + "\n", + "***Skriv koden din i boksen under.***" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-03T10:30:20.037475Z", + "start_time": "2019-07-03T10:30:20.032125Z" + } + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "### f)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "Funksjonene skal settes sammen i main() slik at dette blir en fullverdig lottosimulator (for en lottorekke). Tallene du skal trekke ut (bÃ¥de lottotallene og tilleggstallene) kan legges i samme liste. Funksjonen `compList` kan da sammenligne de første 7 tallene, og sÃ¥ de siste 3 tallene, for Ã¥ finne ut hvor mange like tall du har. main() skal returnere hvor mye du har tjent eller mest sannsynlig tapt pÃ¥ denne lottorekken. Dersom en lottorekke kosten 5 kroner, vil -5 returneres dersom Winnings() er 0. Hvis du er heldig og Winnings() blir 95 skal 90 returneres fra main(). \n", + "\n", + "**Husk at du kan bruke alle funksjoner du har definert over!**\n", + "\n", + "***Skriv koden din i boksen under.***" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-03T10:32:57.485045Z", + "start_time": "2019-07-03T10:32:57.477602Z" + } + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "### g) frivillig" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "Finn ut hvor mye man har vunnet etter Ã¥ ha tippet en million ganger. Anta at premiepotten er det samme hver uke, og at en lottorekke koster 5 kroner.\n", + "\n", + "***Skriv koden din i boksen under.***" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-03T10:33:24.728040Z", + "start_time": "2019-07-03T10:33:24.722740Z" + } + }, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3.10.6 64-bit", + "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.10.6" + }, + "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": "aee8b7b246df8f9039afb4144a1f6fd8d2ca17a180786b69acc140d282b71a49" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Ovinger/Oving5/Matriseaddisjon.ipynb b/Ovinger/Oving5/Matriseaddisjon.ipynb new file mode 100644 index 0000000..12aa85d --- /dev/null +++ b/Ovinger/Oving5/Matriseaddisjon.ipynb @@ -0,0 +1,207 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "<nav class=\"navbar navbar-default\">\n", + " <div class=\"container-fluid\">\n", + " <div class=\"navbar-header\">\n", + " <a class=\"navbar-brand\" href=\"_Oving5.ipynb\">Øving 5</a>\n", + " </div>\n", + " <ul class=\"nav navbar-nav\">\n", + " <li ><a href=\"Generelt%20om%20lister.ipynb\">Generelt om lister</a></li>\n", + " <li ><a href=\"Lett%20og%20blandet.ipynb\">Lett og blandet</a></li>\n", + " <li ><a href=\"Intro%20til%20numpy-arrays.ipynb\">Intro til numpy-arrays</a></li>\n", + " <li ><a href=\"Kodeforstaelse.ipynb\">KodeforstÃ¥else</a></li>\n", + " <li ><a href=\"Vektorer.ipynb\">Vektorer</a></li>\n", + " <li ><a href=\"Lister%20og%20lokker.ipynb\">Lister og løkker</a></li>\n", + " <li ><a href=\"Teoridelen%20paa%20eksamen.ipynb\">Teoridelen pÃ¥ eksamen</a></li>\n", + " <li ><a href=\"Gangetabell%20og%20lister.ipynb\">Gangetabell og lister</a></li>\n", + " <li ><a href=\"Lotto.ipynb\">Lotto</a></li>\n", + " <li ><a href=\"Tannfeen.ipynb\">Tannfeen</a></li>\n", + " <li class=\"active\"><a href=\"Chattebot.ipynb\">Chattebot</a></li>\n", + " <li ><a href=\"Matriseaddisjon.ipynb\">Matriseaddisjon</a></li>\n", + " </ul>\n", + " </div>\n", + "</nav>\n", + "\n", + "# Matriseaddisjon\n", + "\n", + "**LæringsmÃ¥l:**\n", + "\n", + "* Lister av flere dimensjoner\n", + "\n", + "\n", + "I denne oppgaven skal du implementere noen funksjoner slik at to matriser blir skrevet ut pÃ¥ et fint format og addert med hverandre. \n", + "\n", + "En matrise er et godt eksempel pÃ¥ en todimensjonal liste av tall som har et bestemt antall rader x og et bestemt antall kolonner y. Du kan tenke pÃ¥ en matrise som en liste med x antall elementer, hvor hvert element er en liste av størrelse y. I denne oppgaven skal vi se pÃ¥ matriseaddisjon. I denne oppgaven definerer vi addisjon av to matriser pÃ¥ samme mÃ¥te som med vektoraddisjon: dersom vi skal summere matrise a med b og kaller den nye matrisen for c, vil *c[x][y]* være *a[x][y]* + *b[x][y]*, hvor *c[x][y]* er elementet i matrisen c som befinner seg pÃ¥ rad *x* og kolonne *y*.\n", + "\n", + "Du fÃ¥r gitt en main-funksjon med følgende kode:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-03T11:03:43.356638Z", + "start_time": "2019-07-03T11:03:43.345161Z" + } + }, + "outputs": [], + "source": [ + "def main():\n", + " A = random_matrise(4,3)\n", + " print_matrise(A, 'A')\n", + " B = random_matrise(3,4)\n", + " print_matrise(B, 'B')\n", + " C = random_matrise(3,4)\n", + " print_matrise(C, 'C')\n", + " D = matrise_addisjon(A,B)\n", + " E = matrise_addisjon(B,C)\n", + " print_matrise(E, 'B+C' )" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-03T11:03:58.395784Z", + "start_time": "2019-07-03T11:03:58.385979Z" + }, + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "som, etter at du har gjort oppgaven, skal gi følgende utskrift:\n", + "\n", + "```python\n", + "A=[\n", + " [1, 8, 4, 3]\n", + " [5, 1, 5, 8]\n", + " [9, 5, 8, 0]\n", + " ]\n", + "B=[\n", + " [7, 3, 3]\n", + " [2, 1, 7]\n", + " [2, 2, 3]\n", + " [3, 5, 9]\n", + " ]\n", + "C=[\n", + " [4, 4, 6]\n", + " [1, 9, 0]\n", + " [9, 8, 5]\n", + " [2, 9, 5]\n", + " ]\n", + "Matrisene er ikke av samme dimensjon # A og B har ulike dimensjoner (ulikt antall rader og kolonner)\n", + "B+C=[\n", + " [11, 7, 9]\n", + " [3, 10, 7]\n", + " [11, 10, 8]\n", + " [5, 14, 14]\n", + " ]\n", + " ```\n", + " " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Din oppgave**\n", + "\n", + "Implementer funksjonene `random_matrise(bredde, høyde)`, `print_matrise(matrise, navn)` og `matrise_addisjon(a, b)` slik at utskriften av `main()` gir utskriften over. Du kan velge om du bruker vanlige lister eller numpy-arrays i denne oppgaven. Numpy-arrays har flere fordeler her, blant annet at man kan legge sammen to matriser med \"+\" og dette vil funke som det gjør i matte(slik utskriften over viser). Merk at dette ikke er tilfelle med vanlige lister sÃ¥ da mÃ¥ du selv itere gjennom listene og legge sammen tallene. Det er mange mÃ¥ter Ã¥ løse oppgaven pÃ¥. Hvis du trenger en \"tom\" array i numpy, kan en array med alle verdier lik 0 lages med [numpy.zeros](https://numpy.org/doc/stable/reference/generated/numpy.zeros.html).\n", + "\n", + "1. Funksjonen `random_matrise(bredde, høyde)` skal returnere en matrise med *høyde* antall rader og *bredde* antall kolonner. Matrisen skal være fylt med tilfeldige tall fra og med 0 til 10. Bruk random-biblioteket. \n", + "2. `print_matrise(matrise, navn)` skal printe ut matrisene pÃ¥ samme format som vist i utskriften over. \n", + "3. `matrise_addisjon(a, b)` skal ta inn to matriser og returnere en matrise som er summen av a og b. Dersom to matriser er av ulik størrelse er det umulig Ã¥ addere matrisene og \"Matrisene er ikke av samme dimensjon\" skal skrives ut. \n", + "\n", + "***Skriv koden din i boksen under.***" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "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": [ + "For Ã¥ sjekke om to matriser er av samme dimensjon mÃ¥ du sjekke om de bÃ¥de har samme antall rader og samme antall kolonner. len(matrise) returnerer antall rader en matrise har, og len(matrise[0]) returnerer antall kolonner i matrisen. Dette funker ogsÃ¥ for numpy arrays. " + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3.10.6 64-bit", + "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.10.6" + }, + "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": "aee8b7b246df8f9039afb4144a1f6fd8d2ca17a180786b69acc140d282b71a49" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Ovinger/Oving5/Tannfeen.ipynb b/Ovinger/Oving5/Tannfeen.ipynb new file mode 100644 index 0000000..833dc22 --- /dev/null +++ b/Ovinger/Oving5/Tannfeen.ipynb @@ -0,0 +1,183 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "<nav class=\"navbar navbar-default\">\n", + " <div class=\"container-fluid\">\n", + " <div class=\"navbar-header\">\n", + " <a class=\"navbar-brand\" href=\"_Oving5.ipynb\">Øving 5</a>\n", + " </div>\n", + " <ul class=\"nav navbar-nav\">\n", + " <li ><a href=\"Generelt%20om%20lister.ipynb\">Generelt om lister</a></li>\n", + " <li ><a href=\"Lett%20og%20blandet.ipynb\">Lett og blandet</a></li>\n", + " <li ><a href=\"Intro%20til%20numpy-arrays.ipynb\">Intro til numpy-arrays</a></li>\n", + " <li ><a href=\"Kodeforstaelse.ipynb\">KodeforstÃ¥else</a></li>\n", + " <li ><a href=\"Vektorer.ipynb\">Vektorer</a></li>\n", + " <li ><a href=\"Lister%20og%20lokker.ipynb\">Lister og løkker</a></li>\n", + " <li ><a href=\"Teoridelen%20paa%20eksamen.ipynb\">Teoridelen pÃ¥ eksamen</a></li>\n", + " <li ><a href=\"Gangetabell%20og%20lister.ipynb\">Gangetabell og lister</a></li>\n", + " <li ><a href=\"Lotto.ipynb\">Lotto</a></li>\n", + " <li ><a href=\"Tannfeen.ipynb\">Tannfeen</a></li>\n", + " <li class=\"active\"><a href=\"Chattebot.ipynb\">Chattebot</a></li>\n", + " <li ><a href=\"Matriseaddisjon.ipynb\">Matriseaddisjon</a></li>\n", + " </ul>\n", + " </div>\n", + "</nav>\n", + "\n", + "# Tannfeen\n", + "\n", + "**LæringsmÃ¥l:**\n", + "\n", + "* Lister\n", + "* Løkker\n", + " \n", + "\n", + "*Overformynderiet for tannfeer og python-programmerere* har vedtatt at istedenfor Ã¥ betale 20 kroner for hver enkelt tann et barn mister og putter i vannglasset sitt, er de nÃ¥ nødt til Ã¥ betale per gram tann. Det ble bestemt at ett gram tann er verd 1 krone. Tannfeer vil helst bruke sÃ¥ store mynter de kan (i verdi). Gyldige mynter er [20,10,5,1].\n", + "\n", + "Siden tannfeen besøker sÃ¥ mange, vil de ha et program som skal kunne regne ut dette fra lister. Det vil si at programmet tar inn en liste av tannvekter, og fÃ¥r tilbake en liste (av lister) over hvilke mynter som trengs for tennene.\n", + "\n", + "Eksempel:\n", + "\n", + "```python\n", + "teeth = [53,28]\n", + "tooth_fairy(teeth)\n", + "\n", + ">>> [[2,1,0,3],[1,0,1,3]]\n", + "```\n", + "\n", + "Eksempelet over vil si at for 53g vil man fÃ¥ 2 stk 20kr, 1 stk 10kr, 0 stk 5kr og 3 stk 1kr, og for 28g vil man fÃ¥ 1 stk 20kr, 0 stk 10kr, 1 stk 5kr og 3 stk 1kr.\n", + "\n", + "**Oppgave:** Lag programmet og test med listen under." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-03T10:42:45.712190Z", + "start_time": "2019-07-03T10:42:45.702194Z" + } + }, + "outputs": [], + "source": [ + "teeth = [95,103,71,99,114,64,95,53,97,114,109,11,2,21,45,2,26,81,54,14,118,108,117,27,115,43,70,58,107]" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-03T10:42:50.281923Z", + "start_time": "2019-07-03T10:42:50.277659Z" + } + }, + "outputs": [], + "source": [ + "def tooth_fairy(teeth):\n", + " \"\"\"Skriv koden din her\"\"\"" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "Dersom du skrevet koden riktig skal listen over gi følgende utskrift:\n", + "\n", + "```python\n", + "[[4, 1, 1, 0], [5, 0, 0, 3], [3, 1, 0, 1], [4, 1, 1, 4], [5, 1, 0, 4], [3, 0, 0, 4], \n", + "[4, 1, 1, 0], [2, 1, 0, 3], [4, 1, 1, 2], [5, 1, 0, 4], [5, 0, 1, 4], [0, 1, 0, 1], \n", + "[0, 0, 0, 2], [1, 0, 0, 1], [2, 0, 1, 0], [0, 0, 0, 2], [1, 0, 1, 1], [4, 0, 0, 1], \n", + "[2, 1, 0, 4], [0, 1, 0, 4], [5, 1, 1, 3], [5, 0, 1, 3], [5, 1, 1, 2], [1, 0, 1, 2], \n", + "[5, 1, 1, 0], [2, 0, 0, 3], [3, 1, 0, 0], [2, 1, 1, 3], [5, 0, 1, 2]]\n", + "```\n", + "PÃ¥ penere form:\n", + "```python\n", + "20: 4 , 10: 1 , 5: 1 , 1: 0\n", + "20: 5 , 10: 0 , 5: 0 , 1: 3\n", + "20: 3 , 10: 1 , 5: 0 , 1: 1\n", + "20: 4 , 10: 1 , 5: 1 , 1: 4\n", + "20: 5 , 10: 1 , 5: 0 , 1: 4\n", + "20: 3 , 10: 0 , 5: 0 , 1: 4\n", + "20: 4 , 10: 1 , 5: 1 , 1: 0\n", + "20: 2 , 10: 1 , 5: 0 , 1: 3\n", + "20: 4 , 10: 1 , 5: 1 , 1: 2\n", + "20: 5 , 10: 1 , 5: 0 , 1: 4\n", + "20: 5 , 10: 0 , 5: 1 , 1: 4\n", + "20: 0 , 10: 1 , 5: 0 , 1: 1\n", + "20: 0 , 10: 0 , 5: 0 , 1: 2\n", + "20: 1 , 10: 0 , 5: 0 , 1: 1\n", + "20: 2 , 10: 0 , 5: 1 , 1: 0\n", + "20: 0 , 10: 0 , 5: 0 , 1: 2\n", + "20: 1 , 10: 0 , 5: 1 , 1: 1\n", + "20: 4 , 10: 0 , 5: 0 , 1: 1\n", + "20: 2 , 10: 1 , 5: 0 , 1: 4\n", + "20: 0 , 10: 1 , 5: 0 , 1: 4\n", + "20: 5 , 10: 1 , 5: 1 , 1: 3\n", + "20: 5 , 10: 0 , 5: 1 , 1: 3\n", + "20: 5 , 10: 1 , 5: 1 , 1: 2\n", + "20: 1 , 10: 0 , 5: 1 , 1: 2\n", + "20: 5 , 10: 1 , 5: 1 , 1: 0\n", + "20: 2 , 10: 0 , 5: 0 , 1: 3\n", + "20: 3 , 10: 1 , 5: 0 , 1: 0\n", + "20: 2 , 10: 1 , 5: 1 , 1: 3\n", + "20: 5 , 10: 0 , 5: 1 , 1: 2\n", + "```" + ] + } + ], + "metadata": { + "celltoolbar": "Edit Metadata", + "kernelspec": { + "display_name": "Python 3.10.6 64-bit", + "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.10.6" + }, + "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": "aee8b7b246df8f9039afb4144a1f6fd8d2ca17a180786b69acc140d282b71a49" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Ovinger/Oving5/Teoridelen paa eksamen.ipynb b/Ovinger/Oving5/Teoridelen paa eksamen.ipynb new file mode 100644 index 0000000..0f089ff --- /dev/null +++ b/Ovinger/Oving5/Teoridelen paa eksamen.ipynb @@ -0,0 +1,192 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "<nav class=\"navbar navbar-default\">\n", + " <div class=\"container-fluid\">\n", + " <div class=\"navbar-header\">\n", + " <a class=\"navbar-brand\" href=\"_Oving5.ipynb\">Øving 5</a>\n", + " </div>\n", + " <ul class=\"nav navbar-nav\">\n", + " <li ><a href=\"Generelt%20om%20lister.ipynb\">Generelt om lister</a></li>\n", + " <li ><a href=\"Lett%20og%20blandet.ipynb\">Lett og blandet</a></li>\n", + " <li ><a href=\"Intro%20til%20numpy-arrays.ipynb\">Intro til numpy-arrays</a></li>\n", + " <li ><a href=\"Kodeforstaelse.ipynb\">KodeforstÃ¥else</a></li>\n", + " <li ><a href=\"Vektorer.ipynb\">Vektorer</a></li>\n", + " <li ><a href=\"Lister%20og%20lokker.ipynb\">Lister og løkker</a></li>\n", + " <li ><a href=\"Teoridelen%20paa%20eksamen.ipynb\">Teoridelen pÃ¥ eksamen</a></li>\n", + " <li ><a href=\"Gangetabell%20og%20lister.ipynb\">Gangetabell og lister</a></li>\n", + " <li ><a href=\"Lotto.ipynb\">Lotto</a></li>\n", + " <li ><a href=\"Tannfeen.ipynb\">Tannfeen</a></li>\n", + " <li class=\"active\"><a href=\"Chattebot.ipynb\">Chattebot</a></li>\n", + " <li ><a href=\"Matriseaddisjon.ipynb\">Matriseaddisjon</a></li>\n", + " </ul>\n", + " </div>\n", + "</nav>\n", + "\n", + "# Teoridelen pÃ¥ eksamen\n", + "\n", + "**LæringsmÃ¥l:**\n", + "\n", + "* Lister\n", + "* funksjoner\n", + "\n", + "\n", + "I denne oppgaven skal du sammenligne to lister og studere hvor like de er hverandre. \n", + "\n", + "Tidligere har 25% av eksamenen i TDT4110 vært flervalgsoppgaver fordelt pÃ¥ 20 oppgaver. Riktige svar for oppgavene fra en eksamen var som følger:" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "Riktige svar|- |- |-\n", + "---|---|---|---\n", + "1.A|6.A|11.D|16.A\n", + "2.C\t|7.B|\t12.A|\t17.B\n", + "3.B|\t8.A\t|13.C\t|18.A\n", + "4.D\t|9.C|\t14.C|\t19.C\n", + "5.A\t|10.A|\t15.B|\t20.D\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "**a)** \n", + "Lag en liste *fasit* som inneholder de korrekte svarene.\n", + "\n", + "***Skriv svaret ditt i boksen under.***" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-03T09:50:49.055719Z", + "start_time": "2019-07-03T09:50:49.049558Z" + } + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "**b)**\n", + "Lag en funksjon `sjekk_svar` som tar inn studentens_svar som argument. studentens_svar er en liste som inneholder en students svar pÃ¥ oppgavene. Ved Ã¥ sammenligne studenten sine svar med de riktige svarene, skal funksjonen returnere hvor mange prosent av oppgavene studenten klarte. \n", + "\n", + "Eksempel pÃ¥ kjøring:\n", + "\n", + "```python\n", + "print(sjekk_svar(['A', 'C', 'B', 'D', 'A', 'A', 'B', 'A', 'C', 'A', 'D', 'A', 'C', 'C', 'B', 'A', 'B', 'A', 'A', 'C'])) # Gir 90% riktig\n", + "print(sjekk_svar(fasit)) # Gir 100% riktig\n", + "```\n", + "\n", + "***Skriv svaret ditt i boksen under.***" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-03T09:53:05.112502Z", + "start_time": "2019-07-03T09:53:05.105864Z" + } + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "Har du gjort det pÃ¥ riktig mÃ¥te skal koden under gi 20% riktig. Trykk pÃ¥ blokka under og trykk `ctrl + enter` for Ã¥ kjøre den." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "print(sjekk_svar(['B', 'B', 'B', 'B', 'B', 'B', 'B', 'B', 'B', 'B', 'B', 'B', 'B', 'B', 'B', 'B', 'B', 'B', 'B', 'B']))" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3.8.5 32-bit", + "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.8.5" + }, + "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": "03299db1fae60594c2125507d91406fcab8a4e5ee4ae8637248853dec3226cad" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Ovinger/Oving5/Vektorer.ipynb b/Ovinger/Oving5/Vektorer.ipynb new file mode 100644 index 0000000..631374a --- /dev/null +++ b/Ovinger/Oving5/Vektorer.ipynb @@ -0,0 +1,457 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "<nav class=\"navbar navbar-default\">\n", + " <div class=\"container-fluid\">\n", + " <div class=\"navbar-header\">\n", + " <a class=\"navbar-brand\" href=\"_Oving5.ipynb\">Øving 5</a>\n", + " </div>\n", + " <ul class=\"nav navbar-nav\">\n", + " <li ><a href=\"Generelt%20om%20lister.ipynb\">Generelt om lister</a></li>\n", + " <li ><a href=\"Lett%20og%20blandet.ipynb\">Lett og blandet</a></li>\n", + " <li ><a href=\"Intro%20til%20numpy-arrays.ipynb\">Intro til numpy-arrays</a></li>\n", + " <li ><a href=\"Kodeforstaelse.ipynb\">KodeforstÃ¥else</a></li>\n", + " <li ><a href=\"Vektorer.ipynb\">Vektorer</a></li>\n", + " <li ><a href=\"Lister%20og%20lokker.ipynb\">Lister og løkker</a></li>\n", + " <li ><a href=\"Teoridelen%20paa%20eksamen.ipynb\">Teoridelen pÃ¥ eksamen</a></li>\n", + " <li ><a href=\"Gangetabell%20og%20lister.ipynb\">Gangetabell og lister</a></li>\n", + " <li ><a href=\"Lotto.ipynb\">Lotto</a></li>\n", + " <li ><a href=\"Tannfeen.ipynb\">Tannfeen</a></li>\n", + " <li class=\"active\"><a href=\"Chattebot.ipynb\">Chattebot</a></li>\n", + " <li ><a href=\"Matriseaddisjon.ipynb\">Matriseaddisjon</a></li>\n", + " </ul>\n", + " </div>\n", + "</nav>\n", + "\n", + "# Vektorer\n", + "\n", + "**LæringsmÃ¥l:**\n", + "\n", + "* Lister\n", + "\n", + "I denne oppgaven skal vi studere lister bestÃ¥ende av tall, dvs. en vektor. Videre skal vi studere prikkprodukt og skalering av vektorer. \n", + "\n", + "En liste kan brukes til Ã¥ representere en matematisk vektor.\n", + "En av forskjellene mellom lister og vektorer er at lister kan inneholde elementer av forskjellige typer (f.eks bÃ¥de tall og strenger). I denne oppgaven skal du bruke lister til Ã¥ implementere tredimensjonale vektorer, altsÃ¥ vektorer med tre elementer.\n", + "\n", + "**En vektor x=(x,y,z) har lengde $\\sqrt{x^{2}+y^{2}+z^{2}}$. Den kan multipliseres med tall, og vektormultipliseres med andre vektorer.**\n", + "\n", + "Multiplikasjon med tall, ogsÃ¥ kalt skalarmultiplikasjon, ganger hver komponent i vektoren med et tall (skalar).\n", + "\n", + "Prikkprodukt er multiplikasjon av to vektorer med samme lengde. Prikkprodukt og skalarmultiplikasjon er forklart i Eksempel 1.\n", + "\n", + "Eksempel 1:\n", + "\n", + "```python\n", + "Prikkprodukt:\n", + "u*v = u1*v1 + v2*u2 + v3*u3, hvor v = [v1,v2,v3] og u = [u1,u2,u3]\n", + "Numerisk eksempel:\n", + "[3,7,1]*[2,-4,8]=3*2+7*(-4)+1*8=-14\n", + "```\n", + "```python\n", + "Skalarmultiplikasjon:\n", + "c*[v1,v2,v3] = [c*v1,c*v2,c*v3]\n", + "Numerisk eksempel:\n", + "2*[3,7,1] = [6,14,2]\n", + "```\n", + "\n", + "Gjennom oppgave a til f skal du lage et program som bruker forskjellige funksjoner til Ã¥ gjøre forskjellige beregninger pÃ¥ vektorer." + ] + }, + { + "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": [ + "Lag en funksjon som lager en liste med 3 elementer, hvor alle elementene er heltall f.o.m. -10 t.o.m. 10, og returnerer denne. Benytt deg av random-biblioteket.\n", + "\n", + "Eksempel pÃ¥ kjøring\n", + "\n", + "```python\n", + ">>>print(make_vec())\n", + "[0, -9, 5]\n", + "```\n", + "***Skriv svaret ditt i boksen under.***" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-03T08:13:38.430041Z", + "start_time": "2019-07-03T08:13:38.423591Z" + } + }, + "outputs": [], + "source": [] + }, + { + "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": [ + "Lag en funksjon som tar inn en liste/vektor og et navn til denne vektoren som argumenter. Funksjonen skal skrive ut vektoren pÃ¥ en vakker mÃ¥te.\n", + "\n", + "Eksempel pÃ¥ utskrift:\n", + "```python\n", + ">>>vector_print([1.20,4.50,4.40],'vec1')\n", + "vec1 = [1.20, 4.50, 4.40]\n", + "```\n", + "***Skriv svaret ditt i boksen under.***" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "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": [ + "Lag en funksjon `scalar_mult(liste,skalar)` som tar inn en liste/vektor og en skalar som argumenter. Skalarmultipliserer vektoren og returnerer den nye vektoren, liste2. Denne oppgaven er enklere hvis man gjør om listen til en numpy.array.\n", + "\n", + "***Skriv svaret ditt i boksen under.***" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-03T08:22:37.574523Z", + "start_time": "2019-07-03T08:22:37.566574Z" + } + }, + "outputs": [], + "source": [ + "#skriv koden din her" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "Dersom du har gjort det riktig skal kodesnutten under printe lista **[4.8, 18.0, 17.6]**. Trykk `ctrl + enter` for Ã¥ kjøre testen." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "print(scalar_mult([1.2,4.5,4.4],4))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "### d)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "Lag en funksjon `vec_len(vektor)` som tar inn en vektor som argument, og regner ut og returnerer dens lengde. \n", + "\n", + "NB: Her er det snakk om lengden av vektoren gitt av formelen i innledningen, ikke len(vektor)\n", + "\n", + "***Skriv svaret ditt i boksen under.***" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-03T08:28:04.876329Z", + "start_time": "2019-07-03T08:28:04.871381Z" + } + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "Dersom du har gjort det riktig skal kodesnutten under printe tallet **5.0990195135927845**" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "print(vec_len([1,4,3]))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "### e)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-03T08:30:48.040601Z", + "start_time": "2019-07-03T08:30:48.031937Z" + }, + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "Lag en funksjon `vector_dot_product(vec1,vec2)` som tar inn to vektorer som argumenter og returnerer indreproduktet/prikkproduktet av de to vektorene. \n", + "\n", + "Du kan gÃ¥ ut ifra at vektorene har lik lengde. Oppgaven kan løses effektivt ved bruk av numpy, men det er ikke et krav.\n", + "\n", + "***Skriv svaret ditt i boksen under.***" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-03T08:38:21.863113Z", + "start_time": "2019-07-03T08:38:21.858576Z" + } + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "Dersom du har gjort det riktig skal koden under printe **29.400**" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-03T08:40:41.435567Z", + "start_time": "2019-07-03T08:40:41.152222Z" + } + }, + "outputs": [], + "source": [ + "vec1 = [1, 4, 3]\n", + "vec2 = [2, 3.1, 5]\n", + "print(format(vector_dot_product(vec1,vec2),\".3f\"))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "### f)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "Lag en main-funksjon som:\n", + "\n", + "1. Oppretter en vektor med 3 elementer (vec1).\n", + "2. Skriver ut vektoren pÃ¥ fin form.\n", + "3. Tar inn en skalar fra bruker. (Skal kunne ta inn bÃ¥de heltall og flyttall.)\n", + "4. Skriver ut lengden til vektoren før og etter skalering med to desimaler.\n", + "5. Skriver ut forholdet mellom de to lengdene. (Forholdet bør være lik skalaren.)\n", + "6. Skriver ut prikkproduktet mellom vektoren før skalering og vektoren etter skalering. Dvs. prikkproduktet mellom vec1 og (vec1*skalar), altsÃ¥ vec1*(vec1*skalar).\n", + "\n", + "Eksempel pÃ¥ kjøring:\n", + "\n", + "```python\n", + "vec1 = [9, 3, 0]\n", + "Skriv inn en skalar: 2.5\n", + "Lengden før skalering er: 9.49\n", + "Lengden etter skalering er: 23.72\n", + "Forholdet mellom lengden før og etter skalering er: 2.5\n", + "Prikkproduktet av [9, 3, 0] og [22.5, 7.5, 0.0] er: 225.0\n", + "```\n", + "\n", + "***Skriv svaret ditt i boksen under.***" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-03T08:42:38.748968Z", + "start_time": "2019-07-03T08:42:38.741626Z" + } + }, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3.10.6 64-bit", + "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.10.6" + }, + "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": "aee8b7b246df8f9039afb4144a1f6fd8d2ca17a180786b69acc140d282b71a49" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Ovinger/Oving5/_Oving5.ipynb b/Ovinger/Oving5/_Oving5.ipynb new file mode 100644 index 0000000..40684f5 --- /dev/null +++ b/Ovinger/Oving5/_Oving5.ipynb @@ -0,0 +1,86 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "# Øving 5\n", + "\n", + "**LæringsmÃ¥l:** \n", + "\n", + "* Lister\n", + "* Numpy\n", + "* Nettverk\n", + "\n", + "\n", + "## Godkjenning:\n", + "\n", + "For Ã¥ fÃ¥ godkjent øvingen mÃ¥ du gjøre ***Intro til numpy-arrays*** og ***4*** av de ***11*** andre oppgavene. \n", + "\n", + "Oppgaver som er litt ekstra vanskelig er markert med stjerne.\n", + "\n", + "Alle oppgavene skal demonstreres til en læringsassistent pÃ¥ sal. I oppgaver der du skriver programkode skal ogsÃ¥ denne vises fram. Lykke til!\n", + "\n", + "Oppgave | Tema | Vanskelighetsgrad\n", + "--- | --- | ---\n", + "[Generelt om lister](Generelt%20om%20lister.ipynb) |Lister| \n", + "[Lett og blandet om lister](Lett%20og%20blandet.ipynb)|Lister|\n", + "[Intro til numpy-arrays](Intro%20til%20numpy-arrays.ipynb)|Numpy|\n", + "[KodeforstÃ¥else](Kodeforstaelse.ipynb)|KodeforstÃ¥else|\n", + "[Vektorer](Vektorer.ipynb)|Lister|\n", + "[Lister og løkker](Lister%20og%20lokker.ipynb)|Lister og løkker|\n", + "[Teoridelen pÃ¥ eksamen](Teoridelen%20paa%20eksamen.ipynb)|Lister|\n", + "[Gangetabell og lister](Gangetabell%20og%20lister.ipynb)|2D-Lister|\n", + "[Lotto](Lotto.ipynb)|Lister|\n", + "[Tannfeen](Tannfeen.ipynb)|2D-lister, Løkker|\n", + "[Chattebot](Chattebot.ipynb)|Lister, Input| \n", + "[Matriseaddisjon](Matriseaddisjon.ipynb)|2D-Lister|" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3.10.6 64-bit", + "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.10.6" + }, + "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": "aee8b7b246df8f9039afb4144a1f6fd8d2ca17a180786b69acc140d282b71a49" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} -- GitLab