diff --git a/Ovinger/Oving3/Alternerende sum.ipynb b/Ovinger/Oving3/Alternerende sum.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..7e43932c92a7169412028fd12e84bb7f5a709d58
--- /dev/null
+++ b/Ovinger/Oving3/Alternerende sum.ipynb
@@ -0,0 +1,153 @@
+{
+ "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=\"_Oving3.ipynb\">Øving 3</a>\n",
+ " </div>\n",
+ " <ul class=\"nav navbar-nav\">\n",
+ " <li ><a href=\"Intro%20til%20lokker.ipynb\">Intro til løkker</a></li>\n",
+ " <li ><a href=\"Mer%20om%20lokker.ipynb\">Mer om løkker</a></li>\n",
+ " <li><a href=\"Nostede%20lokker.ipynb\">Intro til nøstede løkker</a></li>\n",
+ " <li ><a href=\"Kodeforstaelse.ipynb\">Kodeforståelse</a></li>\n",
+ " <li ><a href=\"Gjett%20tallet.ipynb\">Gjett tallet</a></li>\n",
+ " <li ><a href=\"Tekstbasert%20spill%202.ipynb\">Tekstbasert spill 2</a></li>\n",
+ " <li ><a href=\"Geometrisk%20rekke.ipynb\">Geometrisk rekke</a></li>\n",
+ " <li ><a href=\"Fibonacci.ipynb\">Fibonacci</a></li>\n",
+ " <li class=\"active\"><a href=\"Alternerende%20sum.ipynb\">Alternerende sum</a></li>\n",
+ " <li ><a href=\"Hangman.ipynb\">Hangman</a></li>\n",
+ " <li ><a href=\"Derivasjon.ipynb\">Derivasjon</a></li>\n",
+ " <li ><a href=\"Doble%20lokker.ipynb\">Doble løkker</a></li>\n",
+ " </ul>\n",
+ " </div>\n",
+ "</nav>\n",
+ "\n",
+ "# Alternerende sum\n",
+ "\n",
+ "**Læringsmål:**\n",
+ "\n",
+ "* Løkker\n",
+ "\n",
+ "I denne oppgaven skal du ved hjelp av løkker summere sammen tall, basert på brukerinput. "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "**a)** Skriv en funksjon som leser tar inn et heltall n fra bruker og legger sammen tallserien under.\n",
+ "\n",
+ "**$1^{2}-2^{2}+3^{2}-4^{2}+5^{2}-\\cdot \\cdot \\cdot \\pm n^{2}$**\n",
+ "\n",
+ "Legg merke til at alle partallene har negativt fortegn og alle oddetallene har positivt fortegn. Husk at navnet på variabelen din ***ikke*** kan være **sum**, ettersom dette er navnet på en funksjon i python. Husk også at range() bare går til et tall og ikke til og med.\n",
+ "\n",
+ "Eksempel på kjøring:\n",
+ "```python\n",
+ "alternerende_sum(7)\n",
+ "Out: 28\n",
+ "```\n",
+ "\n",
+ "***Skriv koden din her:***"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2019-07-03T06:12:01.940513Z",
+ "start_time": "2019-07-03T06:12:01.928036Z"
+ }
+ },
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "**b)** Skriv en ny funksjon som avslutter iterasjonen **før** summen av tallene er større enn det positive heltallet k. Dette vil si at resultatet som returneres er summen av leddene som ikke overskrider. \n",
+ "\n",
+ "Hold styr på hvor mange ledd fra tallserien som er brukt i summen og returner dette samtidig.\n",
+ "\n",
+ "Eksempel på kjøring:\n",
+ "\n",
+ "```python\n",
+ "alternerende_sum_2(6)\n",
+ "Out: (-10, 4)\n",
+ "```\n",
+ "```python\n",
+ "alternerende_sum_2(12)\n",
+ "Out: (-10, 4)\n",
+ "```\n",
+ "```python\n",
+ "alternerende_sum_2(15)\n",
+ "Out: (-21, 6)\n",
+ "```\n",
+ "\n",
+ "***Skriv koden din her:***"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ }
+ ],
+ "metadata": {
+ "celltoolbar": "Edit Metadata",
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.7.4"
+ },
+ "toc": {
+ "base_numbering": 1,
+ "nav_menu": {},
+ "number_sections": false,
+ "sideBar": true,
+ "skip_h1_title": false,
+ "title_cell": "Table of Contents",
+ "title_sidebar": "Contents",
+ "toc_cell": false,
+ "toc_position": {},
+ "toc_section_display": true,
+ "toc_window_display": false
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/Ovinger/Oving3/Derivasjon.ipynb b/Ovinger/Oving3/Derivasjon.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..3bb422e39ecd10ed4a858bdf4fdc5ed88369212d
--- /dev/null
+++ b/Ovinger/Oving3/Derivasjon.ipynb
@@ -0,0 +1,156 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "<nav class=\"navbar navbar-default\">\n",
+ " <div class=\"container-fluid\">\n",
+ " <div class=\"navbar-header\">\n",
+ " <a class=\"navbar-brand\" href=\"_Oving3.ipynb\">Øving 3</a>\n",
+ " </div>\n",
+ " <ul class=\"nav navbar-nav\">\n",
+ " <li ><a href=\"Intro%20til%20lokker.ipynb\">Intro til løkker</a></li>\n",
+ " <li ><a href=\"Mer%20om%20lokker.ipynb\">Mer om løkker</a></li>\n",
+ " <li><a href=\"Nostede%20lokker.ipynb\">Intro til nøstede løkker</a></li>\n",
+ " <li ><a href=\"Kodeforstaelse.ipynb\">Kodeforståelse</a></li>\n",
+ " <li ><a href=\"Gjett%20tallet.ipynb\">Gjett tallet</a></li>\n",
+ " <li ><a href=\"Tekstbasert%20spill%202.ipynb\">Tekstbasert spill 2</a></li>\n",
+ " <li ><a href=\"Geometrisk%20rekke.ipynb\">Geometrisk rekke</a></li>\n",
+ " <li ><a href=\"Fibonacci.ipynb\">Fibonacci</a></li>\n",
+ " <li><a href=\"Alternerende%20sum.ipynb\">Alternerende sum</a></li>\n",
+ " <li><a href=\"Hangman.ipynb\">Hangman</a></li>\n",
+ " <li class=\"active\"><a href=\"Derivasjon.ipynb\">Derivasjon</a></li>\n",
+ " <li ><a href=\"Doble%20lokker.ipynb\">Doble løkker</a></li>\n",
+ " </ul>\n",
+ " </div>\n",
+ "</nav>\n",
+ "\n",
+ "\n",
+ "# Derivasjon \n",
+ "\n",
+ "**Læringsmål:**\n",
+ "\n",
+ "* While-løkker\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import matplotlib.pyplot as plt\n",
+ "import numpy as np"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def f_x(x):\n",
+ " return x**2"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "I denne oppgaven skal du finne en tilnærming til den deriverte av `f_x(x)` ved å bruke definisjonen av den deriverte. Du kan starte med å kjøre de to kodeblokkene over. \n",
+ "\n",
+ "\n",
+ "### a) \n",
+ "Implementer og plot den analytiske deriverte av `f_x()`, sammen med `f_x()`. Vi skal bruke den analytisk deriverte for å se hvor langt unna vår tilnærming til den deriverte er. Du kan bruke funksjonen linspace fra biblioteket numpy på følgende møte:\n",
+ "\n",
+ "```python\n",
+ "x = np.linspace(-10,10,100)\n",
+ "```\n",
+ "Dette betyr at vi vi deler området mellom -10 og 10 i hundre like store deler."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### b)\n",
+ "\n",
+ "_Merk at i denne deloppgaven er `x` et tall, ikke et `numpy.array`._ \n",
+ "I denne oppgaven skal du lage funksjonen `f_deriv(f,x,h)`, som bruker definisjonen av den deriverte til å estimere $f'(x)$. \n",
+ "Definer deretter funksjonen `approximate(f, x, h, tol)`, som bruker `f_deriv` til å estimere med økende nøyaktighet frem til forskjellen mellom svaret og estimatet er mindre enn toleransen. \n",
+ "For hver iterasjon kan du dele `h` på 10. \n",
+ "`approximate` skal returnere to lister, en med verdiene fra `f_deriv`, og en med differansen mellom den tilnærmede og analytiske verdien. \n",
+ "Plott begge listene som punkter.\n",
+ "\n",
+ "Eksempel på output med startverdiene for `x = 1`, `h = 10` og `tol = 0.0001`:\n",
+ "\n",
+ "```python \n",
+ "([12.0, 3.0, 2.100000000000002, 2.0100000000000007, 2.0009999999996975], [10.0, 1.0, 0.10000000000000187, 0.010000000000000675, 0.0009999999996974651])\n",
+ "```\n",
+ "\n",
+ "Her er første array de approksimerte verdiene i hver iterasjon, mens den siste arrayen er tilhørende feil i hver iterasjon. \n",
+ "\n",
+ "Eksempel på plotting: \n",
+ ""
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "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": "b31bfab217b7bba0d27806e15e39a0b8f095aad566d769ceebb383dd6773a3d0"
+ }
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/Ovinger/Oving3/Doble lokker.ipynb b/Ovinger/Oving3/Doble lokker.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..8c47a767597d14ccefdaa0eeefbeb1fabb19a787
--- /dev/null
+++ b/Ovinger/Oving3/Doble lokker.ipynb
@@ -0,0 +1,314 @@
+{
+ "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=\"_Oving3.ipynb\">Øving 3</a>\n",
+ " </div>\n",
+ " <ul class=\"nav navbar-nav\">\n",
+ " <li ><a href=\"Intro%20til%20lokker.ipynb\">Intro til løkker</a></li>\n",
+ " <li ><a href=\"Mer%20om%20lokker.ipynb\">Mer om løkker</a></li>\n",
+ " <li><a href=\"Nostede%20lokker.ipynb\">Intro til nøstede løkker</a></li>\n",
+ " <li ><a href=\"Kodeforstaelse.ipynb\">Kodeforståelse</a></li>\n",
+ " <li ><a href=\"Gjett%20tallet.ipynb\">Gjett tallet</a></li>\n",
+ " <li ><a href=\"Tekstbasert%20spill%202.ipynb\">Tekstbasert spill 2</a></li>\n",
+ " <li ><a href=\"Geometrisk%20rekke.ipynb\">Geometrisk rekke</a></li>\n",
+ " <li ><a href=\"Fibonacci.ipynb\">Fibonacci</a></li>\n",
+ " <li><a href=\"Alternerende%20sum.ipynb\">Alternerende sum</a></li>\n",
+ " <li ><a href=\"Hangman.ipynb\">Hangman</a></li>\n",
+ " <li ><a href=\"Derivasjon.ipynb\">Derivasjon</a></li>\n",
+ " <li class=\"active\"><a href=\"Doble%20lokker.ipynb\">Doble løkker</a></li>\n",
+ " </ul>\n",
+ " </div>\n",
+ "</nav>\n",
+ "\n",
+ "# Doble løkker - til dels vanskelig\n",
+ "\n",
+ "**Læringsmål:**\n",
+ "\n",
+ "* Nøstede løkker\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "a) Skriv en funksjon som tar inn et heltall og benytter seg av en dobbel for-løkke og skriver ut følgende:\n",
+ "\n",
+ "```python\n",
+ "triangle(5)\n",
+ "1\n",
+ "1 2\n",
+ "1 2 3\n",
+ "1 2 3 4\n",
+ "1 2 3 4 5\n",
+ "```\n",
+ "\n",
+ "***Skriv koden din her:***"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2019-07-03T06:31:27.370599Z",
+ "start_time": "2019-07-03T06:31:27.365228Z"
+ }
+ },
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "b) Skriv en funksjon som tar inn et heltall n benytter seg av en dobbel for-løkke og skriver ut følgende:\n",
+ "\n",
+ "```python\n",
+ "x(5)\n",
+ "X X\n",
+ "X X\n",
+ "X X\n",
+ "X X\n",
+ "X X\n",
+ "```\n",
+ "\n",
+ "***Skriv koden din her:***"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2019-07-03T06:36:27.852028Z",
+ "start_time": "2019-07-03T06:36:27.844946Z"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "\n",
+ " "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "**c)** \n",
+ "Lag en funksjon, primtallsfaktorisering(n) som returnerer primtallsfaktoriseringen til tallet, eller evt. at det allerede er et primtall. Eksempel på et par kjøringer:\n",
+ "```python\n",
+ "\n",
+ "primtallsfaktorisering(2)\n",
+ "2 er et primtall\n",
+ ">>>\n",
+ "\n",
+ "primtallsfaktorisering(38)\n",
+ "38 = 2*19\n",
+ ">>>\n",
+ "primtallsfakorisering(1000)\n",
+ "1000 = 2*2*2*5*5*5\n",
+ ">>>\n",
+ "primtallsfaktorisering(73727)\n",
+ "73727 er et primtall\n",
+ ">>>\n",
+ "primtallsfaktorisering(123456789)\n",
+ "123456789 = 3*3*3607*3803\n",
+ ">>>\n",
+ "```\n",
+ "\n",
+ "Dette er et problem som peker i retning av dobbel løkke fordi samme tall kan være faktor flere ganger, som f.eks. i `1000 = 2*2*2*5*5*5`. Den ytre løkka trengs for å prøve ut stadig nye faktorer, den indre for å prøve om igjen samme faktor, i tilfelle den inngår flere ganger i tallet.\n",
+ "\n",
+ "***Skriv koden din her:***"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2019-07-03T06:38:34.639856Z",
+ "start_time": "2019-07-03T06:38:34.633773Z"
+ }
+ },
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "**d)** Du skal hjelpe frøken Bernsen med å lage et enkelt program hvor elevene kan øve seg på den lille gangetabellen. Eleven skal stadig møte på nye gangestykker, og får 3 forsøk på hvert spørsmål. Benytt deg av randint(0,9) for å få tilfeldige tall for hvert gangestykke. Programmet skal fortsette frem til eleven gir beskjed om noe annet.\n",
+ "\n",
+ "Eksempel på kjøring:\n",
+ "\n",
+ "```python\n",
+ "Hva blir 2*0? 0\n",
+ "Gratulerer, det er helt riktig!\n",
+ "Er det ønskelig med flere spørsmål? Skriv 1 for ja og 0 for nei: 1\n",
+ ">>> \n",
+ "Hva blir 8*6? 42\n",
+ "Dessverre ikke riktig. Du har 2 forsøk igjen.\n",
+ "Hva blir 8*6? 48\n",
+ "Gratulerer, det er helt riktig!\n",
+ "Er det ønskelig med flere spørsmål? Skriv 1 for ja og 0 for nei: 1\n",
+ ">>>\n",
+ "Hva blir 8*9? 73\n",
+ "Dessverre ikke riktig. Du har 2 forsøk igjen.\n",
+ "Hva blir 8*9? 74\n",
+ "Dessverre ikke riktig. Du har 1 forsøk igjen.\n",
+ "Hva blir 8*9? 78\n",
+ "Dessverre ikke riktig. Du har 0 forsøk igjen.\n",
+ "Dessverre klarte du ikke dette regnestykket, men vent så får du et nytt et:)\n",
+ "Er det ønskelig med flere spørsmål? Skriv 1 for ja og 0 for nei: 1\n",
+ ">>>\n",
+ "Hva blir 9*1? 9\n",
+ "Gratulerer, det er helt riktig!\n",
+ "Er det ønskelig med flere spørsmål? Skriv 1 for ja og 0 for nei: 0\n",
+ ">>>\n",
+ "```\n",
+ "\n",
+ "***Skriv koden din her:***"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2019-07-03T06:40:51.257308Z",
+ "start_time": "2019-07-03T06:40:51.248787Z"
+ }
+ },
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "**e)** (frivillig)\n",
+ "\n",
+ "Du skal endre programmet ditt fra d) slik at eleven først får veldig lette gangestykker ved å bruke randint(0,5) (fra random-biblioteket). Dersom eleven klarer å svare rett på 5 spørsmål på rad (eleven kan fremdeles bruke 3 forsøk), skal vanskelighetsgraden øke ved å bruke randint(0,10). Dette intervallet skal altså øke med 5 for hver gang eleven svarer korrekt på 5 spørsmål på rad. \n",
+ "\n",
+ "Eksempel på kjøring:\n",
+ "\n",
+ "```python\n",
+ "Hva blir 1*2? 2 #1 riktig svar\n",
+ "Gratulerer, det er helt riktig!\n",
+ "Er det ønskelig med flere spørsmål? Skriv 1 for ja og 0 for nei: 1\n",
+ "```\n",
+ "```python\n",
+ "Hva blir 1*5? 5 #2 riktige svar\n",
+ "Gratulerer, det er helt riktig!\n",
+ "Er det ønskelig med flere spørsmål? Skriv 1 for ja og 0 for nei: 1\n",
+ " ```\n",
+ " ```python\n",
+ "Hva blir 3*5? 15 #3 riktige svar\n",
+ "Gratulerer, det er helt riktig!\n",
+ "Er det ønskelig med flere spørsmål? Skriv 1 for ja og 0 for nei: 1\n",
+ " ```\n",
+ " ```python\n",
+ "Hva blir 2*1? 2 #4 riktige svar\n",
+ "Gratulerer, det er helt riktig!\n",
+ "Er det ønskelig med flere spørsmål? Skriv 1 for ja og 0 for nei: 1\n",
+ " ```\n",
+ " ```python\n",
+ "Hva blir 2*0? 2\n",
+ "Dessverre ikke riktig. Du har 2 forsøk igjen.\n",
+ "Hva blir 2*0? 0 #5 riktige svar\n",
+ "Gratulerer, det er helt riktig!\n",
+ "Er det ønskelig med flere spørsmål? Skriv 1 for ja og 0 for nei: 1\n",
+ " ```\n",
+ " ```python\n",
+ "Hva blir 0*10? 0 #Intervallet har økt og 1 riktig svar\n",
+ "Gratulerer, det er helt riktig!\n",
+ "Er det ønskelig med flere spørsmål? Skriv 1 for ja og 0 for nei: 1\n",
+ ".\n",
+ ".\n",
+ ".\n",
+ "Hva blir 15*29? 435 \n",
+ "Gratulerer, det er helt riktig!\n",
+ "Er det ønskelig med flere spørsmål? Skriv 1 for ja og 0 for nei: 0\n",
+ "```"
+ ]
+ }
+ ],
+ "metadata": {
+ "celltoolbar": "Edit Metadata",
+ "kernelspec": {
+ "display_name": "Python 3.9.12 ('base')",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.9.12"
+ },
+ "toc": {
+ "base_numbering": 1,
+ "nav_menu": {},
+ "number_sections": false,
+ "sideBar": true,
+ "skip_h1_title": false,
+ "title_cell": "Table of Contents",
+ "title_sidebar": "Contents",
+ "toc_cell": false,
+ "toc_position": {},
+ "toc_section_display": true,
+ "toc_window_display": false
+ },
+ "vscode": {
+ "interpreter": {
+ "hash": "c7a835b0bfaf10a8e5ac8dbb78b220fe60aa37deac6d6fc977a5312d437a60b7"
+ }
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/Ovinger/Oving3/Fibonacci.ipynb b/Ovinger/Oving3/Fibonacci.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..1bca1a9dbe4193da04277138003db72ec11e7233
--- /dev/null
+++ b/Ovinger/Oving3/Fibonacci.ipynb
@@ -0,0 +1,156 @@
+{
+ "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=\"_Oving3.ipynb\">Øving 3</a>\n",
+ " </div>\n",
+ " <ul class=\"nav navbar-nav\">\n",
+ " <li ><a href=\"Intro%20til%20lokker.ipynb\">Intro til løkker</a></li>\n",
+ " <li ><a href=\"Mer%20om%20lokker.ipynb\">Mer om løkker</a></li>\n",
+ " <li><a href=\"Nostede%20lokker.ipynb\">Intro til nøstede løkker</a></li>\n",
+ " <li ><a href=\"Kodeforstaelse.ipynb\">Kodeforståelse</a></li>\n",
+ " <li ><a href=\"Gjett%20tallet.ipynb\">Gjett tallet</a></li>\n",
+ " <li ><a href=\"Tekstbasert%20spill%202.ipynb\">Tekstbasert spill 2</a></li>\n",
+ " <li ><a href=\"Geometrisk%20rekke.ipynb\">Geometrisk rekke</a></li>\n",
+ " <li class=\"active\"><a href=\"Fibonacci.ipynb\">Fibonacci</a></li>\n",
+ " <li><a href=\"Alternerende%20sum.ipynb\">Alternerende sum</a></li>\n",
+ " <li ><a href=\"Hangman.ipynb\">Hangman</a></li>\n",
+ " <li ><a href=\"Derivasjon.ipynb\">Derivasjon</a></li>\n",
+ " <li ><a href=\"Doble%20lokker.ipynb\">Doble løkker</a></li>\n",
+ " </ul>\n",
+ " </div>\n",
+ "</nav>\n",
+ "\n",
+ "# Fibonacci\n",
+ "\n",
+ "**Læringsmål:**\n",
+ "\n",
+ "* Løkker\n",
+ "\n",
+ "\n",
+ "<br><br>\n",
+ "I denne oppgaven skal du lage en funksjon som ved help av løkker regner ut fibonaccitall. \n",
+ "\n",
+ "Fibonaccitallene er definert som følger: \n",
+ "\n",
+ "* **f(0)=0**\n",
+ "* **f(1)=1**\n",
+ "* **f(k)=f(k−1)+f(k−2)**\n",
+ "\n",
+ "Det vil si at de to første tallene i rekken er 0 og 1, deretter er det neste tallet summen av de to forrige tallene. Starten på rekken ser derfor slik ut: 0 1 1 2 3 5 8 13 ..."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "**a)** Lag en funksjon, *fibonacci(k)* som regner ut og returnerer det k-te fibonaccitallet ved hjelp av iterasjon. Du kan sjekke om du har gjort det riktig ved å kalle *fibonacci(10)*. Har du gjort det rett skal funksjonen returnere 34. **Husk at det første tallet i rekken er tall nummer 0**\n",
+ "\n",
+ "***Skriv koden din her:***"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2019-07-03T05:55:08.163277Z",
+ "start_time": "2019-07-03T05:55:08.156436Z"
+ }
+ },
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "**b)** Skriv om funksjonen i deloppgave a) slik at den også returnerer summen av alle fibonaccitallene. Har du gjort det rett det rett skal kallet til *fibonacci_sum(10)* bli *(34, 88)*."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "**c)** (**Frivillig**, vanskeligere oppgave) Modifiser funksjonen til å returnere en liste med alle fibonaccitallene opp til og med f(k).\n",
+ "\n",
+ "Kallet *fibonacci_list(10)* skal se ut som følger: \n",
+ "*\\[0, 1, 1, 2, 3, 5, 8, 13, 21, 34\\]*"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ }
+ ],
+ "metadata": {
+ "celltoolbar": "Edit Metadata",
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.7.4"
+ },
+ "toc": {
+ "base_numbering": 1,
+ "nav_menu": {},
+ "number_sections": false,
+ "sideBar": true,
+ "skip_h1_title": false,
+ "title_cell": "Table of Contents",
+ "title_sidebar": "Contents",
+ "toc_cell": false,
+ "toc_position": {},
+ "toc_section_display": true,
+ "toc_window_display": false
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/Ovinger/Oving3/Geometrisk rekke.ipynb b/Ovinger/Oving3/Geometrisk rekke.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..abe3749ff53c964b24fd662f4c961519d30cbe89
--- /dev/null
+++ b/Ovinger/Oving3/Geometrisk rekke.ipynb
@@ -0,0 +1,231 @@
+{
+ "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=\"_Oving3.ipynb\">Øving 3</a>\n",
+ " </div>\n",
+ " <ul class=\"nav navbar-nav\">\n",
+ " <li ><a href=\"Intro%20til%20lokker.ipynb\">Intro til løkker</a></li>\n",
+ " <li ><a href=\"Mer%20om%20lokker.ipynb\">Mer om løkker</a></li>\n",
+ " <li><a href=\"Nostede%20lokker.ipynb\">Intro til nøstede løkker</a></li>\n",
+ " <li ><a href=\"Kodeforstaelse.ipynb\">Kodeforståelse</a></li>\n",
+ " <li ><a href=\"Gjett%20tallet.ipynb\">Gjett tallet</a></li>\n",
+ " <li ><a href=\"Tekstbasert%20spill%202.ipynb\">Tekstbasert spill 2</a></li>\n",
+ " <li class=\"active\"><a href=\"Geometrisk%20rekke.ipynb\">Geometrisk rekke</a></li>\n",
+ " <li ><a href=\"Fibonacci.ipynb\">Fibonacci</a></li>\n",
+ " <li><a href=\"Alternerende%20sum.ipynb\">Alternerende sum</a></li>\n",
+ " <li ><a href=\"Hangman.ipynb\">Hangman</a></li>\n",
+ " <li ><a href=\"Derivasjon.ipynb\">Derivasjon</a></li>\n",
+ " <li ><a href=\"Doble%20lokker.ipynb\">Doble løkker</a></li>\n",
+ " </ul>\n",
+ " </div>\n",
+ "</nav>\n",
+ "\n",
+ "# Geometrisk rekke\n",
+ "\n",
+ "**Læringsmål:**\n",
+ "\n",
+ "* Løkker\n",
+ "\n",
+ "\n",
+ "En geometrisk rekke er en sum som kan skrives på formen under: \n",
+ "\n",
+ "$\\sum_{i=0}^{n}r_i=r^0+r^1+r^2+r^3+\\cdot \\cdot \\cdot +r^n$ \n",
+ "\n",
+ "Et uttrykk for summen av en slik rekke er gitt ved $s_n = \\frac{1 - r^n}{1 - r}$. Dere kan lese mer om Geometriske rekker [her](https://no.wikipedia.org/wiki/Geometrisk_rekke), og se utledningen for $s_n$ [her](https://www.purplemath.com/modules/series7.htm)\n",
+ "\n",
+ "Merk at $s_n$ går mot $\\frac{1}{1 -r}$ for $r \\in (-1,1)$ når n går mot uendelig. "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "### a)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Lag en funksjon som summerer en geometrisk rekke fra 0 til n ved hjelp av en for-løkke.\n",
+ "\n",
+ "Sjekk: r = 0.5 og n = 4 skal gi sum = 1.9375\n",
+ "\n",
+ "***Skriv koden din her:***"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2019-07-02T14:25:12.748347Z",
+ "start_time": "2019-07-02T14:25:12.737936Z"
+ }
+ },
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "### b) "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ " \n",
+ "\n",
+ "Skriv om funksjonen (og bruk en annen løkke) slik at løkken avsluttes når din sum er innenfor en toleranse tol til grenseverdien av summen (verdien til summen når n går mot uendelig; se hint).\n",
+ "\n",
+ "\n",
+ "Oppgave b) og c) kan gjøres i et kodevindu. Et eksempel som viser kjøring av alle oppgavene er vist under.\n",
+ "\n",
+ "Test dette med tol = 0.001, r = 1/2, som vist i eksempelet til slutt."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "hidden": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "**Hint**:\n",
+ "Summen til en geometrisk rekke er som nevnt $\\frac{1-r^{n+1}}{1-r}$\n",
+ ". For rekken i b) blir grenseverdien $\\frac{1}{1-r}$ = 2."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### c)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "La programmet gi ut antall iterasjoner som trengs for å være innenfor toleransen. Gi også ut den virkelige differansen mellom summen du fant og grenseverdien."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "hidden": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "### Eksempel\n",
+ "\n",
+ "Eksempel på kjøring av kode a, b, og c:\n",
+ "```\n",
+ "#a)\n",
+ "geometrisk_rekke(0.5,4)\n",
+ "1.9375 \n",
+ "#b&c) \n",
+ "(11, 0.0009765625)\n",
+ "```\n",
+ "I b) og c) representerer 11 antall ganger løkken kjører og 0.0009765625 differansen mellom den faktiske summen og den approksimerte summen. "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ }
+ ],
+ "metadata": {
+ "celltoolbar": "Edit Metadata",
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.7.4"
+ },
+ "toc": {
+ "base_numbering": 1,
+ "nav_menu": {},
+ "number_sections": false,
+ "sideBar": true,
+ "skip_h1_title": false,
+ "title_cell": "Table of Contents",
+ "title_sidebar": "Contents",
+ "toc_cell": false,
+ "toc_position": {},
+ "toc_section_display": true,
+ "toc_window_display": false
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/Ovinger/Oving3/Gjett tallet.ipynb b/Ovinger/Oving3/Gjett tallet.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..c5d5f1efa4c95f0657a05a231a301b80c5c69082
--- /dev/null
+++ b/Ovinger/Oving3/Gjett tallet.ipynb
@@ -0,0 +1,184 @@
+{
+ "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=\"_Oving3.ipynb\">Øving 3</a>\n",
+ " </div>\n",
+ " <ul class=\"nav navbar-nav\">\n",
+ " <li ><a href=\"Intro%20til%20lokker.ipynb\">Intro til løkker</a></li>\n",
+ " <li ><a href=\"Mer%20om%20lokker.ipynb\">Mer om løkker</a></li>\n",
+ " <li><a href=\"Nostede%20lokker.ipynb\">Intro til nøstede løkker</a></li>\n",
+ " <li ><a href=\"Kodeforstaelse.ipynb\">Kodeforståelse</a></li>\n",
+ " <li class=\"active\"><a href=\"Gjett%20tallet.ipynb\">Gjett tallet</a></li>\n",
+ " <li ><a href=\"Tekstbasert%20spill%202.ipynb\">Tekstbasert spill 2</a></li>\n",
+ " <li ><a href=\"Geometrisk%20rekke.ipynb\">Geometrisk rekke</a></li>\n",
+ " <li ><a href=\"Fibonacci.ipynb\">Fibonacci</a></li>\n",
+ " <li><a href=\"Alternerende%20sum.ipynb\">Alternerende sum</a></li>\n",
+ " <li ><a href=\"Hangman.ipynb\">Hangman</a></li>\n",
+ " <li ><a href=\"Derivasjon.ipynb\">Derivasjon</a></li>\n",
+ " <li ><a href=\"Doble%20lokker.ipynb\">Doble løkker</a></li>\n",
+ " </ul>\n",
+ " </div>\n",
+ "</nav>\n",
+ "\n",
+ "\n",
+ "# Gjettelek\n",
+ "\n",
+ "**Læringsmål:**\n",
+ "\n",
+ "* Løkker\n",
+ "* Betingelser\n",
+ "* Innebygde funksjoner\n",
+ "\n",
+ "\n",
+ "I denne oppgaven skal du lage en funnksjon som genererer et tilfeldig heltall i et gitt intervall, og deretter lar brukeren gjette på hvilket tall dette er. Dette bør gjøres ved bruk av løkker. Hele funksjonen skrives i ett kodevindu, altså under deloppgave a).\n",
+ "\n",
+ "\n",
+ "\n",
+ "I denne oppgaven må du benytte deg av biblioteket random. Derfor skal koden din starte med `import random`. \n",
+ "Eksempel på bruk av random.randint()\n",
+ "\n",
+ "```python\n",
+ "tilfeldigTall = random.randint(1,50) #gir deg et tilfeldig tall fra og med 1, til og med 50\n",
+ "tall = random.randint(a,b) #gir deg et tilfeldig tall mellom a og b. (Fra og med a, til og med b)\n",
+ "```\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "**a)** Be brukeren om å velge en nedre og en øvre grense for tall han eller hun skal gjette på. Lagre disse to opplysningene i to variabler.\n",
+ "\n",
+ "***Skriv koden din her:***"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2019-07-02T14:02:57.358551Z",
+ "start_time": "2019-07-02T14:02:57.352636Z"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Oppgi en nedre grense: 1\n",
+ "Oppgi en øvre grense: 50\n",
+ "Make a guess? 25\n",
+ "The correct number is higher\n",
+ "Make a guess? 37\n",
+ "The correct number is higher\n",
+ "Make a guess? 45\n",
+ "The correct number is higher\n",
+ "Make a guess? 49\n",
+ "The correct number is lower\n",
+ "Make a guess? 47\n",
+ "Correct, well done! \n"
+ ]
+ }
+ ],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "**b)** Lag en funksjon, *gjettelek(a,b)* som tar inn verdiene i deloppgave a). Lag så en variabel tilfeldigTall i som genererer et tilfeldig tall i intervallet mellom den øvre og den nedre grensen som brukeren har satt. Fortsett å skriv i samme felt som i oppgave a."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "**c)** Skriv en while-løkke som kjører så lenge brukeren ikke har gjettet riktig svar. Brukeren skal få tilbakemelding for hvert gjett om han eller hun gjettet for lavt, for høyt eller riktig. Fortsett å skriv i samme felt som i oppgave a og b.\n",
+ "\n",
+ "Eksempel på kjøring:\n",
+ "```python\n",
+ "Gi en nedre grense for det tilfeldige tallet: 1\n",
+ "Gi en øvre grense for det tilfeldige tallet: 100\n",
+ "Make a guess 50\n",
+ "The correct number is lower\n",
+ "Make a guess 25\n",
+ "The correct Number is higher\n",
+ "Make a guess 37\n",
+ "The correct number is lower\n",
+ "Make a guess 32\n",
+ "You guessed correct!```"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ }
+ ],
+ "metadata": {
+ "celltoolbar": "Edit Metadata",
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.7.4"
+ },
+ "toc": {
+ "base_numbering": 1,
+ "nav_menu": {},
+ "number_sections": false,
+ "sideBar": true,
+ "skip_h1_title": false,
+ "title_cell": "Table of Contents",
+ "title_sidebar": "Contents",
+ "toc_cell": false,
+ "toc_position": {},
+ "toc_section_display": true,
+ "toc_window_display": false
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/Ovinger/Oving3/Hangman.ipynb b/Ovinger/Oving3/Hangman.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..d76a316898079189928d499760835cf176f440fe
--- /dev/null
+++ b/Ovinger/Oving3/Hangman.ipynb
@@ -0,0 +1,196 @@
+{
+ "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=\"_Oving3.ipynb\">Øving 3</a>\n",
+ " </div>\n",
+ " <ul class=\"nav navbar-nav\">\n",
+ " <li ><a href=\"Intro%20til%20lokker.ipynb\">Intro til løkker</a></li>\n",
+ " <li ><a href=\"Mer%20om%20lokker.ipynb\">Mer om løkker</a></li>\n",
+ " <li><a href=\"Nostede%20lokker.ipynb\">Intro til nøstede løkker</a></li>\n",
+ " <li ><a href=\"Kodeforstaelse.ipynb\">Kodeforståelse</a></li>\n",
+ " <li ><a href=\"Gjett%20tallet.ipynb\">Gjett tallet</a></li>\n",
+ " <li ><a href=\"Tekstbasert%20spill%202.ipynb\">Tekstbasert spill 2</a></li>\n",
+ " <li ><a href=\"Geometrisk%20rekke.ipynb\">Geometrisk rekke</a></li>\n",
+ " <li ><a href=\"Fibonacci.ipynb\">Fibonacci</a></li>\n",
+ " <li><a href=\"Alternerende%20sum.ipynb\">Alternerende sum</a></li>\n",
+ " <li class=\"active\"><a href=\"Hangman.ipynb\">Hangman</a></li>\n",
+ " <li ><a href=\"Derivasjon.ipynb\">Derivasjon</a></li>\n",
+ " <li ><a href=\"Doble%20lokker.ipynb\">Doble løkker</a></li>\n",
+ " </ul>\n",
+ " </div>\n",
+ "</nav>\n",
+ "\n",
+ "**Læringsmål:**\n",
+ "\n",
+ "* Betingelser\n",
+ "* While-løkker\n",
+ "\n",
+ "\n",
+ "Kapittel fire introduserer repetisjonsstrukturer. Dette er en mye brukt programmeringsteknikk som brukes når et program skal utføre den samme oppgaven mange ganger etter hverandre. I denne oppgaven bruker vi en enkel while-løkke for å lage et hangman-spill i Python. \n",
+ "\n",
+ "Lag et program som tar inn et ord (tekststreng) og antall liv (heltall) fra en bruker, og lar en annen (eller samme) bruker gjette på bokstaver i ordet. "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "**a)** Start med å hente inn data fra bruker. Lagre dette i to variabler \"hemmelig_ord\" og \"antall_liv\".\n",
+ "\n",
+ "***Skriv koden din her.***"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2019-07-03T06:20:10.962975Z",
+ "start_time": "2019-07-03T06:20:10.957236Z"
+ }
+ },
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "**b)** Utvid koden over med en funksjon, *hangman(hemmelig_ord, antall_liv)*, som inneholder en while-løkke. Din oppgave er å fylle inn manglende logikk i henhold til kravene under: \n",
+ "\n",
+ "* Hent inn en bokstav fra bruker\n",
+ "* Sjekk om denne er i det hemmelige ordet \n",
+ " * Trekk fra et liv dersom brukeren tipper feil\n",
+ " * Hvis brukeren ikke har flere liv skal løkken avsluttes (HINT: bruk \"break\" for å avslutte en løkke) \n",
+ "\n",
+ "PS: Husk å skrive ut resultatet til brukeren. **Du kan bruke variablene du laget i oppgave a uten å skrive dem på nytt** \n",
+ "\n",
+ "Eksempel på kjøring av kode:\n",
+ "\n",
+ "```python\n",
+ "Skriv inn det hemmelige ordet: hemmelig\n",
+ "Hvor mange forsøk får brukeren? 2\n",
+ "Gjett på én bokstav i ordet: f\n",
+ "Bokstaven f er ikke i ordet.\n",
+ "Du har 1 liv igjen, prøv på nytt.\n",
+ "Gjett på én bokstav i ordet: h\n",
+ "Stemmer, bokstaven er i ordet\n",
+ "Gjett på én bokstav i ordet: e\n",
+ "Stemmer, bokstaven er i ordet\n",
+ "Gjett på én bokstav i ordet: r\n",
+ "Bokstaven r er ikke i ordet.\n",
+ "Du har ingen liv igjen.\n",
+ "```"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "while True:\n",
+ " # do something"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Gjett en bokstav i ordet :f\n",
+ "bokstaven er ikke i ordet\n",
+ "Du har 1 liv igjen\n",
+ "Gjett en bokstav i ordet :h\n",
+ " Stemmer, bokstaven er i ordet\n",
+ "Gjett en bokstav i ordet :e\n",
+ " Stemmer, bokstaven er i ordet\n",
+ "Gjett en bokstav i ordet :r\n",
+ "bokstaven er ikke i ordet\n",
+ "Du har 0 liv igjen\n",
+ "du har ingen liv igjen\n"
+ ]
+ }
+ ],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "**d)** **FRIVILLIG vanskeligere oppgave**: Fyll inn logikk for å fullføre spillet. Ting som kan implementeres er:\n",
+ "\n",
+ "* Avslutt løkken hvis brukeren har gjettet alle bokstavene i løsningsordet.\n",
+ "* For hvert gjett, print ut maskert løsningsord med stjerner for hver bokstav som fortsatt ikke er gjettet. `(Eks.: lø*ning*ord)`\n",
+ "\n",
+ "Du kan fortsette i samme kodefelt som oppgave b."
+ ]
+ }
+ ],
+ "metadata": {
+ "celltoolbar": "Edit Metadata",
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.7.4"
+ },
+ "toc": {
+ "base_numbering": 1,
+ "nav_menu": {},
+ "number_sections": false,
+ "sideBar": true,
+ "skip_h1_title": false,
+ "title_cell": "Table of Contents",
+ "title_sidebar": "Contents",
+ "toc_cell": false,
+ "toc_position": {},
+ "toc_section_display": true,
+ "toc_window_display": false
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/Ovinger/Oving3/Intro til lokker.ipynb b/Ovinger/Oving3/Intro til lokker.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..23df3c47ddefa22e04aa72b0b503f08e0865a2fc
--- /dev/null
+++ b/Ovinger/Oving3/Intro til lokker.ipynb
@@ -0,0 +1,862 @@
+{
+ "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=\"_Oving3.ipynb\">Øving 3</a>\n",
+ " </div>\n",
+ " <ul class=\"nav navbar-nav\">\n",
+ " <li class=\"active\"><a href=\"Intro%20til%20lokker.ipynb\">Intro til løkker</a></li>\n",
+ " <li ><a href=\"Mer%20om%20lokker.ipynb\">Mer om løkker</a></li>\n",
+ " <li><a href=\"Nostede%20lokker.ipynb\">Intro til nøstede løkker</a></li>\n",
+ " <li><a href=\"Kodeforstaelse.ipynb\">Kodeforståelse</a></li>\n",
+ " <li ><a href=\"Gjett%20tallet.ipynb\">Gjett tallet</a></li>\n",
+ " <li ><a href=\"Tekstbasert%20spill%202.ipynb\">Tekstbasert spill 2</a></li>\n",
+ " <li ><a href=\"Geometrisk%20rekke.ipynb\">Geometrisk rekke</a></li>\n",
+ " <li ><a href=\"Fibonacci.ipynb\">Fibonacci</a></li>\n",
+ " <li><a href=\"Alternerende%20sum.ipynb\">Alternerende sum</a></li>\n",
+ " <li ><a href=\"Hangman.ipynb\">Hangman</a></li>\n",
+ " <li ><a href=\"Derivasjon.ipynb\">Derivasjon</a></li>\n",
+ " <li ><a href=\"Doble%20lokker.ipynb\">Doble løkker</a></li>\n",
+ " </ul>\n",
+ " </div>\n",
+ "</nav>\n",
+ "\n",
+ "# Intro til løkker\n",
+ "\n",
+ "**Læringsmål:**\n",
+ "\n",
+ "* Løkker\n",
+ "* Velge egnet løkkekonstruksjon (for eller while) etter behov\n",
+ "\n",
+ "\n",
+ "I denne oppgaven skal du lære å skrive kode hvor handlinger repeteres ved hjelp av løkker."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "heading_collapsed": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "### Intro om løkker"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "hidden": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Noe av det datamaskiner er best på, er gjentatte handlinger i høyt tempo. Dette er også et vanlig behov.\n",
+ "* Et firma skal utbetale lønn til alle sine ansatte hver måned.\n",
+ "* Et digitalt eksamenssystem skal vise spørsmål til, og motta svar fra, alle studenter som tar eksamen. \n",
+ "* Et system som styrer industrielt produksjonsutstyr skal motta informasjon fra en rekke sensorer hvert eneste sekund, om trykk, temperatur, osv., og gjøre handlinger basert på verdiene.\n",
+ "* Utstyr på et sykehus skal overvåke pasienters hjerterytme osv. sekund for sekund, og kunne slå alarm hvis noe er unormalt.\n",
+ "* Utstyr for opptak av musikk skal kunne sample lyden tusenvis eller millionvis av ganger per sekund.\n",
+ "* Et program for å vise video på en mobilskjerm må likeledes kunne oppdatere fargen i hver piksel på skjermen mange ganger i sekundet.\n",
+ "\n",
+ "Du har kanskje erfaring med bruk av regneark? Der er det vanlig hvis man skal bruke samme formel på alle radene i en tabell at man **kopierer** formelen nedover. \n",
+ "Å kopiere samme kodesetning flere ganger er mulig i Python også, men bare praktisk hvis antall repetisjoner er lavt og kjent på forhånd.\n",
+ "Eksemplet nedenfor viser et slikt tilfelle, hvor en kodelinje er gjentatt 3 ganger."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "hidden": true
+ },
+ "outputs": [],
+ "source": [
+ "print(\"Hipp\")\n",
+ "print(\"Hipp\")\n",
+ "print(\"Hipp\")\n",
+ "print(\"Hurra!\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "hidden": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Samme utskrift kan oppnås med løkke:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "hidden": true
+ },
+ "outputs": [],
+ "source": [
+ "for i in range(3):\n",
+ " print(\"Hipp!\")\n",
+ "print(\"Hurra!\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "hidden": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "**for <variabel> in range(3)**: gjør at påfølgende kodesetning(er) med innrykk blir repetert 3 ganger.\n",
+ "\n",
+ "print(\"Hurra!\") som ikke har innrykk, er ikke del av løkka, og vil derfor bare bli utført en gang, etter at løkka er ferdig.\n",
+ "\n",
+ "Det fins to typer løkker i Python, **for**-løkke som vist over, og **while**-løkke. Vi kunne ha klart oss med bare while-løkke, eksemplet ville da ha blitt:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "hidden": true
+ },
+ "outputs": [],
+ "source": [
+ "i = 0\n",
+ "while i < 3:\n",
+ " print(\"Hipp\")\n",
+ " i = i + 1 # eller: i += 1\n",
+ "print(\"Hurra!\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "hidden": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "while er noe mer tungvint her, vi må eksplisitt øke i med 1 for hver runde, som er implisitt i for-løkka. \n",
+ "\n",
+ "while-løkka vil fortsette så lenge betingelsen (her: i < 3) er sann, den vil derfor kjøre når i er 0, 1, 2, men deretter stoppe når i blir 3. Som i for-løkka gjør dette at Hipp skrives 3 ganger.\n",
+ "\n",
+ "I andre situasjoner er while-løkke derimot bedre enn for-løkke. Generelt gjelder følgende:\n",
+ "\n",
+ "* **for-løkke** egner seg når vi har et **kjent antall repetisjoner**. Eksempel fra den virkelige verden: hver måned skal et firma utbetale lønn til alle sine ansatte. Firmaet og dets datasystem vet (forhåpentligvis) hvor mange ansatte det har, dermed har løkka \"for alle ansatte, beregn og utbetal lønn\" et kjent antall repetisjoner når lønningsdagen kommer.\n",
+ "* **while-løkke** er derimot nødvendig hvis **maks antall repetisjoner er uvisst** når løkka starter og vi først finner ut underveis når løkka skal avsluttes. F.eks.\n",
+ " * brukeren bestemmer underveis, f.eks. \"Try again\" / \"Quit\" - vi aner ikke hvor mange ganger brukeren vil forsøke. Eller et program for lydopptak: løkka som sampler lyden, starter når brukeren klikker på \"Record\" og skal fortsette til brukeren trykker \"Stop\" - og vi aner ikke hvor mange sekunder eller minutter det vil ta.\n",
+ " * numerisk løsning av matematiske likninger, hvor stoppkriteriet er at vi skal ha nådd en viss presisjon. Hvis vi ikke aner på forhånd hvor mange iterasjoner som trengs for å nå denne presisjonen, vil while-løkke være best.\n",
+ " * produksjonsutstyr i en fabrikk skal kjøre som normalt med mindre sensordata indikerer en krisesituasjon, og da gå over til en alternativ nødprosedyre. Vi aner ikke om det går tusen sekunder, eller millioner av sekunder... kanskje inntreffer krisesituasjonen slett ikke. Dermed vil antall repetisjoner av løkka for normal oppførsel være ukjent når den starter, som tilsier while-løkke.\n",
+ "\n",
+ "Under er forskjellen vist ved to ytterligere varianter av Hurra-programmet vårt. Kopier gjerne denne koden inn i editoren din og kjør den for å se hvordan den virker."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "hidden": true
+ },
+ "outputs": [],
+ "source": [
+ "# hvis brukeren skal bestemme antall på forhånd:\n",
+ "antall = int(input(\"Hvor mange Hipp?\" ))\n",
+ "for i in range(antall):\n",
+ " print(\"Hipp\")\n",
+ "print(\"Hurra!\")\n",
+ " \n",
+ "# hvis brukeren skal bestemme seg for å slutte underveis:\n",
+ "print(\"Slå Enter direkte etter Hipp for å legge til flere Hipp,\")\n",
+ "print(\"eller mellomrom så Enter for å avslutte: \")\n",
+ "while input(\"Hipp\") == \"\":\n",
+ " pass\n",
+ "print(\"Hurra!\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "hidden": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Linje 1-5 viser en variant med **for**-løkke. Siden brukeren gir inn på forhånd antall Hipp som ønskes, er **antall repetisjoner kjent**, og **for-løkke enklest.**\n",
+ "\n",
+ "Linje 7-12 viser derimot en variant hvor brukeren bestemmer underveis i løkka om vi skal fortsette eller avslutte, da er det best med **while** siden **antall repetisjoner er ukjent.**\n",
+ "\n",
+ " * brukeren velger å fortsette ved å trykke Enter direkte etter Hipp; dette vil gi en helt tom streng \"\" som resultat, slik at betingelsen i while vil være sann. Så lenge den er sann, fortsetter løkka med å gjøre ny input() som gjør at ledeteksten \"Hipp\" kommer på skjermen på ny.\n",
+ " \n",
+ " * brukeren velger å avslutte ved å skrive inn et blankt tegn og deretter slå Enter. Dette vil gi strengen \" \" som er forskjellig fra \"\", da blir betingelsen usann, og løkka avsluttes, og programmet går videre med å skrive \"Hurra\".\n",
+ "\n",
+ "I while-løkka er den eneste handlingen vi ønsker å utføre, den input() og sammenligning som står i betingelsen. Da trenger vi egentlig ingen innmat. Man er imidlertid nødt til å ha minst en setning inni ei løkke.\n",
+ "Derfor **pass**, som er et beskyttet ord i Python for å gjøre ingenting. De fleste løkker vil ha mer kompliserte gjøremål og derfor også trenge en eller flere setninger inni som gjør noe."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "## a)\n",
+ "Koden under viser en funksjon som repeterer en for-løkke 3 ganger. For hver runde blir brukeren bedt om å beskrive seg selv med et adjektiv, hvorpå maskinen disser brukeren ved å si at den er snillere, smartere etc.\n",
+ "\n",
+ "(Trikset her er bare å legge til \"ere\" bak adjektivet, så det vil ikke bli grammatisk korrekt for adjektiv som bøyes annerledes.)\n",
+ "\n",
+ "***Kjør koden for å se hvordan den virker. Endre så koden slik at programmet først spør brukeren hvor mange repetisjoner som ønskes, og deretter utfører programmet med ønsket antall repetisjoner av løkka.***\n",
+ "\n",
+ "Eksempel på kjøring:\n",
+ "\n",
+ "```python \n",
+ "Hvor mange adjektiv vil du gi? 2\n",
+ "Beskriv deg selv med et adjektiv? snill\n",
+ "Hah, du snill!? Jeg er mye snillere!\n",
+ "Beskriv deg selv med et adjektiv? ond\n",
+ "Hah, du ond!? Jeg er mye ondere!\n",
+ "Takk for nå!\n",
+ "```"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2019-07-02T12:12:32.923751Z",
+ "start_time": "2019-07-02T12:12:22.141490Z"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Hvor mange adjektiv vil du gi? 3\n",
+ "Beskriv deg selv med et adjektiv? snill\n",
+ "Hah, du snill!? Jeg er mye snillere!\n",
+ "Beskriv deg selv med et adjektiv? snill\n",
+ "Hah, du snill!? Jeg er mye snillere!\n",
+ "Beskriv deg selv med et adjektiv? snill\n",
+ "Hah, du snill!? Jeg er mye snillere!\n",
+ "Takk for nå!\n"
+ ]
+ }
+ ],
+ "source": [
+ "#endre funksjonen under\n",
+ "\n",
+ "def diss_brukeren_n_ganger(n):\n",
+ " \n",
+ " for i in range(3):\n",
+ " adj = input(\"Beskriv deg selv med et adjektiv? \")\n",
+ " print(\"Hah, du\", adj + \"!? Jeg er mye\", adj + \"ere!\")\n",
+ " \n",
+ " print(\"Takk for nå!\")\n",
+ "\n",
+ "n = input(\"Hvor mange adjektiv vil du gi? \")\n",
+ "diss_brukeren_n_ganger(n)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "hidden": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "**Hint:** I stedet for tallet 3 i for-løkken, må verdien på variablen n samsvare med antall iterasjoner som skal kjøres. I tillegg må verdien på n konverteres til et heltall (*int*)."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "## b)\n",
+ "Koden under viser en while-løkke som utfører samme type brukerdialog som i (a), med 3 repetisjoner. Kjør den for å se hvordan det virker. **Endre nå funksjonen diss_brukeren_gjentatte_ganger() så løkka ikke kjører akkurat 3 ganger, men så mange ganger brukeren vil**, hvor brukeren kan bestemme dette underveis ved å gi et tomt svar (dvs. bare slå Enter) for å slutte. Da vil input()-setningen resultere i en tom streng, \"\".\n",
+ "\n",
+ "Eksempel på kjøring:\n",
+ "\n",
+ "```python\n",
+ "Slå Enter uten å skrive noe når du vil avslutte.\n",
+ "Beskriv deg selv med et adjektiv? snill\n",
+ "Hah, du snill!? Jeg er mye snillere!\n",
+ "Beskriv deg selv med et adjektiv? smart\n",
+ "Hah, du smart!? Jeg er mye smartere!\n",
+ "Beskriv deg selv med et adjektiv? flittig\n",
+ "Hah, du flittig!? Jeg er mye flittigere!\n",
+ "Beskriv deg selv med et adjektiv?\n",
+ "Takk for nå!\n",
+ "```\n",
+ "\n",
+ "Fjerde gang spørsmålet om adjektiv ble stilt, slo brukeren her bare Enter uten å skrive inn noen tegn, da avsluttet løkka og programmet gikk videre med å skrive \"Takk for nå\""
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def diss_brukeren_gjentatte_ganger():\n",
+ " i = 0\n",
+ " while i < 3:\n",
+ " adj = input(\"Beskriv deg selv med et adjektiv? \")\n",
+ " print(\"Hah, du\", adj + \"!? Jeg er mye\", adj + \"ere!\")\n",
+ " i += 1 # øker i med 1\n",
+ " print(\"Takk for nå!\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "hidden": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "**Hint:**\n",
+ "I eksemplet måtte vi sette i = 0 før vi kan utføre testen i < 3 i while-løkken. Hvis ikke i hadde fått noen verdi, ville testen gi feilmelding. Likeledes, hvis du skal teste på at adj != \"\" må adj ha fått en verdi før denne testen skjer. Altså må du gjøre den første input til adj før while-løkka starter.\n",
+ "\n",
+ "Inni while-løkka vil det da også være fornuftig å bytte om rekkefølgen på print-setningen og input-setningen, fordi du allerede har gjort en input før løkka som du kan basere den første \"Hah...\"-responsen på."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "## c)\n",
+ "Ta igjen utgangspunkt i while-løkka med 3 repetisjoner som vist før oppgave (b). Vi ønsker nå å endre programmet på følgende måte:\n",
+ "\n",
+ "Brukeren starter med 42 bokstaver til disposisjon. For hver runde skal programmet trekke fra antall bokstaver i det adjektivet som ble brukt.\n",
+ "\n",
+ "Løkka skal fortsette så lenge det fortsatt er bokstaver til disposisjon (dvs. dette tallet er større enn 0). \n",
+ "\n",
+ "**Eksempel på kjøring:**\n",
+ "\n",
+ "```python\n",
+ "Du har 42 bokstaver til disposisjon.\n",
+ "Beskriv deg selv med et adjektiv? snill\n",
+ "Hah, du snill!? Jeg er mye snillere!\n",
+ "Du har 37 bokstaver til disposisjon.\n",
+ "Beskriv deg selv med et adjektiv? desperat\n",
+ "Hah, du desperat!? Jeg er mye desperatere!\n",
+ "Du har 29 bokstaver til disposisjon.\n",
+ "Beskriv deg selv med et adjektiv? kjempetørst\n",
+ "Hah, du kjempetørst!? Jeg er mye kjempetørstere!\n",
+ "Du har 18 bokstaver til disposisjon.\n",
+ "Beskriv deg selv med et adjektiv? megasupereffektiv\n",
+ "Hah, du megasupereffektiv!? Jeg er mye megasupereffektivere!\n",
+ "Du har 1 bokstaver til disposisjon.\n",
+ "Beskriv deg selv med et adjektiv? o\n",
+ "Hah, du o!? Jeg er mye oere!\n",
+ "Takk for nå!\n",
+ ">>>\n",
+ "```\n",
+ "\n",
+ "I siste linje, hvor det bare er 1 bokstav til disposisjon, er brukeren lojal her og skrive bare en bokstav - men du behøver ikke lage programmet slik at det sikrer dette... det er ok om brukeren skriver et lenger ord den siste gangen, så lenge brukeren ikke får lov til å skrive nye ord når antall bokstaver til disposisjon er blitt <= 0."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "heading_collapsed": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "**Hint:** I stedet for tellevariabelen i som starter på 0, og med betingelse < 3 i while-setninga, må du nå ha en variabel som starter på 42, og hvor lengden av hvert nye ord trekkes fra i løkka. Lengde kan finnes med funksjonen len(), dvs. len(adj) gir lengden til strengen adj. Testen i while-setninga må også tilpasses til det vi nå er ute etter, nemlig å fortsette så lenge det fremdeles er bokstaver til disposisjon."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "hidden": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "#### Intro til for-løkke og range()\n",
+ "Som forklart over, er for-løkker egnet for tilfeller hvor antall repetisjoner er kjent. I oppgave (a) startet vi med kode:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "hidden": true
+ },
+ "outputs": [],
+ "source": [
+ "def diss_brukeren_n_ganger(n):\n",
+ " \n",
+ " for i in range(3):\n",
+ " adj = input(\"Beskriv deg selv med et adjektiv? \")\n",
+ " print(\"Hah, du\", adj + \"!? Jeg er mye\", adj + \"ere!\")\n",
+ " \n",
+ " print(\"Takk for nå!\")\n",
+ "\n",
+ "n = input(\"Hvor mange adjektiv vil du gi? \")\n",
+ "diss_brukeren_n_ganger(n)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "hidden": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "som repeterer 3 ganger. Du byttet deretter ut tallet 3 med en variabel for å kunne repetere et annet (men fortsatt kjent) antall ganger.\n",
+ "\n",
+ "I oppgave (a) ble løkkevariabelen i ikke brukt til noe inni selve løkka, den fins kun i for-setningen. Poenget i denne løkka er bare å telle opp at den kjører 3 ganger, i har ingen mening utover det.\n",
+ "\n",
+ "I andre tilfeller hvor vi bruker for-løkker kan løkkevariabelen ha en større betydning. Det er da viktig å forstå ikke bare at f.eks. range(3) fører til 3 repetisjoner, men å vite eksakt hvilken tallsekvens en range() representerer.\n",
+ "\n",
+ "Generelt gjelder følgende:\n",
+ "\n",
+ "* Hvis vi gir inn bare **ett tall** til range(), tolkes dette som sluttverdien. Startverdien er default 0. Sluttverdien selv er **ikke** med i sekvensen; det er \"til\", ikke \"til og med\". Eksempel:\n",
+ " * range(3) gir tallsekvensen 0, 1, 2. Løkka over kjører 3 ganger ved å ta først med i=0, så med i=1, så med i=2.\n",
+ " * range(5) gir 0, 1, 2, 3, 4\n",
+ " * range(0) gir en tom tallsekvens. Samme vil være tilfelle med negative tall; og en løkke for i in range(0): vil kjøre null ganger.\n",
+ "* Hvis vi gir inn **to tall** til range(), tolkes dette som startverdi (fra og med) og sluttverdi (til, men ikke med). Eksempel:\n",
+ " * range(1, 7) gir 1, 2, 3, 4, 5, 6\n",
+ " * range(-3, 4) gir -3, -2, -1, 0, 1, 2, 3\n",
+ " * range(4, 3) gir en tom tallsekvens (fordi sluttverdi er mindre enn startverdi)\n",
+ "* Hvis vi gir inn tre tall til range(), er de to første start og slutt som før, det tredje er stegverdien. Default stegverdi er +1, så vi trenger kun angi den hvis vi ønsker noe annet enn +1. Eksempel:\n",
+ " * range(1, 10, 2) gir 1, 3, 5, 7, 9\n",
+ " * range(3, 11, 4) gir 3, 7 (men ikke 11, fordi det bare er til sluttverdien, ikke til og med)\n",
+ " * range(11, 3, -2) gir 11, 9, 7, 5 - det går altså an å bruke negative tall for stegverdi, da må startverdi være større enn sluttverdi for at løkka skal kjøre\n",
+ "\n",
+ "På basis av dette kan vi endre det lille programmet over til ett som bruker variabelen i også inne i løkka, f.eks. (**Kjør gjerne selv koden med ctrl + enter, og ta gjerne å endre på verdiene for å se hva som skjer**)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "hidden": true
+ },
+ "outputs": [],
+ "source": [
+ "for i in range(7, 14, 3):\n",
+ " adj = input(\"Beskriv deg selv med et adjektiv? \")\n",
+ " print(\"Hah, du\", adj + \"!? Jeg er\", i, \"ganger\", adj + \"ere!\")\n",
+ "print(\"Takk for nå!\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "hidden": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Her vil koden fortsatt kjøre 3 ganger fordi den resulterende tallsekvensen har 3 elementer, men bruken av i inni løkka gjør programmet mer og mer skrytende. (Bare range(3) ville ikke ha sett like bra ut her, da sier den \"0 ganger...\", \"1 ganger...\" som ikke er særlig imponerende)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "hidden": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Et annet eksempel (kjør koden!):"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "metadata": {
+ "hidden": true
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Hvilket tall vil du se gangetabellen for? 6\n",
+ "6-gangen går slik:\n",
+ "6 12 18 24 30 36 42 48 54 60 Takk for nå!\n"
+ ]
+ }
+ ],
+ "source": [
+ "tall = int(input(\"Hvilket tall vil du se gangetabellen for? \"))\n",
+ "print(str(tall)+\"-gangen går slik:\")\n",
+ " \n",
+ "for i in range(1, 11):\n",
+ " print(i * tall, end = \" \")\n",
+ " \n",
+ "print(\"Takk for nå!\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "hidden": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Merk igjen at sluttverdien er til, men ikke med, så vi må gi 11 som sluttverdi i range() for at den skal få med 70 i resultatet, dersom vi vil se hele 7-gangen.\n",
+ "\n",
+ "end = \" \" i print-setninga gjør at vi ikke får linjeskift mellom hvert tall men i stedet får dem etter hverandre med blanke mellom.\n",
+ "\n",
+ " \n",
+ "\n",
+ "Problemet kunne alternativt ha vært løst ved å bruke tallet det skal ganges med som stegverdi. Ulempen er at range-uttrykket blir litt mer komplisert, men samtidig slipper vi nå unna med en enkelt multiplikasjon utenfor løkka i stedet for å multiplisere i hver runde av løkka:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2019-07-02T12:45:50.304075Z",
+ "start_time": "2019-07-02T12:33:15.731777Z"
+ },
+ "hidden": true
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Hvilket tall vil du se gangetabellen for? 6\n",
+ "6-gangen går slik:\n",
+ "6 12 18 24 30 36 42 48 54 60 Takk for nå!\n"
+ ]
+ }
+ ],
+ "source": [
+ "tall = int(input(\"Hvilket tall vil du se gangetabellen for? \"))\n",
+ "print(str(tall)+\"-gangen går slik:\")\n",
+ " \n",
+ "for i in range(tall, tall * 10 + 1, tall):\n",
+ " print(i, end = \" \")\n",
+ " \n",
+ "print(\"Takk for nå!\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "hidden": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Dette programmet vil gi eksakt samme utskrift som det foregående, bare oppnådd på en litt annen måte; for 7-gangen vil nå 7 være startverdi og stegverdi, og 71 sluttverdi for range()."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "## d)\n",
+ "koden under er de to første for-løkkene ferdige og gir riktig utskrift i forhold til den forklarende teksten i print-setningene.\n",
+ "\n",
+ "Den neste oppgaven er ikke ferdig. Bytt ut `range(0)` i disse tre (også merket med ###) slik at for-løkken gir tallsekvenser som passer med det som forklares i print-setningene.\n",
+ "\n",
+ "\n",
+ "**Øvelse på range()**"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Oddetallene fra 1 til 20:\n",
+ "1 3 5 7 9 11 13 15 17 19 \n",
+ "Tallene i 3-gangen mellom 12 og 25:\n",
+ "12 15 18 21 24 \n"
+ ]
+ }
+ ],
+ "source": [
+ "#Oddetall fra til\n",
+ "\n",
+ "#Oddetall i gange\n",
+ "\n",
+ "#tallsekvens\n",
+ "\n",
+ "#telle baklengs med gitt intervall fra til\n",
+ "\n",
+ "print(\"Oddetallene fra 1 til 20:\")\n",
+ "def oddetall_fra_til(fra, til):\n",
+ " for number in range(fra, til + 1, 2):\n",
+ " print(number, end = \" \")\n",
+ " \n",
+ "oddetall_fra_til(1,20)\n",
+ "print()\n",
+ "\n",
+ "print(\"Tallene i 3-gangen mellom 12 og 25:\")\n",
+ "def tre_gangen(fra,til):\n",
+ " for number in range(fra,til,3):\n",
+ " print(number, end = \" \")\n",
+ "\n",
+ "tre_gangen(12,25)\n",
+ "\n",
+ "#Fullfør funksjonen under:\n",
+ "\n",
+ "def x_gangen(x): # Tar in x, og returnerer de 10 første tallene i x-gangen\n",
+ " for number in range(0): ###\n",
+ " print(number, end = \" \")\n",
+ " print()\n",
+ "x_gangen(5)\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "## e)\n",
+ "Lag et funksjon, print_numbers(start, stop), som printer tallene fra start til og med stop. Bruk en forløkke i funksjonen.\n",
+ "\n",
+ "***Skriv koden din her:***"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2019-07-02T12:45:50.308821Z",
+ "start_time": "2019-07-02T12:37:38.116Z"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "1\n",
+ "2\n",
+ "3\n",
+ "4\n",
+ "5\n"
+ ]
+ }
+ ],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "## f) \n",
+ "Lag et funksjon print_numbers_reversed(start,stop), som printer ut tallene fra stop til start. Her skal start være et mindre tall enn stop. Bruk en forløkke.\n",
+ "\n",
+ "***Skriv koden din her:***"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "15\n",
+ "14\n",
+ "13\n",
+ "12\n",
+ "11\n",
+ "10\n",
+ "9\n",
+ "8\n",
+ "7\n",
+ "6\n",
+ "5\n",
+ "4\n",
+ "3\n",
+ "2\n",
+ "1\n"
+ ]
+ }
+ ],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "heading_collapsed": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "hidden": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "## Evig while-løkke\n",
+ "Hvis en while-løkke ikke blir stoppet kan den kjøre evig. Et eksempel er en løkke som starter ***while True*** ; da vil betingelsen alltid være sann uansett hva som skjer inni løkka. Løkka vist under vil printe Jeg elsker ITGK! et uendelig antall ganger.\n",
+ "\n",
+ "Det vil vanligvis gå greit å stoppe programmet likevel, enten ved å trykke Ctrl-C eller ved å lukke vinduet der koden kjører... men **lagre for sikkerhets skyld alle filer du jobber med før du eksperimenterer med å kjøre en evig løkke**.\n",
+ "\n",
+ "Eksempel på en evig løkke:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2019-07-02T12:45:50.310736Z",
+ "start_time": "2019-07-02T12:40:47.558Z"
+ },
+ "hidden": true
+ },
+ "outputs": [],
+ "source": [
+ "while True:\n",
+ " print(\"Jeg elsker ITGK!\")"
+ ]
+ }
+ ],
+ "metadata": {
+ "celltoolbar": "Edit Metadata",
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.7.4"
+ },
+ "toc": {
+ "base_numbering": 1,
+ "nav_menu": {},
+ "number_sections": false,
+ "sideBar": true,
+ "skip_h1_title": false,
+ "title_cell": "Table of Contents",
+ "title_sidebar": "Contents",
+ "toc_cell": false,
+ "toc_position": {},
+ "toc_section_display": true,
+ "toc_window_display": false
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/Ovinger/Oving3/Kodeforstaelse.ipynb b/Ovinger/Oving3/Kodeforstaelse.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..535e7f3db3e1494dd1218de2ed98816a2aea70fb
--- /dev/null
+++ b/Ovinger/Oving3/Kodeforstaelse.ipynb
@@ -0,0 +1,322 @@
+{
+ "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=\"_Oving3.ipynb\">Øving 3</a>\n",
+ " </div>\n",
+ " <ul class=\"nav navbar-nav\">\n",
+ " <li ><a href=\"Intro%20til%20lokker.ipynb\">Intro til løkker</a></li>\n",
+ " <li ><a href=\"Mer%20om%20lokker.ipynb\">Mer om løkker</a></li>\n",
+ " <li><a href=\"Nostede%20lokker.ipynb\">Intro til nøstede løkker</a></li>\n",
+ " <li class=\"active\"><a href=\"Kodeforstaelse.ipynb\">Kodeforståelse</a></li>\n",
+ " <li ><a href=\"Gjett%20tallet.ipynb\">Gjett tallet</a></li>\n",
+ " <li ><a href=\"Tekstbasert%20spill%202.ipynb\">Tekstbasert spill 2</a></li>\n",
+ " <li ><a href=\"Geometrisk%20rekke.ipynb\">Geometrisk rekke</a></li>\n",
+ " <li ><a href=\"Fibonacci.ipynb\">Fibonacci</a></li>\n",
+ " <li><a href=\"Alternerende%20sum.ipynb\">Alternerende sum</a></li>\n",
+ " <li ><a href=\"Hangman.ipynb\">Hangman</a></li>\n",
+ " <li ><a href=\"Derivasjon.ipynb\">Derivasjon</a></li>\n",
+ " <li ><a href=\"Doble%20lokker.ipynb\">Doble løkker</a></li>\n",
+ " </ul>\n",
+ " </div>\n",
+ "</nav>\n",
+ "\n",
+ "# Kodeforståelse\n",
+ "\n",
+ "**Læringsmål:**\n",
+ "\n",
+ "* Tolke kode\n",
+ "\n",
+ "Koden under kan ikke kjøres, her skal du tenke deg fram til svarene! Ca. 20% av eksamen er kodeforståelse så se på dette som god trening! "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "**a)** Hva skrives ut i koden under?"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2019-07-02T13:32:20.691362Z",
+ "start_time": "2019-07-02T13:32:20.393635Z"
+ },
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "```python\n",
+ "a=345\n",
+ "b=''\n",
+ "while a or b=='':\n",
+ " b=str(a%2)+b\n",
+ " a=a//2\n",
+ "print(b)\n",
+ "```"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Svar: < dobbeltklikk her>"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "**b)** Hva skrives ut i koden under?"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "```python\n",
+ "def mysterious_function(x, y):\n",
+ " \n",
+ " for x in range(x,y,2):\n",
+ " print(x, end = '')\n",
+ " if x%4 == 0: \n",
+ " print(\": Dette tallet går opp i 4-gangeren\")\n",
+ " else: \n",
+ " print()\n",
+ " \n",
+ "mysterious_function(0,10)\n",
+ " \n",
+ " ```\n",
+ " \n",
+ "`end=\"\"` gjør at det neste som printes ikke printes en linje under, men at det fortsetter på samme linje."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Svar: < dobbeltklikk her>"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "**c)** Hva skrives ut i koden under?"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "```python\n",
+ "def mysterious_function_x():\n",
+ " result = 1\n",
+ " while result<10:\n",
+ " result = result*2\n",
+ " return result\n",
+ "\n",
+ "mysterious_function_x()\n",
+ "```"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Svar: < dobbeltklikk her>"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "**d)** Hva skrives ut i koden under?"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2019-07-02T13:41:54.677954Z",
+ "start_time": "2019-07-02T13:41:54.667307Z"
+ },
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "```python\n",
+ "i = 1\n",
+ "j = 3\n",
+ "while j>0:\n",
+ " i = i*2\n",
+ " j = j - 1\n",
+ "print(i)```"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Svar: < dobbeltklikk her>"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "**e)** Hva skrives ut i koden under?\n",
+ "\n",
+ "```python\n",
+ "\n",
+ "def mysterious_function_z(i):\n",
+ " outer_string = \"\"\n",
+ " for x in range(i):\n",
+ " inner_string = \"\"\n",
+ " for y in range(x+1):\n",
+ " inner_string += \"*\"\n",
+ " outer_string += inner_string + \"\\n\"\n",
+ " return outer_string\n",
+ "\n",
+ "print(mysterious_function_z(5))\n",
+ " \n",
+ " \n",
+ " \n",
+ " \n",
+ " \n",
+ " \n",
+ "i = 5\n",
+ "for x in range(i):\n",
+ " for y in range(x+1):\n",
+ " print(\"*\", end=\"\")\n",
+ " print()```\n",
+ " \n",
+ "Her er det en dobbel løkke, så dette er nok nytt for mange. Prøv likevel! Hvordan fungerer egentlig en løkke i en løkke? Se side 176 i Starting Out with Python."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Svar: < dobbeltklikk her>"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def mysterious_function_z(i):\n",
+ " outer_string = \"\"\n",
+ " for x in range(i):\n",
+ " inner_string = \"\"\n",
+ " for y in range(x+1):\n",
+ " inner_string += \"*\"\n",
+ " outer_string += inner_string + \"\\n\"\n",
+ " return outer_string\n",
+ "\n",
+ "print(mysterious_function_z(5))"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ }
+ ],
+ "metadata": {
+ "celltoolbar": "Edit Metadata",
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.7.4"
+ },
+ "toc": {
+ "base_numbering": 1,
+ "nav_menu": {},
+ "number_sections": false,
+ "sideBar": true,
+ "skip_h1_title": false,
+ "title_cell": "Table of Contents",
+ "title_sidebar": "Contents",
+ "toc_cell": false,
+ "toc_position": {},
+ "toc_section_display": true,
+ "toc_window_display": false
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/Ovinger/Oving3/Mer om lokker.ipynb b/Ovinger/Oving3/Mer om lokker.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..51b988d392f53220c860abce9eb864484b9c7fc0
--- /dev/null
+++ b/Ovinger/Oving3/Mer om lokker.ipynb
@@ -0,0 +1,454 @@
+{
+ "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=\"_Oving3.ipynb\">Øving 3</a>\n",
+ " </div>\n",
+ " <ul class=\"nav navbar-nav\">\n",
+ " <li ><a href=\"#\">Intro til løkker</a></li>\n",
+ " <li class=\"active\"><a href=\"Mer%20om%20lokker.ipynb\">Mer om løkker</a></li>\n",
+ " <li><a href=\"Nostede%20lokker.ipynb\">Intro til nøstede løkker</a></li>\n",
+ " <li><a href=\"Kodeforstaelse.ipynb\">Kodeforståelse</a></li>\n",
+ " <li ><a href=\"Gjett%20tallet.ipynb\">Gjett tallet</a></li>\n",
+ " <li ><a href=\"Geometrisk%20rekke.ipynb\">Geometrisk rekke</a></li>\n",
+ " <li ><a href=\"Tekstbasert%20spill%202.ipynb\">Tekstbasert spill 2</a></li>\n",
+ " <li ><a href=\"Fibonacci.ipynb\">Fibonacci</a></li>\n",
+ " <li><a href=\"Alternerende%20sum.ipynb\">Alternerende sum</a></li>\n",
+ " <li ><a href=\"Hangman.ipynb\">Hangman</a></li>\n",
+ " <li ><a href=\"Derivasjon.ipynb\">Derivasjon</a></li>\n",
+ " <li ><a href=\"Doble%20lokker.ipynb\">Doble løkker</a></li>\n",
+ " </ul>\n",
+ " </div>\n",
+ "</nav>\n",
+ "\n",
+ "# Mer om løkker - oppsamlingsløkker\n",
+ "\n",
+ "**Læringsmål:**\n",
+ "\n",
+ "* Løkker\n",
+ "\n",
+ "I denne oppgaven ser vi spesielt på løkker som samler opp et resultat underveis. Hvis du har programmert noe før, vil dette være enkle oppgaver, men for deg som er helt uerfaren, se gjerne på følgende tutorial om oppsamlingsløkker før du setter i gang:"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "heading_collapsed": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "### Tutorial om oppsamlingsløkker"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "hidden": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Ofte brukes løkker til å samle opp et resultat (f.eks. en tallverdi) som vi er interessert i å finne. Et enkelt eksempel på en oppsamlingsløkke, er følgende som summerer alle tallene fra og med 1 til og med 100 (som egentlig er en unødvendig løkke å kjøre siden resultatet er kjent på forhånd, men greit å bruke som illustrasjon):"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "hidden": true
+ },
+ "outputs": [],
+ "source": [
+ "summen = 0\n",
+ "for i in range(1, 101):\n",
+ " summen += i # summen = summen + i\n",
+ "print(\"Summen av tallene 1-100:\", summen)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "hidden": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "range() må ha 101 som sluttverdi fordi den er til men ikke med, dvs. hvis tallet 100 skal være med i summen. Variabelen **summen** er den som brukes til å samle opp resultatet underveis. Det kunne ha vært fristende å kalle variabelen bare sum, men dette er navnet på en standardfunksjon i Python og dermed ikke lurt å bruke som variabelnavn. Merk deg at summen må defineres **før** løkka, og der gis verdien 0 (fordi vi ikke har summert inn noen av tallene ennå). Dette fordi vi inni løkka ønsker å utføre summen = summen + 1 (som kortere kan skrives summen += 1), og et slikt uttrykk hvor summen også fins på høyre side av = kan bare fungere hvis den allerede har fått en verdi. Måten dette programmet funker på, er altså at vi starter med å gi summen verdi 0. Så begynner løkka, med i = 1, og vi legger til i (dvs. 1) til summen som da blir 1. Så blir i 2, som legges til summen, som nå blir 3. Så i=3, summen = 6. Så i=4, summen = 10, osv. Siste gang løkka kjøres er i=100 og summen blir 5050, så avslutter løkka og vi printer resultatet på skjermen.\n",
+ "\n",
+ "Tilsvarende hvis vi skulle gange sammen alle tallene 1-20:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "hidden": true
+ },
+ "outputs": [],
+ "source": [
+ "produktet = 1\n",
+ "for i in range(1, 20):\n",
+ " produktet *= i # produktet = produktet * i\n",
+ "print(\"Produktet av tallene 1-20:\", produktet)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "hidden": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Strukturelt er dette temmelig likt - en viktig forskjell er at når vi skal gange, blir riktig startverdi 1 (som er det tallet som ikke påvirker et produkt) mens det var 0 for summering.\n",
+ "\n",
+ "Til slutt et lite eksempel der det passer bedre med while enn med for, fordi vi ikke aner antall repetisjoner:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "hidden": true
+ },
+ "outputs": [],
+ "source": [
+ "print(\"Skriv inn ett og ett positivt heltall.\")\n",
+ "print(\"For å avslutte, skriv et negativt tall (dette telles ikke med).\")\n",
+ "tall = int(input(\"Tall: \"))\n",
+ "storst = tall # første tall er størst, inntil annet bevist\n",
+ "antall = 0\n",
+ " \n",
+ "while tall >= 0:\n",
+ " if tall > storst:\n",
+ " storst = tall\n",
+ " antall += 1\n",
+ " tall = int(input(\"Tall: \"))\n",
+ " \n",
+ "print(\"Du skrev inn\", antall, \"tall.\")\n",
+ "print(\"Det største var\", storst)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "hidden": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Her skriver brukeren inn en serie tall fra tastaturet - og gir et negativt tall for å avslutte - og programmets oppgave til slutt er å kunne fortelle hvor mange tall som ble skrevet inn (bortsett fra det negative), og hva som var det største av tallene. For å telle opp antallet, har vi variabelen antall som settes til 0 før løkka, og deretter økes med 1 for hver runde av løkka. For å finne det største tallet, antar vi før løkka at det første tallet også er det største. (Vi må uansett lese det første tallet før løkka, for at while-testen skal funke). Deretter tester vi for hver runde av løkka om det sist innleste tallet er større enn det som var størst hittil, i så fall gis variabelen storst verdien til dette nye tallet i stedet. Variabelen storst vil dermed til en hver tid inneholde den største verdien hittil."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "### a)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Lag en funksjon som ved hjelp av en løkke ber brukeren om å taste inn x heltall, som vist i eksemplet på kjøring under. x tas inn som brukerinput. Til slutt skal funksjonen returnere summen av tallene.\n",
+ "\n",
+ "Eksempel på kjøring:\n",
+ "```\n",
+ "Hvor mange tall vil du summere? 7\n",
+ "Skriv inn et heltall: 6\n",
+ "Skriv inn et heltall: 4\n",
+ "Skriv inn et heltall: 7\n",
+ "Skriv inn et heltall: 3\n",
+ "Skriv inn et heltall: 2\n",
+ "Skriv inn et heltall: 456\n",
+ "Skriv inn et heltall: 99\n",
+ "Summen av tallene ble 577\n",
+ "```\n",
+ "\n",
+ "***Skriv koden din her:***"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "heading_collapsed": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "#### Hint"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "hidden": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Du vil trenge en variabel til å summere inn ett og ett nytt tall for hver runde av løkka. Husk at denne variabelen må være opprettet og gitt en passende startverdi før løkka, ellers vil du ikke klare å bruke den i løkka."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "### b)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Lag en funksjon som multipliserer sammen alle tallene fra 1,2,3,... og avslutter når produktet er større enn 1000.\n",
+ "\n",
+ "***Skriv koden din her:***"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2019-07-02T12:56:17.761917Z",
+ "start_time": "2019-07-02T12:56:17.756785Z"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "5040"
+ ]
+ },
+ "execution_count": 5,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "\n",
+ " "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "heading_collapsed": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "#### Hint 2"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "hidden": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Du vet ikke på forhånd hvor lenge du kan multiplisere tallene før du får et produkt større enn 1000, så her kan det være lurt å bruke en while-løkke med produkt mindre enn 1000 som betingelse. Svaret skal bli 5040. Som for oppgave (a) vil du trenge en variabel til å gange inn ett og ett nytt tall for hver runde av løkka, og som må ha fått en passende startverdi før løkka. Merk at passende startverdi for en variabel som skal samle opp et produkt, vil være et annet tall enn det man bruker som startverdi for å samle opp en sum."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "### c)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Lag en funksjon, quiztion(q, a) som stiller brukeren det samme spørsmålet q, om og om igjen, helt til det korrekte svaret blir skrevet. Funksjonen tar inn spørsålet q og svaret a som tekststrenger. Når rett svar er tastet inn av bruker skal programmet fortelle hvor mange forsøk som ble brukt. Eksempel på kjøring vist nedenfor, men du kan godt bytte ut med et spørsmål med annen tematikk, noe du selv er interessert i. Se ***hint 3*** dersom du står fast.\n",
+ "\n",
+ "Eksempel på kjøring:\n",
+ "\n",
+ "```\n",
+ "quiztion(\"Hva heter hovedstaden til Niue\", \"Alofi\")\n",
+ "\n",
+ "Hva heter hovedstaden til Niue? Niue City\n",
+ "Det var feil, prøv igjen.\n",
+ "Hva heter hovedstaden til Niue? Niuania\n",
+ "Det var feil, prøv igjen.\n",
+ "Hva heter hovedstaden til Niue? Apia\n",
+ "Det var feil, prøv igjen.\n",
+ "Hva heter hovedstaden til Niue? Alofi\n",
+ "Korrekt!! Du brukte 4 forsøk.\n",
+ "```\n",
+ "\n",
+ "***Skriv koden din her:***"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2019-07-02T13:03:21.820001Z",
+ "start_time": "2019-07-02T13:03:21.814887Z"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Hva er hovedstaden til Niue? alofi\n",
+ "Det var feil, prøv igjen.\n",
+ "Hva er hovedstaden til Niue? alfoi\n",
+ "Det var feil, prøv igjen.\n",
+ "Hva er hovedstaden til Niue? alfoi\n",
+ "Det var feil, prøv igjen.\n",
+ "Hva er hovedstaden til Niue? Alofi\n",
+ "Korrekt!! Du brukte 3 forsøk.\n"
+ ]
+ }
+ ],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "heading_collapsed": true
+ },
+ "source": [
+ "#### Hint 3"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "hidden": true
+ },
+ "source": [
+ "Du vet ikke hvor mange ganger brukeren svarer feil så det kan være lurt med en while-løkke hvor betingelsen er at brukerens svar != riktig svar."
+ ]
+ }
+ ],
+ "metadata": {
+ "celltoolbar": "Edit Metadata",
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.7.4"
+ },
+ "toc": {
+ "base_numbering": 1,
+ "nav_menu": {},
+ "number_sections": false,
+ "sideBar": true,
+ "skip_h1_title": false,
+ "title_cell": "Table of Contents",
+ "title_sidebar": "Contents",
+ "toc_cell": false,
+ "toc_position": {},
+ "toc_section_display": true,
+ "toc_window_display": false
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/Ovinger/Oving3/Nostede lokker.ipynb b/Ovinger/Oving3/Nostede lokker.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..28e436c9c49322c2a5922c513bdbba85063cb7ad
--- /dev/null
+++ b/Ovinger/Oving3/Nostede lokker.ipynb
@@ -0,0 +1,1956 @@
+{
+ "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=\"_Oving3.ipynb\">Øving 3</a>\n",
+ " </div>\n",
+ " <ul class=\"nav navbar-nav\">\n",
+ " <li ><a href=\"Intro%20til%20lokker.ipynb\">Intro til løkker</a></li>\n",
+ " <li ><a href=\"Mer%20om%20lokker.ipynb\">Mer om løkker</a></li>\n",
+ " <li class=\"active\"><a href=\"Nostede%20lokker.ipynb\">Intro til nøstede løkker</a></li>\n",
+ " <li><a href=\"Kodeforstaelse.ipynb\">Kodeforståelse</a></li>\n",
+ " <li ><a href=\"Gjett%20tallet.ipynb\">Gjett tallet</a></li>\n",
+ " <li ><a href=\"Tekstbasert%20spill%202.ipynb\">Tekstbasert spill 2</a></li>\n",
+ " <li ><a href=\"Geometrisk%20rekke.ipynb\">Geometrisk rekke</a></li>\n",
+ " <li ><a href=\"Fibonacci.ipynb\">Fibonacci</a></li>\n",
+ " <li><a href=\"Alternerende%20sum.ipynb\">Alternerende sum</a></li>\n",
+ " <li ><a href=\"Hangman.ipynb\">Hangman</a></li>\n",
+ " <li ><a href=\"Derivasjon.ipynb\">Derivasjon</a></li>\n",
+ " <li ><a href=\"Doble%20lokker.ipynb\">Doble løkker</a></li>\n",
+ " </ul>\n",
+ " </div>\n",
+ "</nav>\n",
+ "\n",
+ "# Intro til nøstede løkker\n",
+ "\n",
+ "**Læringsmål:**\n",
+ "\n",
+ "* Nøstede løkker\n",
+ "\n",
+ "I denne oppgaven skal du lære hvordan vi kan benytte oss av en løkke inne i en annen løkke. "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "hidden": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "### Intro til nøstede løkker\n",
+ "Nøstede løkker vil si løkker som er inni andre løkker. Et eksempel på en nøstet løkke er en dobbel løkke, som vil si at det er en løkke inni en annen løkke. Doble løkker brukes mye i programmering, typisk når man skal løse problemer som på en eller annen måte er todimensjonale, f.eks. knyttet til matriser eller todimensjonale tabeller med tall. Todimensjonal her kan bety rent visuelt (f.eks. at man skal tegne noe på en skjerm og må oppdatere fargen i hvert punkt i et rutenett av piksler), men behøver ikke å ha noen visuell betydning. Det kan være snakk om dimensjoner av informasjon på en mer abstrakt måte. F.eks. kan de to dimensjonene være tall og verdier i kortstokken, vi kan da generere en hel kortstokk ved en dobbel løkke som følger:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 14,
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2019-07-02T13:13:16.212772Z",
+ "start_time": "2019-07-02T13:13:16.199788Z"
+ },
+ "hidden": true
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "â™ A â™ 2 â™ 3 â™ 4 â™ 5 â™ 6 â™ 7 â™ 8 â™ 9 â™ 10 â™ J â™ Q â™ K \n",
+ "♣A ♣2 ♣3 ♣4 ♣5 ♣6 ♣7 ♣8 ♣9 ♣10 ♣J ♣Q ♣K \n",
+ "♥A ♥2 ♥3 ♥4 ♥5 ♥6 ♥7 ♥8 ♥9 ♥10 ♥J ♥Q ♥K \n",
+ "♦A ♦2 ♦3 ♦4 ♦5 ♦6 ♦7 ♦8 ♦9 ♦10 ♦J ♦Q ♦K \n",
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "\n",
+ "def format_card_deck():\n",
+ " \n",
+ " farger = ['♠', '♣', '♥', '♦']\n",
+ " verdier = ['A', '2', '3', '4', '5', '6', '7', '8',\n",
+ " '9', '10', 'J', 'Q', 'K']\n",
+ " outer_string = \"\"\n",
+ " \n",
+ " for farge in farger: # Traverse the farger-array\n",
+ " inner_string = \"\"\n",
+ " for verdi in verdier: # Traverse the verdier-array\n",
+ " inner_string += farge + verdi + \" \" # Add the current farge and verdi, in addition to spacing\n",
+ " outer_string += inner_string + \"\\n\" # add all the values of one farge to the result, and start at a new line\n",
+ " \n",
+ " return outer_string\n",
+ "\n",
+ "print(format_card_deck())\n",
+ "\n",
+ " "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "hidden": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Den innerste løkka går 13 runder hver gang den kjører fordi det er 13 elementer i sekvensen som gis til for-løkka (verdier). Den legger til hver av kortene i en farge til en indre streng. Denne strengen legges til en ytre streng når den indre forløkken er ferdig. Dermed får vi alle kortene av en sort hver gang den indre forløkken er ferdig å kjøre. Merk \"\\n\" i den ytre strengen. Dette gjør at vi skifter linje mellom hver gang den fullførte indre strengen legges til den ytre strengen. Den ytre løkka går 4 ganger, en for hver farge i kortstokken"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## a)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "**Eksempel på nøstet løkke med print**"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Jeg elsker ITGK! Jeg elsker ITGK! Jeg elsker ITGK! \n",
+ "Jeg elsker ITGK! Jeg elsker ITGK! Jeg elsker ITGK! \n",
+ "Jeg elsker ITGK! Jeg elsker ITGK! Jeg elsker ITGK! \n",
+ "Jeg elsker ITGK! Jeg elsker ITGK! Jeg elsker ITGK! \n",
+ "Jeg elsker ITGK! Jeg elsker ITGK! Jeg elsker ITGK! \n"
+ ]
+ }
+ ],
+ "source": [
+ "for x in range(5):\n",
+ " for y in range(3):\n",
+ " print(\"Jeg elsker ITGK! \", end=\" \")\n",
+ " print()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Under følger en funksjon og bygging av tekststreng som gir samme output som løkkene over:**"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 16,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Jeg elsker ITGK! Jeg elsker ITGK! Jeg elsker ITGK! \n",
+ "Jeg elsker ITGK! Jeg elsker ITGK! Jeg elsker ITGK! \n",
+ "Jeg elsker ITGK! Jeg elsker ITGK! Jeg elsker ITGK! \n",
+ "Jeg elsker ITGK! Jeg elsker ITGK! Jeg elsker ITGK! \n",
+ "Jeg elsker ITGK! Jeg elsker ITGK! Jeg elsker ITGK! \n",
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "def nested_loop_example():\n",
+ " \n",
+ " result_string = \"\"\n",
+ " \n",
+ " for x in range(5):\n",
+ " inner_string = \"\"\n",
+ " \n",
+ " for y in range(3):\n",
+ " inner_string += \"Jeg elsker ITGK! \"\n",
+ " \n",
+ " result_string += inner_string + \"\\n\"\n",
+ " return result_string\n",
+ "\n",
+ "print(nested_loop_example())"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Denne utskriften trenger man strengt tatt ikke dobbel løkke for å få til; selve utskriften gir riktig nok et todimensjonalt inntrykk, men siden den underliggende informasjonen ikke er todimensjonal men derimot konstant (samme utskrift \"Jeg elsker ITGK!\" i alle tilfeller), er det også greit mulig å klare dette med enkel løkke, eller helt uten løkker, som følger:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2019-07-02T13:15:07.223226Z",
+ "start_time": "2019-07-02T13:15:07.215744Z"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Jeg elsker ITGK! Jeg elsker ITGK! Jeg elsker ITGK!\n",
+ "Jeg elsker ITGK! Jeg elsker ITGK! Jeg elsker ITGK!\n",
+ "Jeg elsker ITGK! Jeg elsker ITGK! Jeg elsker ITGK!\n",
+ "Jeg elsker ITGK! Jeg elsker ITGK! Jeg elsker ITGK!\n",
+ "Jeg elsker ITGK! Jeg elsker ITGK! Jeg elsker ITGK!\n",
+ "Jeg elsker ITGK! Jeg elsker ITGK! Jeg elsker ITGK! \n",
+ "Jeg elsker ITGK! Jeg elsker ITGK! Jeg elsker ITGK! \n",
+ "Jeg elsker ITGK! Jeg elsker ITGK! Jeg elsker ITGK! \n",
+ "Jeg elsker ITGK! Jeg elsker ITGK! Jeg elsker ITGK! \n",
+ "Jeg elsker ITGK! Jeg elsker ITGK! Jeg elsker ITGK! \n",
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "# Løsning med enkel løkke:\n",
+ "for x in range(5):\n",
+ " print(\"Jeg elsker ITGK! Jeg elsker ITGK! Jeg elsker ITGK!\")\n",
+ "\n",
+ "# Løsning uten løkker; \"\\n\" er tegnet for linjeskift (newline på engelsk)\n",
+ "print(((\"Jeg elsker ITGK! \" * 3) + \"\\n\") * 5)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Koden over vil skrive ut “Jeg elsker ITGK!†tre ganger ved siden av hverandre fem ganger nedover. Dette skjer på to ulike måter, derav 10 linjer i outputen. \n",
+ "\n",
+ "Hvis vi nå endrer litt på kravene til programmet, så det skal handle om flere studenter enn \"Jeg\" og flere emner enn \"ITGK\", vil vi ha et genuint todimensjonalt problem (én dimensjon er studenter, en annen emner) hvor dobbel løkke vil være klart enkleste løsning. **Din oppgave: kopier funksjonen nested_loop_example(), endre programmet så det gir utskrift som vist nedenfor**. Fra forrige oppgave skal altså Jeg byttes ut med Stud <nummer>, og ITGK skal byttes ut med Emne <nummer>. Brukeren skal angi ønsket antall for både studenter og emner, 4 og 3 er bare eksempler.\n",
+ "\n",
+ "```\n",
+ "print(nested_loop_example())\n",
+ "Hvor mange studenter? 4\n",
+ "Hvor mange emner? 3\n",
+ "Stud 1 elsker Emne 1 ; Stud 1 elsker Emne 2 ; Stud 1 elsker Emne 3 ;\n",
+ "Stud 2 elsker Emne 1 ; Stud 2 elsker Emne 2 ; Stud 2 elsker Emne 3 ;\n",
+ "Stud 3 elsker Emne 1 ; Stud 3 elsker Emne 2 ; Stud 3 elsker Emne 3 ;\n",
+ "Stud 4 elsker Emne 1 ; Stud 4 elsker Emne 2 ; Stud 4 elsker Emne 3 ;\n",
+ "```\n",
+ "\n",
+ "**EKSTRA UTFORDRING** (ikke nødvendig for å få godkjent (a)): For å gjøre programmet litt mindre tørt og abstrakt, kan du prøve å endre så det skriver fornavn på personer i stedet for \"Stud x\", og navn på faktiske emner i stedet for Emne y - jfr eksempel med kortstokk i teksten \"Intro til nøstede løkker\" øverst i denne oppgaven. For å gjøre det mindre forutsigbart, kan du dessuten bruke funksjonen random() for å generere tilfeldige tall for hver runde av løkka, og ha en if-setning for å velge verb basert på verdien av dette. F.eks. \"elsker\" bare hvis tallet ble > 0.9, og gradvis litt mer beskjedne verb til lavere tallverdien var."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 13,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Hvor mange studenter ? 4\n",
+ "Antall emner ? 3\n",
+ "Stud 1 elsker Emne 1 Stud 1 elsker Emne 2 Stud 1 elsker Emne 3 \n",
+ "Stud 2 elsker Emne 1 Stud 2 elsker Emne 2 Stud 2 elsker Emne 3 \n",
+ "Stud 3 elsker Emne 1 Stud 3 elsker Emne 2 Stud 3 elsker Emne 3 \n",
+ "Stud 4 elsker Emne 1 Stud 4 elsker Emne 2 Stud 4 elsker Emne 3 \n"
+ ]
+ }
+ ],
+ "source": [
+ "antall_studenter = int(input(\"Hvor mange studenter ? \"))\n",
+ "antall_emner = int(input(\"Antall emner ? \"))\n",
+ "for i in range(1,antall_studenter+1):\n",
+ " for j in range(1, antall_emner + 1):\n",
+ " print(\"Stud \" + str(i) + \" elsker Emne \" + str(j), end = \" \")\n",
+ " print()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "## b)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Lag en funksjon som returnerer en tekststreng med alle klokkeslett i løpet av et døgn på en fin måte. Du trenger kun å tenke på timer og minutter. Klokkeslettene skal gå fra 0:0 til 23:59 som vist nedenfor.\n",
+ "\n",
+ "Eksempel på kjøring av kode:\n",
+ "\n",
+ "```python\n",
+ "print(klokkeslett())\n",
+ "\n",
+ "0:0\n",
+ "0:1\n",
+ "0:2\n",
+ ".\n",
+ ". # Alle klokkeslett i mellom her skal skrives ut\n",
+ ".\n",
+ "23:58\n",
+ "23:59```\n",
+ "\n",
+ "***Skriv koden din her:***"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2019-07-02T13:21:25.863928Z",
+ "start_time": "2019-07-02T13:21:25.855403Z"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "0:0\n",
+ "0:1\n",
+ "0:2\n",
+ "0:3\n",
+ "0:4\n",
+ "0:5\n",
+ "0:6\n",
+ "0:7\n",
+ "0:8\n",
+ "0:9\n",
+ "0:10\n",
+ "0:11\n",
+ "0:12\n",
+ "0:13\n",
+ "0:14\n",
+ "0:15\n",
+ "0:16\n",
+ "0:17\n",
+ "0:18\n",
+ "0:19\n",
+ "0:20\n",
+ "0:21\n",
+ "0:22\n",
+ "0:23\n",
+ "0:24\n",
+ "0:25\n",
+ "0:26\n",
+ "0:27\n",
+ "0:28\n",
+ "0:29\n",
+ "0:30\n",
+ "0:31\n",
+ "0:32\n",
+ "0:33\n",
+ "0:34\n",
+ "0:35\n",
+ "0:36\n",
+ "0:37\n",
+ "0:38\n",
+ "0:39\n",
+ "0:40\n",
+ "0:41\n",
+ "0:42\n",
+ "0:43\n",
+ "0:44\n",
+ "0:45\n",
+ "0:46\n",
+ "0:47\n",
+ "0:48\n",
+ "0:49\n",
+ "0:50\n",
+ "0:51\n",
+ "0:52\n",
+ "0:53\n",
+ "0:54\n",
+ "0:55\n",
+ "0:56\n",
+ "0:57\n",
+ "0:58\n",
+ "0:59\n",
+ "1:0\n",
+ "1:1\n",
+ "1:2\n",
+ "1:3\n",
+ "1:4\n",
+ "1:5\n",
+ "1:6\n",
+ "1:7\n",
+ "1:8\n",
+ "1:9\n",
+ "1:10\n",
+ "1:11\n",
+ "1:12\n",
+ "1:13\n",
+ "1:14\n",
+ "1:15\n",
+ "1:16\n",
+ "1:17\n",
+ "1:18\n",
+ "1:19\n",
+ "1:20\n",
+ "1:21\n",
+ "1:22\n",
+ "1:23\n",
+ "1:24\n",
+ "1:25\n",
+ "1:26\n",
+ "1:27\n",
+ "1:28\n",
+ "1:29\n",
+ "1:30\n",
+ "1:31\n",
+ "1:32\n",
+ "1:33\n",
+ "1:34\n",
+ "1:35\n",
+ "1:36\n",
+ "1:37\n",
+ "1:38\n",
+ "1:39\n",
+ "1:40\n",
+ "1:41\n",
+ "1:42\n",
+ "1:43\n",
+ "1:44\n",
+ "1:45\n",
+ "1:46\n",
+ "1:47\n",
+ "1:48\n",
+ "1:49\n",
+ "1:50\n",
+ "1:51\n",
+ "1:52\n",
+ "1:53\n",
+ "1:54\n",
+ "1:55\n",
+ "1:56\n",
+ "1:57\n",
+ "1:58\n",
+ "1:59\n",
+ "2:0\n",
+ "2:1\n",
+ "2:2\n",
+ "2:3\n",
+ "2:4\n",
+ "2:5\n",
+ "2:6\n",
+ "2:7\n",
+ "2:8\n",
+ "2:9\n",
+ "2:10\n",
+ "2:11\n",
+ "2:12\n",
+ "2:13\n",
+ "2:14\n",
+ "2:15\n",
+ "2:16\n",
+ "2:17\n",
+ "2:18\n",
+ "2:19\n",
+ "2:20\n",
+ "2:21\n",
+ "2:22\n",
+ "2:23\n",
+ "2:24\n",
+ "2:25\n",
+ "2:26\n",
+ "2:27\n",
+ "2:28\n",
+ "2:29\n",
+ "2:30\n",
+ "2:31\n",
+ "2:32\n",
+ "2:33\n",
+ "2:34\n",
+ "2:35\n",
+ "2:36\n",
+ "2:37\n",
+ "2:38\n",
+ "2:39\n",
+ "2:40\n",
+ "2:41\n",
+ "2:42\n",
+ "2:43\n",
+ "2:44\n",
+ "2:45\n",
+ "2:46\n",
+ "2:47\n",
+ "2:48\n",
+ "2:49\n",
+ "2:50\n",
+ "2:51\n",
+ "2:52\n",
+ "2:53\n",
+ "2:54\n",
+ "2:55\n",
+ "2:56\n",
+ "2:57\n",
+ "2:58\n",
+ "2:59\n",
+ "3:0\n",
+ "3:1\n",
+ "3:2\n",
+ "3:3\n",
+ "3:4\n",
+ "3:5\n",
+ "3:6\n",
+ "3:7\n",
+ "3:8\n",
+ "3:9\n",
+ "3:10\n",
+ "3:11\n",
+ "3:12\n",
+ "3:13\n",
+ "3:14\n",
+ "3:15\n",
+ "3:16\n",
+ "3:17\n",
+ "3:18\n",
+ "3:19\n",
+ "3:20\n",
+ "3:21\n",
+ "3:22\n",
+ "3:23\n",
+ "3:24\n",
+ "3:25\n",
+ "3:26\n",
+ "3:27\n",
+ "3:28\n",
+ "3:29\n",
+ "3:30\n",
+ "3:31\n",
+ "3:32\n",
+ "3:33\n",
+ "3:34\n",
+ "3:35\n",
+ "3:36\n",
+ "3:37\n",
+ "3:38\n",
+ "3:39\n",
+ "3:40\n",
+ "3:41\n",
+ "3:42\n",
+ "3:43\n",
+ "3:44\n",
+ "3:45\n",
+ "3:46\n",
+ "3:47\n",
+ "3:48\n",
+ "3:49\n",
+ "3:50\n",
+ "3:51\n",
+ "3:52\n",
+ "3:53\n",
+ "3:54\n",
+ "3:55\n",
+ "3:56\n",
+ "3:57\n",
+ "3:58\n",
+ "3:59\n",
+ "4:0\n",
+ "4:1\n",
+ "4:2\n",
+ "4:3\n",
+ "4:4\n",
+ "4:5\n",
+ "4:6\n",
+ "4:7\n",
+ "4:8\n",
+ "4:9\n",
+ "4:10\n",
+ "4:11\n",
+ "4:12\n",
+ "4:13\n",
+ "4:14\n",
+ "4:15\n",
+ "4:16\n",
+ "4:17\n",
+ "4:18\n",
+ "4:19\n",
+ "4:20\n",
+ "4:21\n",
+ "4:22\n",
+ "4:23\n",
+ "4:24\n",
+ "4:25\n",
+ "4:26\n",
+ "4:27\n",
+ "4:28\n",
+ "4:29\n",
+ "4:30\n",
+ "4:31\n",
+ "4:32\n",
+ "4:33\n",
+ "4:34\n",
+ "4:35\n",
+ "4:36\n",
+ "4:37\n",
+ "4:38\n",
+ "4:39\n",
+ "4:40\n",
+ "4:41\n",
+ "4:42\n",
+ "4:43\n",
+ "4:44\n",
+ "4:45\n",
+ "4:46\n",
+ "4:47\n",
+ "4:48\n",
+ "4:49\n",
+ "4:50\n",
+ "4:51\n",
+ "4:52\n",
+ "4:53\n",
+ "4:54\n",
+ "4:55\n",
+ "4:56\n",
+ "4:57\n",
+ "4:58\n",
+ "4:59\n",
+ "5:0\n",
+ "5:1\n",
+ "5:2\n",
+ "5:3\n",
+ "5:4\n",
+ "5:5\n",
+ "5:6\n",
+ "5:7\n",
+ "5:8\n",
+ "5:9\n",
+ "5:10\n",
+ "5:11\n",
+ "5:12\n",
+ "5:13\n",
+ "5:14\n",
+ "5:15\n",
+ "5:16\n",
+ "5:17\n",
+ "5:18\n",
+ "5:19\n",
+ "5:20\n",
+ "5:21\n",
+ "5:22\n",
+ "5:23\n",
+ "5:24\n",
+ "5:25\n",
+ "5:26\n",
+ "5:27\n",
+ "5:28\n",
+ "5:29\n",
+ "5:30\n",
+ "5:31\n",
+ "5:32\n",
+ "5:33\n",
+ "5:34\n",
+ "5:35\n",
+ "5:36\n",
+ "5:37\n",
+ "5:38\n",
+ "5:39\n",
+ "5:40\n",
+ "5:41\n",
+ "5:42\n",
+ "5:43\n",
+ "5:44\n",
+ "5:45\n",
+ "5:46\n",
+ "5:47\n",
+ "5:48\n",
+ "5:49\n",
+ "5:50\n",
+ "5:51\n",
+ "5:52\n",
+ "5:53\n",
+ "5:54\n",
+ "5:55\n",
+ "5:56\n",
+ "5:57\n",
+ "5:58\n",
+ "5:59\n",
+ "6:0\n",
+ "6:1\n",
+ "6:2\n",
+ "6:3\n",
+ "6:4\n",
+ "6:5\n",
+ "6:6\n",
+ "6:7\n",
+ "6:8\n",
+ "6:9\n",
+ "6:10\n",
+ "6:11\n",
+ "6:12\n",
+ "6:13\n",
+ "6:14\n",
+ "6:15\n",
+ "6:16\n",
+ "6:17\n",
+ "6:18\n",
+ "6:19\n",
+ "6:20\n",
+ "6:21\n",
+ "6:22\n",
+ "6:23\n",
+ "6:24\n",
+ "6:25\n",
+ "6:26\n",
+ "6:27\n",
+ "6:28\n",
+ "6:29\n",
+ "6:30\n",
+ "6:31\n",
+ "6:32\n",
+ "6:33\n",
+ "6:34\n",
+ "6:35\n",
+ "6:36\n",
+ "6:37\n",
+ "6:38\n",
+ "6:39\n",
+ "6:40\n",
+ "6:41\n",
+ "6:42\n",
+ "6:43\n",
+ "6:44\n",
+ "6:45\n",
+ "6:46\n",
+ "6:47\n",
+ "6:48\n",
+ "6:49\n",
+ "6:50\n",
+ "6:51\n",
+ "6:52\n",
+ "6:53\n",
+ "6:54\n",
+ "6:55\n",
+ "6:56\n",
+ "6:57\n",
+ "6:58\n",
+ "6:59\n",
+ "7:0\n",
+ "7:1\n",
+ "7:2\n",
+ "7:3\n",
+ "7:4\n",
+ "7:5\n",
+ "7:6\n",
+ "7:7\n",
+ "7:8\n",
+ "7:9\n",
+ "7:10\n",
+ "7:11\n",
+ "7:12\n",
+ "7:13\n",
+ "7:14\n",
+ "7:15\n",
+ "7:16\n",
+ "7:17\n",
+ "7:18\n",
+ "7:19\n",
+ "7:20\n",
+ "7:21\n",
+ "7:22\n",
+ "7:23\n",
+ "7:24\n",
+ "7:25\n",
+ "7:26\n",
+ "7:27\n",
+ "7:28\n",
+ "7:29\n",
+ "7:30\n",
+ "7:31\n",
+ "7:32\n",
+ "7:33\n",
+ "7:34\n",
+ "7:35\n",
+ "7:36\n",
+ "7:37\n",
+ "7:38\n",
+ "7:39\n",
+ "7:40\n",
+ "7:41\n",
+ "7:42\n",
+ "7:43\n",
+ "7:44\n",
+ "7:45\n",
+ "7:46\n",
+ "7:47\n",
+ "7:48\n",
+ "7:49\n",
+ "7:50\n",
+ "7:51\n",
+ "7:52\n",
+ "7:53\n",
+ "7:54\n",
+ "7:55\n",
+ "7:56\n",
+ "7:57\n",
+ "7:58\n",
+ "7:59\n",
+ "8:0\n",
+ "8:1\n",
+ "8:2\n",
+ "8:3\n",
+ "8:4\n",
+ "8:5\n",
+ "8:6\n",
+ "8:7\n",
+ "8:8\n",
+ "8:9\n",
+ "8:10\n",
+ "8:11\n",
+ "8:12\n",
+ "8:13\n",
+ "8:14\n",
+ "8:15\n",
+ "8:16\n",
+ "8:17\n",
+ "8:18\n",
+ "8:19\n",
+ "8:20\n",
+ "8:21\n",
+ "8:22\n",
+ "8:23\n",
+ "8:24\n",
+ "8:25\n",
+ "8:26\n",
+ "8:27\n",
+ "8:28\n",
+ "8:29\n",
+ "8:30\n",
+ "8:31\n",
+ "8:32\n",
+ "8:33\n",
+ "8:34\n",
+ "8:35\n",
+ "8:36\n",
+ "8:37\n",
+ "8:38\n",
+ "8:39\n",
+ "8:40\n",
+ "8:41\n",
+ "8:42\n",
+ "8:43\n",
+ "8:44\n",
+ "8:45\n",
+ "8:46\n",
+ "8:47\n",
+ "8:48\n",
+ "8:49\n",
+ "8:50\n",
+ "8:51\n",
+ "8:52\n",
+ "8:53\n",
+ "8:54\n",
+ "8:55\n",
+ "8:56\n",
+ "8:57\n",
+ "8:58\n",
+ "8:59\n",
+ "9:0\n",
+ "9:1\n",
+ "9:2\n",
+ "9:3\n",
+ "9:4\n",
+ "9:5\n",
+ "9:6\n",
+ "9:7\n",
+ "9:8\n",
+ "9:9\n",
+ "9:10\n",
+ "9:11\n",
+ "9:12\n",
+ "9:13\n",
+ "9:14\n",
+ "9:15\n",
+ "9:16\n",
+ "9:17\n",
+ "9:18\n",
+ "9:19\n",
+ "9:20\n",
+ "9:21\n",
+ "9:22\n",
+ "9:23\n",
+ "9:24\n",
+ "9:25\n",
+ "9:26\n",
+ "9:27\n",
+ "9:28\n",
+ "9:29\n",
+ "9:30\n",
+ "9:31\n",
+ "9:32\n",
+ "9:33\n",
+ "9:34\n",
+ "9:35\n",
+ "9:36\n",
+ "9:37\n",
+ "9:38\n",
+ "9:39\n",
+ "9:40\n",
+ "9:41\n",
+ "9:42\n",
+ "9:43\n",
+ "9:44\n",
+ "9:45\n",
+ "9:46\n",
+ "9:47\n",
+ "9:48\n",
+ "9:49\n",
+ "9:50\n",
+ "9:51\n",
+ "9:52\n",
+ "9:53\n",
+ "9:54\n",
+ "9:55\n",
+ "9:56\n",
+ "9:57\n",
+ "9:58\n",
+ "9:59\n",
+ "10:0\n",
+ "10:1\n",
+ "10:2\n",
+ "10:3\n",
+ "10:4\n",
+ "10:5\n",
+ "10:6\n",
+ "10:7\n",
+ "10:8\n",
+ "10:9\n",
+ "10:10\n",
+ "10:11\n",
+ "10:12\n",
+ "10:13\n",
+ "10:14\n",
+ "10:15\n",
+ "10:16\n",
+ "10:17\n",
+ "10:18\n",
+ "10:19\n",
+ "10:20\n",
+ "10:21\n",
+ "10:22\n",
+ "10:23\n",
+ "10:24\n",
+ "10:25\n",
+ "10:26\n",
+ "10:27\n",
+ "10:28\n",
+ "10:29\n",
+ "10:30\n",
+ "10:31\n",
+ "10:32\n",
+ "10:33\n",
+ "10:34\n",
+ "10:35\n",
+ "10:36\n",
+ "10:37\n",
+ "10:38\n",
+ "10:39\n",
+ "10:40\n",
+ "10:41\n",
+ "10:42\n",
+ "10:43\n",
+ "10:44\n",
+ "10:45\n",
+ "10:46\n",
+ "10:47\n",
+ "10:48\n",
+ "10:49\n",
+ "10:50\n",
+ "10:51\n",
+ "10:52\n",
+ "10:53\n",
+ "10:54\n",
+ "10:55\n",
+ "10:56\n",
+ "10:57\n",
+ "10:58\n",
+ "10:59\n",
+ "11:0\n",
+ "11:1\n",
+ "11:2\n",
+ "11:3\n",
+ "11:4\n",
+ "11:5\n",
+ "11:6\n",
+ "11:7\n",
+ "11:8\n",
+ "11:9\n",
+ "11:10\n",
+ "11:11\n",
+ "11:12\n",
+ "11:13\n",
+ "11:14\n",
+ "11:15\n",
+ "11:16\n",
+ "11:17\n",
+ "11:18\n",
+ "11:19\n",
+ "11:20\n",
+ "11:21\n",
+ "11:22\n",
+ "11:23\n",
+ "11:24\n",
+ "11:25\n",
+ "11:26\n",
+ "11:27\n",
+ "11:28\n",
+ "11:29\n",
+ "11:30\n",
+ "11:31\n",
+ "11:32\n",
+ "11:33\n",
+ "11:34\n",
+ "11:35\n",
+ "11:36\n",
+ "11:37\n",
+ "11:38\n",
+ "11:39\n",
+ "11:40\n",
+ "11:41\n",
+ "11:42\n",
+ "11:43\n",
+ "11:44\n",
+ "11:45\n",
+ "11:46\n",
+ "11:47\n",
+ "11:48\n",
+ "11:49\n",
+ "11:50\n",
+ "11:51\n",
+ "11:52\n",
+ "11:53\n",
+ "11:54\n",
+ "11:55\n",
+ "11:56\n",
+ "11:57\n",
+ "11:58\n",
+ "11:59\n",
+ "12:0\n",
+ "12:1\n",
+ "12:2\n",
+ "12:3\n",
+ "12:4\n",
+ "12:5\n",
+ "12:6\n",
+ "12:7\n",
+ "12:8\n",
+ "12:9\n",
+ "12:10\n",
+ "12:11\n",
+ "12:12\n",
+ "12:13\n",
+ "12:14\n",
+ "12:15\n",
+ "12:16\n",
+ "12:17\n",
+ "12:18\n",
+ "12:19\n",
+ "12:20\n",
+ "12:21\n",
+ "12:22\n",
+ "12:23\n",
+ "12:24\n",
+ "12:25\n",
+ "12:26\n",
+ "12:27\n",
+ "12:28\n",
+ "12:29\n",
+ "12:30\n",
+ "12:31\n",
+ "12:32\n",
+ "12:33\n",
+ "12:34\n",
+ "12:35\n",
+ "12:36\n",
+ "12:37\n",
+ "12:38\n",
+ "12:39\n",
+ "12:40\n",
+ "12:41\n",
+ "12:42\n",
+ "12:43\n",
+ "12:44\n",
+ "12:45\n",
+ "12:46\n",
+ "12:47\n",
+ "12:48\n",
+ "12:49\n",
+ "12:50\n",
+ "12:51\n",
+ "12:52\n",
+ "12:53\n",
+ "12:54\n",
+ "12:55\n",
+ "12:56\n",
+ "12:57\n",
+ "12:58\n",
+ "12:59\n",
+ "13:0\n",
+ "13:1\n",
+ "13:2\n",
+ "13:3\n",
+ "13:4\n",
+ "13:5\n",
+ "13:6\n",
+ "13:7\n",
+ "13:8\n",
+ "13:9\n",
+ "13:10\n",
+ "13:11\n",
+ "13:12\n",
+ "13:13\n",
+ "13:14\n",
+ "13:15\n",
+ "13:16\n",
+ "13:17\n",
+ "13:18\n",
+ "13:19\n",
+ "13:20\n",
+ "13:21\n",
+ "13:22\n",
+ "13:23\n",
+ "13:24\n",
+ "13:25\n",
+ "13:26\n",
+ "13:27\n",
+ "13:28\n",
+ "13:29\n",
+ "13:30\n",
+ "13:31\n",
+ "13:32\n",
+ "13:33\n",
+ "13:34\n",
+ "13:35\n",
+ "13:36\n",
+ "13:37\n",
+ "13:38\n",
+ "13:39\n",
+ "13:40\n",
+ "13:41\n",
+ "13:42\n",
+ "13:43\n",
+ "13:44\n",
+ "13:45\n",
+ "13:46\n",
+ "13:47\n",
+ "13:48\n",
+ "13:49\n",
+ "13:50\n",
+ "13:51\n",
+ "13:52\n",
+ "13:53\n",
+ "13:54\n",
+ "13:55\n",
+ "13:56\n",
+ "13:57\n",
+ "13:58\n",
+ "13:59\n",
+ "14:0\n",
+ "14:1\n",
+ "14:2\n",
+ "14:3\n",
+ "14:4\n",
+ "14:5\n",
+ "14:6\n",
+ "14:7\n",
+ "14:8\n",
+ "14:9\n",
+ "14:10\n",
+ "14:11\n",
+ "14:12\n",
+ "14:13\n",
+ "14:14\n",
+ "14:15\n",
+ "14:16\n",
+ "14:17\n",
+ "14:18\n",
+ "14:19\n",
+ "14:20\n",
+ "14:21\n",
+ "14:22\n",
+ "14:23\n",
+ "14:24\n",
+ "14:25\n",
+ "14:26\n",
+ "14:27\n",
+ "14:28\n",
+ "14:29\n",
+ "14:30\n",
+ "14:31\n",
+ "14:32\n",
+ "14:33\n",
+ "14:34\n",
+ "14:35\n",
+ "14:36\n",
+ "14:37\n",
+ "14:38\n",
+ "14:39\n",
+ "14:40\n",
+ "14:41\n",
+ "14:42\n",
+ "14:43\n",
+ "14:44\n",
+ "14:45\n",
+ "14:46\n",
+ "14:47\n",
+ "14:48\n",
+ "14:49\n",
+ "14:50\n",
+ "14:51\n",
+ "14:52\n",
+ "14:53\n",
+ "14:54\n",
+ "14:55\n",
+ "14:56\n",
+ "14:57\n",
+ "14:58\n",
+ "14:59\n",
+ "15:0\n",
+ "15:1\n",
+ "15:2\n",
+ "15:3\n",
+ "15:4\n",
+ "15:5\n",
+ "15:6\n",
+ "15:7\n",
+ "15:8\n",
+ "15:9\n",
+ "15:10\n",
+ "15:11\n",
+ "15:12\n",
+ "15:13\n",
+ "15:14\n",
+ "15:15\n",
+ "15:16\n",
+ "15:17\n",
+ "15:18\n",
+ "15:19\n",
+ "15:20\n",
+ "15:21\n",
+ "15:22\n",
+ "15:23\n",
+ "15:24\n",
+ "15:25\n",
+ "15:26\n",
+ "15:27\n",
+ "15:28\n",
+ "15:29\n",
+ "15:30\n",
+ "15:31\n",
+ "15:32\n",
+ "15:33\n",
+ "15:34\n",
+ "15:35\n",
+ "15:36\n",
+ "15:37\n",
+ "15:38\n",
+ "15:39\n",
+ "15:40\n",
+ "15:41\n",
+ "15:42\n",
+ "15:43\n",
+ "15:44\n",
+ "15:45\n",
+ "15:46\n",
+ "15:47\n",
+ "15:48\n",
+ "15:49\n",
+ "15:50\n",
+ "15:51\n",
+ "15:52\n",
+ "15:53\n",
+ "15:54\n",
+ "15:55\n",
+ "15:56\n",
+ "15:57\n",
+ "15:58\n",
+ "15:59\n",
+ "16:0\n",
+ "16:1\n",
+ "16:2\n",
+ "16:3\n",
+ "16:4\n",
+ "16:5\n",
+ "16:6\n",
+ "16:7\n",
+ "16:8\n",
+ "16:9\n",
+ "16:10\n",
+ "16:11\n",
+ "16:12\n",
+ "16:13\n",
+ "16:14\n",
+ "16:15\n",
+ "16:16\n",
+ "16:17\n",
+ "16:18\n",
+ "16:19\n",
+ "16:20\n",
+ "16:21\n",
+ "16:22\n",
+ "16:23\n",
+ "16:24\n",
+ "16:25\n",
+ "16:26\n",
+ "16:27\n",
+ "16:28\n",
+ "16:29\n",
+ "16:30\n",
+ "16:31\n",
+ "16:32\n",
+ "16:33\n",
+ "16:34\n",
+ "16:35\n",
+ "16:36\n",
+ "16:37\n",
+ "16:38\n",
+ "16:39\n",
+ "16:40\n",
+ "16:41\n",
+ "16:42\n",
+ "16:43\n",
+ "16:44\n",
+ "16:45\n",
+ "16:46\n",
+ "16:47\n",
+ "16:48\n",
+ "16:49\n",
+ "16:50\n",
+ "16:51\n",
+ "16:52\n",
+ "16:53\n",
+ "16:54\n",
+ "16:55\n",
+ "16:56\n",
+ "16:57\n",
+ "16:58\n",
+ "16:59\n",
+ "17:0\n",
+ "17:1\n",
+ "17:2\n",
+ "17:3\n",
+ "17:4\n",
+ "17:5\n",
+ "17:6\n",
+ "17:7\n",
+ "17:8\n",
+ "17:9\n",
+ "17:10\n",
+ "17:11\n",
+ "17:12\n",
+ "17:13\n",
+ "17:14\n",
+ "17:15\n",
+ "17:16\n",
+ "17:17\n",
+ "17:18\n",
+ "17:19\n",
+ "17:20\n",
+ "17:21\n",
+ "17:22\n",
+ "17:23\n",
+ "17:24\n",
+ "17:25\n",
+ "17:26\n",
+ "17:27\n",
+ "17:28\n",
+ "17:29\n",
+ "17:30\n",
+ "17:31\n",
+ "17:32\n",
+ "17:33\n",
+ "17:34\n",
+ "17:35\n",
+ "17:36\n",
+ "17:37\n",
+ "17:38\n",
+ "17:39\n",
+ "17:40\n",
+ "17:41\n",
+ "17:42\n",
+ "17:43\n",
+ "17:44\n",
+ "17:45\n",
+ "17:46\n",
+ "17:47\n",
+ "17:48\n",
+ "17:49\n",
+ "17:50\n",
+ "17:51\n",
+ "17:52\n",
+ "17:53\n",
+ "17:54\n",
+ "17:55\n",
+ "17:56\n",
+ "17:57\n",
+ "17:58\n",
+ "17:59\n",
+ "18:0\n",
+ "18:1\n",
+ "18:2\n",
+ "18:3\n",
+ "18:4\n",
+ "18:5\n",
+ "18:6\n",
+ "18:7\n",
+ "18:8\n",
+ "18:9\n",
+ "18:10\n",
+ "18:11\n",
+ "18:12\n",
+ "18:13\n",
+ "18:14\n",
+ "18:15\n",
+ "18:16\n",
+ "18:17\n",
+ "18:18\n",
+ "18:19\n",
+ "18:20\n",
+ "18:21\n",
+ "18:22\n",
+ "18:23\n",
+ "18:24\n",
+ "18:25\n",
+ "18:26\n",
+ "18:27\n",
+ "18:28\n",
+ "18:29\n",
+ "18:30\n",
+ "18:31\n",
+ "18:32\n",
+ "18:33\n",
+ "18:34\n",
+ "18:35\n",
+ "18:36\n",
+ "18:37\n",
+ "18:38\n",
+ "18:39\n",
+ "18:40\n",
+ "18:41\n",
+ "18:42\n",
+ "18:43\n",
+ "18:44\n",
+ "18:45\n",
+ "18:46\n",
+ "18:47\n",
+ "18:48\n",
+ "18:49\n",
+ "18:50\n",
+ "18:51\n",
+ "18:52\n",
+ "18:53\n",
+ "18:54\n",
+ "18:55\n",
+ "18:56\n",
+ "18:57\n",
+ "18:58\n",
+ "18:59\n",
+ "19:0\n",
+ "19:1\n",
+ "19:2\n",
+ "19:3\n",
+ "19:4\n",
+ "19:5\n",
+ "19:6\n",
+ "19:7\n",
+ "19:8\n",
+ "19:9\n",
+ "19:10\n",
+ "19:11\n",
+ "19:12\n",
+ "19:13\n",
+ "19:14\n",
+ "19:15\n",
+ "19:16\n",
+ "19:17\n",
+ "19:18\n",
+ "19:19\n",
+ "19:20\n",
+ "19:21\n",
+ "19:22\n",
+ "19:23\n",
+ "19:24\n",
+ "19:25\n",
+ "19:26\n",
+ "19:27\n",
+ "19:28\n",
+ "19:29\n",
+ "19:30\n",
+ "19:31\n",
+ "19:32\n",
+ "19:33\n",
+ "19:34\n",
+ "19:35\n",
+ "19:36\n",
+ "19:37\n",
+ "19:38\n",
+ "19:39\n",
+ "19:40\n",
+ "19:41\n",
+ "19:42\n",
+ "19:43\n",
+ "19:44\n",
+ "19:45\n",
+ "19:46\n",
+ "19:47\n",
+ "19:48\n",
+ "19:49\n",
+ "19:50\n",
+ "19:51\n",
+ "19:52\n",
+ "19:53\n",
+ "19:54\n",
+ "19:55\n",
+ "19:56\n",
+ "19:57\n",
+ "19:58\n",
+ "19:59\n",
+ "20:0\n",
+ "20:1\n",
+ "20:2\n",
+ "20:3\n",
+ "20:4\n",
+ "20:5\n",
+ "20:6\n",
+ "20:7\n",
+ "20:8\n",
+ "20:9\n",
+ "20:10\n",
+ "20:11\n",
+ "20:12\n",
+ "20:13\n",
+ "20:14\n",
+ "20:15\n",
+ "20:16\n",
+ "20:17\n",
+ "20:18\n",
+ "20:19\n",
+ "20:20\n",
+ "20:21\n",
+ "20:22\n",
+ "20:23\n",
+ "20:24\n",
+ "20:25\n",
+ "20:26\n",
+ "20:27\n",
+ "20:28\n",
+ "20:29\n",
+ "20:30\n",
+ "20:31\n",
+ "20:32\n",
+ "20:33\n",
+ "20:34\n",
+ "20:35\n",
+ "20:36\n",
+ "20:37\n",
+ "20:38\n",
+ "20:39\n",
+ "20:40\n",
+ "20:41\n",
+ "20:42\n",
+ "20:43\n",
+ "20:44\n",
+ "20:45\n",
+ "20:46\n",
+ "20:47\n",
+ "20:48\n",
+ "20:49\n",
+ "20:50\n",
+ "20:51\n",
+ "20:52\n",
+ "20:53\n",
+ "20:54\n",
+ "20:55\n",
+ "20:56\n",
+ "20:57\n",
+ "20:58\n",
+ "20:59\n",
+ "21:0\n",
+ "21:1\n",
+ "21:2\n",
+ "21:3\n",
+ "21:4\n",
+ "21:5\n",
+ "21:6\n",
+ "21:7\n",
+ "21:8\n",
+ "21:9\n",
+ "21:10\n",
+ "21:11\n",
+ "21:12\n",
+ "21:13\n",
+ "21:14\n",
+ "21:15\n",
+ "21:16\n",
+ "21:17\n",
+ "21:18\n",
+ "21:19\n",
+ "21:20\n",
+ "21:21\n",
+ "21:22\n",
+ "21:23\n",
+ "21:24\n",
+ "21:25\n",
+ "21:26\n",
+ "21:27\n",
+ "21:28\n",
+ "21:29\n",
+ "21:30\n",
+ "21:31\n",
+ "21:32\n",
+ "21:33\n",
+ "21:34\n",
+ "21:35\n",
+ "21:36\n",
+ "21:37\n",
+ "21:38\n",
+ "21:39\n",
+ "21:40\n",
+ "21:41\n",
+ "21:42\n",
+ "21:43\n",
+ "21:44\n",
+ "21:45\n",
+ "21:46\n",
+ "21:47\n",
+ "21:48\n",
+ "21:49\n",
+ "21:50\n",
+ "21:51\n",
+ "21:52\n",
+ "21:53\n",
+ "21:54\n",
+ "21:55\n",
+ "21:56\n",
+ "21:57\n",
+ "21:58\n",
+ "21:59\n",
+ "22:0\n",
+ "22:1\n",
+ "22:2\n",
+ "22:3\n",
+ "22:4\n",
+ "22:5\n",
+ "22:6\n",
+ "22:7\n",
+ "22:8\n",
+ "22:9\n",
+ "22:10\n",
+ "22:11\n",
+ "22:12\n",
+ "22:13\n",
+ "22:14\n",
+ "22:15\n",
+ "22:16\n",
+ "22:17\n",
+ "22:18\n",
+ "22:19\n",
+ "22:20\n",
+ "22:21\n",
+ "22:22\n",
+ "22:23\n",
+ "22:24\n",
+ "22:25\n",
+ "22:26\n",
+ "22:27\n",
+ "22:28\n",
+ "22:29\n",
+ "22:30\n",
+ "22:31\n",
+ "22:32\n",
+ "22:33\n",
+ "22:34\n",
+ "22:35\n",
+ "22:36\n",
+ "22:37\n",
+ "22:38\n",
+ "22:39\n",
+ "22:40\n",
+ "22:41\n",
+ "22:42\n",
+ "22:43\n",
+ "22:44\n",
+ "22:45\n",
+ "22:46\n",
+ "22:47\n",
+ "22:48\n",
+ "22:49\n",
+ "22:50\n",
+ "22:51\n",
+ "22:52\n",
+ "22:53\n",
+ "22:54\n",
+ "22:55\n",
+ "22:56\n",
+ "22:57\n",
+ "22:58\n",
+ "22:59\n",
+ "23:0\n",
+ "23:1\n",
+ "23:2\n",
+ "23:3\n",
+ "23:4\n",
+ "23:5\n",
+ "23:6\n",
+ "23:7\n",
+ "23:8\n",
+ "23:9\n",
+ "23:10\n",
+ "23:11\n",
+ "23:12\n",
+ "23:13\n",
+ "23:14\n",
+ "23:15\n",
+ "23:16\n",
+ "23:17\n",
+ "23:18\n",
+ "23:19\n",
+ "23:20\n",
+ "23:21\n",
+ "23:22\n",
+ "23:23\n",
+ "23:24\n",
+ "23:25\n",
+ "23:26\n",
+ "23:27\n",
+ "23:28\n",
+ "23:29\n",
+ "23:30\n",
+ "23:31\n",
+ "23:32\n",
+ "23:33\n",
+ "23:34\n",
+ "23:35\n",
+ "23:36\n",
+ "23:37\n",
+ "23:38\n",
+ "23:39\n",
+ "23:40\n",
+ "23:41\n",
+ "23:42\n",
+ "23:43\n",
+ "23:44\n",
+ "23:45\n",
+ "23:46\n",
+ "23:47\n",
+ "23:48\n",
+ "23:49\n",
+ "23:50\n",
+ "23:51\n",
+ "23:52\n",
+ "23:53\n",
+ "23:54\n",
+ "23:55\n",
+ "23:56\n",
+ "23:57\n",
+ "23:58\n",
+ "23:59\n",
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "def klokkeslett():\n",
+ " outer_string = \"\"\n",
+ " for hour in range(24):\n",
+ " inner_string = \"\"\n",
+ " for minute in range(60):\n",
+ " inner_string += str(hour) +\":\" + str(minute) + \"\\n\"\n",
+ " outer_string += inner_string\n",
+ " return outer_string \n",
+ "\n",
+ "print(klokkeslett())"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "## c)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Bruk doble løkker til å lage en funksjon som returnerer alle tallene i den lille gangetabellen, dvs. lag to for-løkker opp til 11 og multipliser variabelen x fra den ene løkken med variabelen y fra den andre løkken og bygg det på en indre streng i den innerste løkken. Du trenger ikke å tenke på formatet til utskriften.\n",
+ "\n",
+ "Eksempel på kjøring:\n",
+ "\n",
+ "```python\n",
+ "print(gangetabellen())\n",
+ "1\n",
+ "2\n",
+ "3\n",
+ "4\n",
+ "5\n",
+ ".\n",
+ ".\n",
+ ".\n",
+ "60\n",
+ "70\n",
+ "80\n",
+ "90\n",
+ "100\n",
+ "```\n",
+ "***Skriv koden din her:***"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 29,
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2019-07-02T13:22:00.046861Z",
+ "start_time": "2019-07-02T13:22:00.042947Z"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "1 2 3 4 5 6 7 8 9 10 \n",
+ "2 4 6 8 10 12 14 16 18 20 \n",
+ "3 6 9 12 15 18 21 24 27 30 \n",
+ "4 8 12 16 20 24 28 32 36 40 \n",
+ "5 10 15 20 25 30 35 40 45 50 \n",
+ "6 12 18 24 30 36 42 48 54 60 \n",
+ "7 14 21 28 35 42 49 56 63 70 \n",
+ "8 16 24 32 40 48 56 64 72 80 \n",
+ "9 18 27 36 45 54 63 72 81 90 \n",
+ "10 20 30 40 50 60 70 80 90 100 \n",
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "def gangetabellen(x, y):\n",
+ " outer_string = \"\"\n",
+ " for i in range(1,x):\n",
+ " inner_string = \"\"\n",
+ " for j in range(1,y):\n",
+ " inner_string += str(i*j)+ \" \"\n",
+ " outer_string += inner_string + \"\\n\" \n",
+ " return outer_string\n",
+ "\n",
+ "\n",
+ "print(gangetabellen(11,11))\n",
+ " "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "**Bonus**: Forsøk å legg inn \"\\n\" etter den innerste løkken i c) har kjørt (dvs. på samme innrykk som innerste for, men nedenfor linjen hvor inner_string blir utvidet med tall. Legg også til et mellomrom etter str(i*j)' ' på slutten av print-funksjonen som printer ut tallene. Ser du nå at det ligner mer på en gangetabell?"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ }
+ ],
+ "metadata": {
+ "celltoolbar": "Edit Metadata",
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.7.4"
+ },
+ "toc": {
+ "base_numbering": 1,
+ "nav_menu": {},
+ "number_sections": false,
+ "sideBar": true,
+ "skip_h1_title": false,
+ "title_cell": "Table of Contents",
+ "title_sidebar": "Contents",
+ "toc_cell": false,
+ "toc_position": {},
+ "toc_section_display": true,
+ "toc_window_display": false
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/Ovinger/Oving3/Tekstbasert spill 2.ipynb b/Ovinger/Oving3/Tekstbasert spill 2.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..5089c6e16673d85e8beee3a641ba7f003bbec523
--- /dev/null
+++ b/Ovinger/Oving3/Tekstbasert spill 2.ipynb
@@ -0,0 +1,217 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "<nav class=\"navbar navbar-default\">\n",
+ " <div class=\"container-fluid\">\n",
+ " <div class=\"navbar-header\">\n",
+ " <a class=\"navbar-brand\" href=\"_Oving3.ipynb\">Øving 3</a>\n",
+ " </div>\n",
+ " <ul class=\"nav navbar-nav\">\n",
+ " <li ><a href=\"Intro%20til%20lokker.ipynb\">Intro til løkker</a></li>\n",
+ " <li ><a href=\"Mer%20om%20lokker.ipynb\">Mer om løkker</a></li>\n",
+ " <li><a href=\"Nostede%20lokker.ipynb\">Intro til nøstede løkker</a></li>\n",
+ " <li ><a href=\"Kodeforstaelse.ipynb\">Kodeforståelse</a></li>\n",
+ " <li class=\"active\"><a href=\"Gjett%20tallet.ipynb\">Gjett tallet</a></li>\n",
+ " <li ><a href=\"Tekstbasert%20spill%202.ipynb\">Tekstbasert spill 2</a></li>\n",
+ " <li ><a href=\"Geometrisk%20rekke.ipynb\">Geometrisk rekke</a></li>\n",
+ " <li ><a href=\"Fibonacci.ipynb\">Fibonacci</a></li>\n",
+ " <li><a href=\"Alternerende%20sum.ipynb\">Alternerende sum</a></li>\n",
+ " <li ><a href=\"Hangman.ipynb\">Hangman</a></li>\n",
+ " <li ><a href=\"Derivasjon.ipynb\">Derivasjon</a></li>\n",
+ " <li ><a href=\"Doble%20lokker.ipynb\">Doble løkker</a></li>\n",
+ " </ul>\n",
+ " </div>\n",
+ "</nav>\n",
+ "\n",
+ "\n",
+ "# Tekstbasert spill 2\n",
+ "\n",
+ "**Læringsmål:**\n",
+ "\n",
+ "* Løkker\n",
+ "* Betingelser\n",
+ "\n",
+ "I denne oppgaven skal vi utvide spillet vi begynte på i øving 2. Du må ikke ha gjort oppgaven i øving for å gjøre denne, men det kan være lurt å ta en kikk [her](link) for å forstå hva oppgaven går ut på. "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "### a)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Ved hjelp av en while løkke, la brukeren skrive inn kommando, og gjenta tilstanden dersom brukeren gir inn en ugyldig kommando. Se forrige oppgave for oppførsel ellers. \n",
+ "\n",
+ "Eksempel:\n",
+ "```python\n",
+ "Du står utenfor en dør.\n",
+ ">sadasd\n",
+ "Forstår ikke kommando, prøv noe annet.\n",
+ "Du står utenfor en dør.\n",
+ ">GÃ¥ inn\n",
+ "Du går inn døren.\n",
+ "```\n",
+ "\n",
+ "***Skriv koden din i blokka under***"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### b)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Ved hjelp av løkker ønsker vi nå at visse kommandoer skal ta brukeren tilbake til utgangspunktet i spillet. Dersom en bruker skriver inn en kommando som ikke skal ta brukeren ut av spillet (eller en ugyldig kommando), ønsker vi at den opprinnelige meldingen brukeren får skal gjentas, ellers går spilleren ut av løkken. **Altså, for alle andre kommandoer enn en spesifikk skal løkka gjentas.** I eksempelet under gjentas tilstanden helt til brukeren skriver noe som endrer den.\n",
+ "\n",
+ "Eksempel:\n",
+ "```python\n",
+ "Du står utenfor en dør med en postkasse.\n",
+ ">bank på\n",
+ "Du får ingen respons.\n",
+ "Du står utenfor en dør med en postkasse. #opprinnelig tilstand\n",
+ ">gå andre veien\n",
+ "Du snur deg og vandrer hjem igjen. Du hører en skummel lyd og løper tilbake. \n",
+ "Du står utenfor en dør med en postkasse. #opprinnelig tilstand\n",
+ ">åpne døren \n",
+ "Du går inn døren. #går ut av løkken\n",
+ "```\n",
+ "\n",
+ "***Skriv koden din i blokka under***"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### c)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Ved hjelp av løkker og variabler skal du nå la visse kommandoer brukeren skriver inn endre tilstanden i spillet (altså variablene) **selv om vi ikke går ut av løkka**. Ved å sjekke tilstanden til disse variablene skal en kommando kunne gjøre to ting, utifra hva tilstanden til en variabel er satt til.\n",
+ "\n",
+ "Eksempel:\n",
+ "```python\n",
+ "Du står utenfor en dør med en postkasse.\n",
+ ">åpne døren\n",
+ "Døren er låst.\n",
+ "\n",
+ "Du står utenfor en dør med en postkasse.\n",
+ ">Ã¥pne postkassen\n",
+ "Du finner en nøkkel. #her må man oppdatere en variabel\n",
+ "\n",
+ "Du står utenfor en dør med en postkasse. #vi printer ut det samme \n",
+ ">åpne døren \n",
+ "Du låser opp døren og går inn. #her er tilstanden annerledes enn når vi startet og vi går ut av løkka\n",
+ "```\n",
+ "\n",
+ "***Skriv koden din i blokka under***"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### d)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Legg til muligheten for brukeren til å gå ut av spillet uansett tilstand vet å kun trykke enter uten å skrive inn noe. Legg inn en avslutningsmelding.\n",
+ "\n",
+ "Eksempel:\n",
+ "```python\n",
+ "Du står utenfor en dør med en postkasse.\n",
+ ">\n",
+ "Ha en fin dag!\n",
+ "```\n",
+ "\n",
+ "***Skriv koden din i samme blokk som oppgave c***"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "heading_collapsed": true
+ },
+ "source": [
+ "#### Hint"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "hidden": true
+ },
+ "source": [
+ "Du kan bruke break for å hoppe ut av en løkke."
+ ]
+ }
+ ],
+ "metadata": {
+ "celltoolbar": "Edit Metadata",
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.7.4"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/Ovinger/Oving3/_Oving3.ipynb b/Ovinger/Oving3/_Oving3.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..b69129984a05aae8ab45f90f7e2286472df77d3b
--- /dev/null
+++ b/Ovinger/Oving3/_Oving3.ipynb
@@ -0,0 +1,89 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "# Øving 3\n",
+ "\n",
+ "**Læringsmål:**\n",
+ "\n",
+ "* Løkker\n",
+ "* Betingelser\n",
+ "* Strenger\n",
+ " \n",
+ "\n",
+ "## Godkjenning:\n",
+ "\n",
+ "For å få godkjent øvingen må du gjøre ***4*** av ***11*** oppgaver. ***1*** av de ***4*** må være en oppgave merket med stjerne.\n",
+ "\n",
+ "Oppgaver som er litt ekstra vanskelig er markert med stjerne. Oppgaver som går forbi det som er blitt forelest er markert med to stjerner.\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",
+ "[Introduksjon til løkker](Intro%20til%20lokker.ipynb) |Løkker | \n",
+ "[Mer om løkker](Mer%20om%20lokker.ipynb)|Løkker|\n",
+ "[Intro til nøstede løkker](Nostede%20lokker.ipynb)|Nøstede løkker|\n",
+ "[Kodeforståelse](Kodeforstaelse.ipynb)|Kodeforståelse|\n",
+ "[Gjett tallet](Gjett%20tallet.ipynb)|Løkker og betingelse|\n",
+ "[Tekstbasert Spill 2](Tekstbasert%20spill%202.ipynb)|Løkker og betingelse|\n",
+ "[Geometrisk rekke](Geometrisk%20rekke.ipynb)|Løkker og betingelse|\n",
+ "[Fibonacci](Fibonacci.ipynb)|Løkker|\n",
+ "[Alternerende sum](Alternerende%20sum.ipynb)|Løkker|\n",
+ "[Hangman](Hangman.ipynb)|Løkker|\n",
+ "[Doble løkker](Doble%20lokker.ipynb)|Nøstede Løkker| \n",
+ "[Derivasjon](Derivasjon.ipynb)| Løkker |\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ }
+ ],
+ "metadata": {
+ "celltoolbar": "Edit Metadata",
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.7.4"
+ },
+ "toc": {
+ "base_numbering": 1,
+ "nav_menu": {},
+ "number_sections": false,
+ "sideBar": true,
+ "skip_h1_title": false,
+ "title_cell": "Table of Contents",
+ "title_sidebar": "Contents",
+ "toc_cell": false,
+ "toc_position": {},
+ "toc_section_display": true,
+ "toc_window_display": false
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}