diff --git a/.DS_Store b/.DS_Store
new file mode 100644
index 0000000000000000000000000000000000000000..bc52dbcd6a7eb91d61ab8068afa9bc43f44c57ad
Binary files /dev/null and b/.DS_Store differ
diff --git a/Oving4/Arbeidsdager.ipynb b/Oving4/Arbeidsdager.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..ed74c86ff7d5e8a20cb9b3c5b9666b670186aba7
--- /dev/null
+++ b/Oving4/Arbeidsdager.ipynb
@@ -0,0 +1,316 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "source": [
+ "<nav class=\"navbar navbar-default\">\n",
+ " <div class=\"container-fluid\">\n",
+ " <div class=\"navbar-header\">\n",
+ " <a class=\"navbar-brand\" href=\"_Oving4.ipynb\">Øving 4</a>\n",
+ " </div>\n",
+ " <ul class=\"nav navbar-nav\">\n",
+ " <li><a href=\"Grunnleggende%20om%20funksjoner.ipynb\">Grunnleggende om funksjoner</a></li>\n",
+ " <li><a href=\"Varierte%20funksjoner.ipynb\">Varierte funksjoner</a></li>\n",
+ " <li><a href=\"Lokale%20variabler.ipynb\">Lokale variabler</a></li>\n",
+ " <li><a href=\"Globale%20variabler.ipynb\">Globale variabler</a></li>\n",
+ " <li><a href=\"Euklids%20algoritme.ipynb\">Euklids algoritme</a></li>\n",
+ " <li><a href=\"Primtall.ipynb\">Primtall</a></li>\n",
+ " <li><a href=\"Multiplikasjon.ipynb\">Multiplikasjon</a></li>\n",
+ " <li><a href=\"Den%20store%20sporreundersokelsen.ipynb\">Den store spørreundersøkelsen</a></li>\n",
+ " <li class=\"active\"><a href=\"Arbeidsdager.ipynb\">Arbeidsdager</a></li>\n",
+ " <li><a href=\"Sekantmetoden.ipynb\">Sekantmetoden</a></li>\n",
+ " <li><a href=\"Not%20quite%20Blackjack.ipynb\">Not quite Blackjack</a></li>\n",
+ " <li><a href=\"Funksjoner%20og%20Jupyter%20widgets.ipynb\">Funksjoner og Jupyter widgets</a></li>\n",
+ " </ul>\n",
+ " </div>\n",
+ "</nav>\n",
+ "\n",
+ "# Arbeidsdager\n",
+ "\n",
+ "**Læringsmål:**\n",
+ "- Funksjoner \n",
+ "- Betingelser\n",
+ "- Løkker\n",
+ "\n",
+ "**Starting Out with Python:**\n",
+ "- Kap. 3.1-3.2\n",
+ "- Kap. 4.3\n",
+ "- Kap. 5.3\n",
+ "- Kap. 5.5\n",
+ "- Kap. 5.8\n"
+ ],
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "Et vanlig år består av 52 hele uker og én dag, til sammen 365 dager. Det vil si at hvis ett år starter på en mandag, starter neste år på en tirsdag. Skuddår har en dag ekstra. Dvs. hvis et skuddår starter på en mandag, starter neste år på en onsdag. 1. januar 1900 var en mandag. Skuddår er litt finurlig definert. Bruk følgende funksjon til å bestemme om et år er et skuddår:"
+ ],
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2019-07-03T10:09:44.703606Z",
+ "start_time": "2019-07-03T10:09:44.686102Z"
+ },
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ }
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "source": [
+ "# Trykk ctrl + enter her så har du denne funksjonen til senere oppgaver\n",
+ "def is_leap_year ( year ):\n",
+ " if year % 400 == 0:\n",
+ " return True\n",
+ " elif year % 100 == 0:\n",
+ " return False\n",
+ " elif year % 4 == 0:\n",
+ " return True\n",
+ " return False"
+ ],
+ "outputs": [],
+ "metadata": {}
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "## a)"
+ ],
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "Lag først en funksjon `weekday_newyear(year)` som tar inn et årstall, og returnerer hvilken ukedag året starter på. Ukedager representeres med heltall, dvs. mandag = 0, tirsdag = 1, ..., søndag = 6. \n",
+ "\n",
+ "*Merk: Deloppgaven skal løses uten å bruke Pythons innebygde datofunksjoner.*\n",
+ "\n",
+ "Skriv deretter ut årstall med tilhørende første ukedag i tekstlig format for år 1900 til og med 1919 ved å benytte funksjonen `weekday_newyear(year)`.\n",
+ "\n",
+ "***Skriv koden i kodeblokken under***"
+ ],
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ }
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "source": [],
+ "outputs": [],
+ "metadata": {}
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "Hvis du har gjort alt riktig skal koden din gi følgende output:\n",
+ "```python\n",
+ "1900 man\n",
+ "1901 tir\n",
+ "1902 ons\n",
+ "1903 tor\n",
+ "1904 fre\n",
+ "1905 son\n",
+ "1906 man\n",
+ "1907 tir\n",
+ "1908 ons\n",
+ "1909 fre\n",
+ "1910 lor\n",
+ "1911 son\n",
+ "1912 man\n",
+ "1913 ons\n",
+ "1914 tor\n",
+ "1915 fre\n",
+ "1916 lor\n",
+ "1917 man\n",
+ "1918 tir\n",
+ "1919 ons\n",
+ "```"
+ ],
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "## b)"
+ ],
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "Lag funksjonen `is_workday(day)` som tar inn en ukedag, og returnerer `True` om ukedagen er arbeidsdag, og `False` ellers. (Alle hverdager er arbeidsdager. Lørdag og søndag er ikke arbeidsdager. For eksempel skal `is_workday(2)` returnere `True`, mens `is_workday(5)` skal returnere `False`.\n",
+ "\n",
+ "***Skriv koden din i kodeblokken under og test at den fungerer***"
+ ],
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ }
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "source": [],
+ "outputs": [],
+ "metadata": {}
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "## c)"
+ ],
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "Lag først funksjonen `workdays_in_year(year)` som tar inn et årstall og skriver ut antall arbeidsdager i det gitte året. (Vi ser bort ifra helligdager som faller på arbeidsdager, dvs. at bl.a. langfredag vil telles som en arbeidsdag.) \n",
+ "\n",
+ "Husk at skuddår har en ekstra dag i februar. \n",
+ "\n",
+ "Skriv deretter ut antall arbeidsdager for årene 1900 til og med 1919.\n",
+ "\n",
+ "***Skriv koden din i kodeblokken under***"
+ ],
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ }
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "source": [],
+ "outputs": [],
+ "metadata": {}
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "**Hint:** Benytt deg av tidligere lagde funksjoner for å slippe å skrive mye kode på nytt."
+ ],
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "Har du gjort alt riktig skal koden din gi følgende output:\n",
+ "\n",
+ "```python\n",
+ "1900 har 261 arbeidsdager\n",
+ "1901 har 261 arbeidsdager\n",
+ "1902 har 261 arbeidsdager\n",
+ "1903 har 261 arbeidsdager\n",
+ "1904 har 261 arbeidsdager\n",
+ "1905 har 260 arbeidsdager\n",
+ "1906 har 261 arbeidsdager\n",
+ "1907 har 261 arbeidsdager\n",
+ "1908 har 262 arbeidsdager\n",
+ "1909 har 261 arbeidsdager\n",
+ "1910 har 260 arbeidsdager\n",
+ "1911 har 260 arbeidsdager\n",
+ "1912 har 262 arbeidsdager\n",
+ "1913 har 261 arbeidsdager\n",
+ "1914 har 261 arbeidsdager\n",
+ "1915 har 261 arbeidsdager\n",
+ "1916 har 260 arbeidsdager\n",
+ "1917 har 261 arbeidsdager\n",
+ "1918 har 261 arbeidsdager\n",
+ "1919 har 261 arbeidsdager\n",
+ "```"
+ ],
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ }
+ }
+ ],
+ "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
+}
\ No newline at end of file
diff --git a/Oving4/Den store sporreundersokelsen.ipynb b/Oving4/Den store sporreundersokelsen.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..b254d948bba3539829a7ea97d06672a1a50e143e
--- /dev/null
+++ b/Oving4/Den store sporreundersokelsen.ipynb
@@ -0,0 +1,228 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "<nav class=\"navbar navbar-default\">\n",
+ " <div class=\"container-fluid\">\n",
+ " <div class=\"navbar-header\">\n",
+ " <a class=\"navbar-brand\" href=\"_Oving5.ipynb\">Øving 5</a>\n",
+ " </div>\n",
+ " <ul class=\"nav navbar-nav\">\n",
+ " <li><a href=\"Grunnleggende%20om%20funksjoner.ipynb\">Grunnleggende om funksjoner</a></li>\n",
+ " <li><a href=\"Varierte%20funksjoner.ipynb\">Varierte funksjoner</a></li>\n",
+ " <li><a href=\"Lokale%20variabler.ipynb\">Lokale variabler</a></li>\n",
+ " <li><a href=\"Globale%20variabler.ipynb\">Globale variabler</a></li>\n",
+ " <li><a href=\"Euklids%20algoritme.ipynb\">Euklids algoritme</a></li>\n",
+ " <li><a href=\"Primtall.ipynb\">Primtall</a></li>\n",
+ " <li><a href=\"Multiplikasjon.ipynb\">Multiplikasjon</a></li>\n",
+ " <li class=\"active\"><a href=\"Den%20store%20sporreundersokelsen.ipynb\">Den store spørreundersøkelsen</a></li>\n",
+ " <li><a href=\"Arbeidsdager.ipynb\">Arbeidsdager</a></li>\n",
+ " <li><a href=\"Sekantmetoden.ipynb\">Sekantmetoden</a></li>\n",
+ " <li><a href=\"Not%20quite%20Blackjack.ipynb\">Not quite Blackjack</a></li>\n",
+ " <li><a href=\"Funksjoner%20og%20Jupyter%20widgets.ipynb\">Funksjoner og Jupyter widgets</a></li>\n",
+ " </ul>\n",
+ " </div>\n",
+ "</nav>\n",
+ "\n",
+ "## Den store spørreundersøkelsen\n",
+ "\n",
+ "**Læringsmål:**\n",
+ "\n",
+ "* Funksjoner \n",
+ "* Betingelser\n",
+ "* Løkker\n",
+ "\n",
+ "**Starting Out with Python:**\n",
+ "\n",
+ "* Kap. 3.1-3.2\n",
+ " * 3.1: The if Statement\n",
+ " * 3.2: The if-else Statement \n",
+ "* Kap. 4.2\n",
+ " * 4.2: The while Loop: A Condition-Controlled Loop\n",
+ "* Kap. 5.4-5.6, 5.8 \n",
+ " * 5.4: Local Variables\n",
+ " * 5.5: Passing Arguments to Functions\n",
+ " * 5.6: Global Variables and Global Constants\n",
+ " * 5.8: Writing Your Own Value-Returning Functions\n",
+ " \n",
+ "\n",
+ "**I denne oppgaven skal du skrive et større program. For denne typen oppgaver kan det være mer praktisk å laste ned python og eventuelt en IDE (Et område man programmerer i på sin egen maskin). Ta derfor en kikk [her](https://docs.google.com/document/d/17tS0maWyzORUsIjmCVEszfqrl2X4By-Cy2Sw3ENG5lA/edit?usp=sharing) før du begynner. Det er fortsatt mulig å gjøre oppgaven i Jupyter dersom du ikke ønsker å jobbe lokalt**\n",
+ " \n",
+ "I denne oppgaven skal du implementere et lite utdrag av en spørreundersøkelse om leksevaner til studenter. Undersøkelsen er beregnet for kvinner og menn i aldersgruppen 16-25 år.\n",
+ "\n",
+ "Spørreundersøkelsen implementeres ved hjelp av å skrive ut spørsmål og lese input fra brukeren i en while-løkke som kjøres så lenge brukeren ønsker å skrive inn data. Når alle spørsmålene er besvart, gjentas spørsmålene for en ny person. \n",
+ "\n",
+ "Hold styr på fem globale tellere (variabler) under kjøringen av while-løkken: **antall_kvinner**, **antall_menn**, **antall_fag**, **antall_ITGK**, og **antall_timer_lekser**. Hvis brukeren til enhver tid svarer hade på et spørsmål skal while-løkken avsluttes og verdiene av de fem tellerne skrives ut.\n",
+ "\n",
+ "I programmet ditt kan du få bruk for:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from sys import exit #Du kan nå bruke funksjonen exit() i programmet ditt. Anbefales brukt i sjekk_svar-funksjonen."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "exit() vil avslutte kjøringen av programmet.\n",
+ "\n",
+ "Bruk funksjoner til å lese inn svar fra brukeren (de bør være forskjellige om brukeren skriver inn et tall eller en streng), og til å skrive ut statistikk til slutt (oppgave g).\n",
+ "\n",
+ "Funksjoner som kan implementeres i løpet av oppgaven er:\n",
+ "\n",
+ "sjekk_svar(spm)\n",
+ "les_streng(spm)\n",
+ "les_ja_nei(spm)\n",
+ "les_tall(spm)\n",
+ "skriv_statistikk()\n",
+ "(Der spm er svaret på de forskjellige spørsmålene som skal stilles i while-løkken)\n",
+ "\n",
+ "Deloppgave a til e skal altså implementeres inni while-løkken."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# du kan skrive all koden din i denne blokken dersom du ikke vil laste ned IDLE/Pycharm"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "**a)** Be brukeren skrive inn kjønn og alder. Med for eksempel ***f*** for kvinne og ***m*** for mann, lagre disse i variablene **kjonn** og **alder**.\n",
+ "\n",
+ "\n",
+ "\n",
+ "**b)** Sjekk om brukeren er innenfor tiltenkt aldersgruppe. Dersom brukeren er utenfor aldersgruppen, skriv en melding om at vedkommende ikke kan ta spørreundersøkelsen, og hopp tilbake til første spørsmål (kjønn).\n",
+ "\n",
+ "\n",
+ "\n",
+ "**c)** Dersom brukeren er innenfor tiltenkt aldersgruppe, spør om brukeren tar et **fag**, med svaralternativene ja og nei. Deretter lagres svaret som en variabel fag. Ta utgangspunkt i denne variabelen når du avgjør om brukeren trenger å svare på de neste to spørsmålene eller ikke. Om noe annet svares, skal spørsmålet gjentas til et gyldig svaralternativ er gitt. \n",
+ "\n",
+ "\n",
+ "\n",
+ "**d)** Du skal nå spørre om brukeren tar ITGK og lagre svaret som en variabel **medlem_ITGK**, men spørsmålsteksten skal variere ut ifra alderen på brukeren\n",
+ "\n",
+ "* Dersom brukeren er under 22 år skal spørsmålsteksten være: Tar du ITGK?\n",
+ "* Ellers skal spørsmålsteksten være: Tar virkelig du ITGK?\n",
+ "\n",
+ "\n",
+ "**e)** Spør brukeren hvor mange timer han/hun bruker i snitt daglig på lekser og lagre svaret i variabelen **timer_lekser**\n",
+ "\n",
+ "\n",
+ "\n",
+ "**f)** Endre programmet ditt slik at de globale tellerne nevnt tidligere i oppgaven blir inkrementert i deloppgavene a til e.\n",
+ "\n",
+ "\n",
+ "\n",
+ "**g)** Kjør programmet ditt, utfør noen undersøkelser, og avslutt ved å skrive hade. Sjekk at statistikken (verdiene av de globale tellerne) som skrives ut på slutten er korrekt.\n",
+ "\n",
+ "**Eksempel på kjøring:**\n",
+ "\n",
+ "```\n",
+ "Velkommen til spørreundersøkelsen!\n",
+ " \n",
+ " Hvilket kjønn er du? [f/m]: f\n",
+ " Hvor gammel er du?: 21\n",
+ " Tar du et eller flere fag? [ja/nei ]: bleh\n",
+ " Tar du et eller flere fag? [ja/nei ]: ja\n",
+ " Tar du ITGK? [ja/nei]: ja\n",
+ " Hvor mange timer bruker du daglig (i snitt) på lekser?: 2\n",
+ " \n",
+ "Velkommen til spørreundersøkelsen!\n",
+ " \n",
+ " Hvilket kjønn er du? [f/m]: m\n",
+ " Hvor gammel er du?: 28\n",
+ "Du kan dessverre ikke ta denne undersøkelsen\n",
+ " \n",
+ "Velkommen til spørreundersøkelsen!\n",
+ " \n",
+ " Hvilket kjønn er du? [f/m]: m\n",
+ " Hvor gammel er du?: 25\n",
+ " Tar du et eller flere fag? [ja/nei ]: ja\n",
+ " Tar du virkelig ITGK?: nei\n",
+ " Hvor mange timer bruker du daglig (i snitt) på lekser?: 3\n",
+ " \n",
+ "Velkommen til spørreundersøkelsen!\n",
+ " \n",
+ " Hvilket kjønn er du? [f/m]: f\n",
+ " Hvor gammel er du?: 18\n",
+ " Tar du et eller flere fag? [ja/nei ]: nei\n",
+ " \n",
+ "Velkommen til spørreundersøkelsen!\n",
+ " \n",
+ " Hvilket kjønn er du? [f/m]: m\n",
+ " Hvor gammel er du?: 24\n",
+ " Tar du et eller flere fag? [ja/nei ]: hade\n",
+ " \n",
+ "Resultat av undersøkelse!\n",
+ " Antall kvinner: 2\n",
+ " Antall menn: 2\n",
+ " Antall personer som tar fag: 2\n",
+ " Antall personer som tar ITGK: 1\n",
+ " Antall timer i snitt brukt på lekser : 2.5\n",
+ " ```\n",
+ " \n",
+ "**h)** Vil det være mulig å hente ut svarene fra spørreundersøkelsen etter at vi har avsluttet programmet? Hvor er de i så fall lagret? Eventuelt hvorfor ikke?"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Svar: < dobbelklikk her>"
+ ]
+ }
+ ],
+ "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/Oving4/Euklids algoritme.ipynb b/Oving4/Euklids algoritme.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..73cf35e2e01900474c8fce7f6b46915730bf4394
--- /dev/null
+++ b/Oving4/Euklids algoritme.ipynb
@@ -0,0 +1,248 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "source": [
+ "<nav class=\"navbar navbar-default\">\n",
+ " <div class=\"container-fluid\">\n",
+ " <div class=\"navbar-header\">\n",
+ " <a class=\"navbar-brand\" href=\"_Oving4.ipynb\">Øving 4</a>\n",
+ " </div>\n",
+ " <ul class=\"nav navbar-nav\">\n",
+ " <li><a href=\"Grunnleggende%20om%20funksjoner.ipynb\">Grunnleggende om funksjoner</a></li>\n",
+ " <li><a href=\"Varierte%20funksjoner.ipynb\">Varierte funksjoner</a></li>\n",
+ " <li><a href=\"Lokale%20variabler.ipynb\">Lokale variabler</a></li>\n",
+ " <li><a href=\"Globale%20variabler.ipynb\">Globale variabler</a></li>\n",
+ " <li class=\"active\"><a href=\"Euklids%20algoritme.ipynb\">Euklids algoritme</a></li>\n",
+ " <li><a href=\"Primtall.ipynb\">Primtall</a></li>\n",
+ " <li><a href=\"Multiplikasjon.ipynb\">Multiplikasjon</a></li>\n",
+ " <li><a href=\"Den%20store%20sporreundersokelsen.ipynb\">Den store spørreundersøkelsen</a></li>\n",
+ " <li><a href=\"Arbeidsdager.ipynb\">Arbeidsdager</a></li>\n",
+ " <li><a href=\"Sekantmetoden.ipynb\">Sekantmetoden</a></li>\n",
+ " <li><a href=\"Not%20quite%20Blackjack.ipynb\">Not quite Blackjack</a></li>\n",
+ " <li><a href=\"Funksjoner%20og%20Jupyter%20widgets.ipynb\">Funksjoner og Jupyter widgets</a></li>\n",
+ " </ul>\n",
+ " </div>\n",
+ "</nav>\n",
+ "\n",
+ "# Euklids algoritme\n",
+ "\n",
+ "**Læringsmål:**\n",
+ "- Funksjoner\n",
+ "- Algoritmer\n",
+ "- Løkker\n",
+ "\n",
+ "**Starting Out with Python:**\n",
+ "- Kap. 5.2-5.5\n",
+ "\n",
+ "Et vanlig problem i matematikken er å finne den største felles divisoren av to tall. I denne oppgaven skal du lage en funksjon som finner dette tallet, og så bruke funksjonen til å forkorte brøker. \n",
+ "\n",
+ "Eksempelvis vil det største tallet som deler både 20 og 30 være 10, brøken 20/30 kan derfor forkortes til 2/3 ved å dele på 10 i både teller og nevner. \n",
+ "\n",
+ "Dette problemet kan løses ved hjelp av Euklids algoritme. Pseudokode for Euklids algoritme er som følger: \n",
+ "\n",
+ "```\n",
+ "Gitt inputparametere a og b, begge heltall.\n",
+ "Gjenta så lenge b ikke er 0:\n",
+ " Tilegn den nåværende verdien av b til en ny variabel gammel_b.\n",
+ " Tilegn til b resten etter a dividert på b.\n",
+ " Tilegn til a verdien av gammel_b.\n",
+ "Returner a som resultat av algoritmen\n",
+ "```"
+ ],
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "## a)"
+ ],
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "Lag en funksjon `gcd` (Greatest Common Divisor) som tar inn to tall, utfører Euklids algoritme, og returnerer den største felles divisoren. For eksempel skal `gcd(30,10)` returnere svaret `10`\n",
+ "\n",
+ "***Skriv funksjonen `gcd` i kodeblokken under og test at den funker som den skal***"
+ ],
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ }
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "source": [],
+ "outputs": [],
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2019-07-03T08:46:31.734000Z",
+ "start_time": "2019-07-03T08:46:31.723874Z"
+ }
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "## b)\n",
+ "\n",
+ "Du skal nå bruke gcd-funksjonen til å forkorte brøker. \n",
+ "\n",
+ "Lag en funksjon reduce_fraction som tar inn to positive heltall `a` og `b` og bruker gcd-funksjonen definert i forrige deloppgave for å finne største felles divisor `d`. \n",
+ "\n",
+ "Funksjonen skal returnere `a/d` og `b/d`.\n",
+ "\n",
+ "***Skriv funksjonen `reduce_fraction` i kodeblokken under***"
+ ],
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ }
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "source": [],
+ "outputs": [],
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2019-07-03T08:46:33.807693Z",
+ "start_time": "2019-07-03T08:46:33.802439Z"
+ }
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "Under finner du testkode for å sjekke at funksjonen din fungerer som den skal (husk å trykke `ctrl + enter` i kodeblokken med funksjonen din før du kjører denne)"
+ ],
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ }
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "source": [
+ "# TESTKODE FOR reduce_fraction\n",
+ "print (\"%d/%d\" % reduce_fraction (5, 10))\n",
+ "print (\"%d/%d\" % reduce_fraction (4, 2))\n",
+ "print (\"%d/%d\" % reduce_fraction (42 , 13))"
+ ],
+ "outputs": [],
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2019-07-03T08:46:35.969408Z",
+ "start_time": "2019-07-03T08:46:35.960742Z"
+ }
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "Hvis din versjon av `reduce_fraction` fungerer som den skal vil du få følgende output fra testkoden:\n",
+ "\n",
+ "```\n",
+ "1/2\n",
+ "2/1\n",
+ "42/13\n",
+ "```"
+ ],
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "#### Tips"
+ ],
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "heading_collapsed": true,
+ "run_control": {
+ "frozen": true
+ }
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "- For å returnere to variabler fra en funksjon separerer man returverdiene med komma: `return var_a, var_b`\n",
+ "\n",
+ "- Man kan også tilegne verdier til to variabler på samme kodelinje, dette gjøres ved å skrive: `a, b = funksjon_med_to_returverdier()` der funksjonen kalles."
+ ],
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "hidden": true,
+ "run_control": {
+ "frozen": true
+ }
+ }
+ }
+ ],
+ "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
+}
\ No newline at end of file
diff --git a/Oving4/Funksjoner og Jupyter widgets.ipynb b/Oving4/Funksjoner og Jupyter widgets.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..36f28cbb742545a0730901eb96c351579ec8b0f5
--- /dev/null
+++ b/Oving4/Funksjoner og Jupyter widgets.ipynb
@@ -0,0 +1,399 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "source": [
+ "<nav class=\"navbar navbar-default\">\n",
+ " <div class=\"container-fluid\">\n",
+ " <div class=\"navbar-header\">\n",
+ " <a class=\"navbar-brand\" href=\"_Oving4.ipynb\">Øving 4</a>\n",
+ " </div>\n",
+ " <ul class=\"nav navbar-nav\">\n",
+ " <li><a href=\"Grunnleggende%20om%20funksjoner.ipynb\">Grunnleggende om funksjoner</a></li>\n",
+ " <li><a href=\"Varierte%20funksjoner.ipynb\">Varierte funksjoner</a></li>\n",
+ " <li><a href=\"Lokale%20variabler.ipynb\">Lokale variabler</a></li>\n",
+ " <li><a href=\"Globale%20variabler.ipynb\">Globale variabler</a></li>\n",
+ " <li ><a href=\"Euklids%20algoritme.ipynb\">Euklids algoritme</a></li>\n",
+ " <li><a href=\"Primtall.ipynb\">Primtall</a></li>\n",
+ " <li><a href=\"Multiplikasjon.ipynb\">Multiplikasjon</a></li>\n",
+ " <li><a href=\"Den%20store%20sporreundersokelsen.ipynb\">Den store spørreundersøkelsen</a></li>\n",
+ " <li><a href=\"Arbeidsdager.ipynb\">Arbeidsdager</a></li>\n",
+ " <li><a href=\"Sekantmetoden.ipynb\">Sekantmetoden</a></li>\n",
+ " <li><a href=\"Not%20quite%20Blackjack.ipynb\">Not quite Blackjack</a></li>\n",
+ " <li class=\"active\"><a href=\"Funksjoner%20og%20Jupyter%20widgets.ipynb\">Funksjoner og Jupyter widgets</a></li>\n",
+ " </ul>\n",
+ " </div>\n",
+ "</nav>\n",
+ "\n",
+ "# Funksjoner og Jupyter widgets\n",
+ "\n",
+ "**Læringsmål:**\n",
+ "- Funksjoner\n",
+ "\n",
+ "Det er mye vi kan bruke funksjoner til i python. I jupyter finnes det et eget bibliotek med knapper og andre interaktive verktøy kalt widgets. Med widgets kan vi interagere med brukeren på et litt annet nivå enn det å ta tekstlig input fra konsollen tillater. Det anbefales å ta en liten kikk på dokumentajsonen til widgets før du setter i gang, [her](https://ipywidgets.readthedocs.io/en/latest/examples/Using%20Interact.html). "
+ ],
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "### Interact"
+ ],
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "Under ser vi hvordan vi kan definere en simpel funksjon, før vi kobler sammen funksjonen med grensesnittkontroller i form av en slider. Funksjonen vil så kalles med hva enn slideren er satt til. Når vi beveger slideren kalles funksjonen med sliderens verdi og verdien printes. **Kjør koden under**"
+ ],
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ }
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "source": [
+ "from ipywidgets import interact, interactive, fixed, interact_manual\n",
+ "from IPython.display import display\n",
+ "import ipywidgets as widgets\n",
+ "\n",
+ "def f(x):\n",
+ " return x\n",
+ "\n",
+ "interact(f, x=10)"
+ ],
+ "outputs": [],
+ "metadata": {}
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "**Oppgave a): Lag en slider hvor kvadratet av tallet slideren er satt til pluss 10 printes ut. Sett sliderens standardverdi til 3, minimumsverdien til -15, og maksverdien til 20. Steglengden skal være 0.2**"
+ ],
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ }
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "source": [
+ "#oppgave a)"
+ ],
+ "outputs": [],
+ "metadata": {}
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "#### Hint"
+ ],
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "heading_collapsed": true,
+ "run_control": {
+ "frozen": true
+ }
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "Se [her](https://ipywidgets.readthedocs.io/en/latest/examples/Using%20Interact.html#Widget-abbreviations) og [her](https://ipywidgets.readthedocs.io/en/latest/examples/Widget%20List.html). Husk at det er forskjell på int og float."
+ ],
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "hidden": true,
+ "run_control": {
+ "frozen": true
+ }
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "### Interact med andre datatyper"
+ ],
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "På helt lik linje kan vi kalle funksjonen vår med helt andre datatyper, så lenge vi ikke gjør noe ulovlig med dem inne i funksjonen. Setter vi x til en boolean vil vi heller få opp en avkrysningsboks, som enten vil være True eller False. Setter vi x til en streng vil få opp en tekstboks."
+ ],
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ }
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "source": [
+ "interact(f, x=True)\n",
+ "interact(f, x = \"Hei, hva heter du?\")"
+ ],
+ "outputs": [],
+ "metadata": {}
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "**Oppgave b):** Lag en funksjon `equation(a,b,c,x,reverse,statement)` som tar inn fem argumenter ved hjelp av widgets, a,b,c og x skal være heltall, reverse en boolean, og statement en streng. Funksjonen skal returnere statement, men dersom reverse er True, skal det være stor bokstav der det tidligere var liten, og motsatt. Deretter skal den regne ut\n",
+ "\n",
+ "$ax^{2}+bx+c$ \n",
+ "\n",
+ "og dersom reverse er True skal fortegnet til a ganges med -1. \n",
+ "\n",
+ "Eksmpel på kjøring:\n",
+ "```python\n",
+ ">>> print(equation(2,2,2,1,True, \"Hei\")\n",
+ "(\"hEI\", 2)\n",
+ ">>> print(equation(2,2,2,1,False, \"Hei\")\n",
+ "(\"Hei\", 6)\n",
+ ">>> print(equation(5,1,-10,20,False, \"Heiho\")\n",
+ "(\"Heiho\", 2010)\n",
+ "```"
+ ],
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ }
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "source": [
+ "#oppgave b"
+ ],
+ "outputs": [],
+ "metadata": {}
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "#### Hint"
+ ],
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "heading_collapsed": true,
+ "run_control": {
+ "frozen": true
+ }
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "En funksjon i python kan enkelt returnere to verdier separert med komma.\n",
+ "```python\n",
+ "def funksjon()\n",
+ " return \"hei\",6\n",
+ "```\n",
+ "Her må vi i tillegg iterere over en streng, noe vi teknisk sett ikke har lært enda. Du kan lese litt mer om dette [her](https://thispointer.com/python-how-to-iterate-over-the-characters-in-string/)."
+ ],
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "hidden": true,
+ "run_control": {
+ "frozen": true
+ }
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "### Buttons"
+ ],
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "Jupyter lar oss også benytte oss av buttons, som vi kan koble sammen med funksjoner. I tillegg la oss ta en kikk på Textarea, som vi kan bruke til å ta input fra bruker på en litt annen måte. "
+ ],
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ }
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "source": [
+ "tekst = widgets.Textarea(\n",
+ " value='Hello World',\n",
+ " placeholder='Type something',\n",
+ " description='tekst:',\n",
+ " disabled=False\n",
+ ")\n",
+ "display(tekst)\n",
+ "print(tekst.value)"
+ ],
+ "outputs": [],
+ "metadata": {}
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "Over ser vi et eksempel på et tekstfelt, hvor vi etterpå prøver å printe verdien som gis inn i tekstfeltet. Dette ser vi ikke fungerer om vi prøver å endre verdien i tekstfeltet og kjøre koden på nytt. La oss heller se på hvordan en knapp fungerer. Under ser vi hvordan vi definerer en knapp og så en funksjon som kalles når knappen trykkes. Merk at funksjonen hello tar inn en parameter b, denne parameteren vil da være knappen selv, altså button. Dette trenger du ikke tenke så mye på, bare vit at når definerer en funksjon som kalles når knappen trykkes, må denne parameteren alltid være med. "
+ ],
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ }
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "source": [
+ "button = widgets.Button(\n",
+ " description='Click me',\n",
+ " disabled=False,\n",
+ " tooltip='Click me',\n",
+ ")\n",
+ "\n",
+ "def hello(b):\n",
+ " print(\"Hello World\")\n",
+ " \n",
+ "button.on_click(hello)\n",
+ "display(button)"
+ ],
+ "outputs": [],
+ "metadata": {}
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "**Oppgave c):** Endre funksjonen hello så den printer ut det som er skrevet inn i tekstfeltet \"tekst\"."
+ ],
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "**Oppgave d)**: Lag en funksjon som stiller brukeren et flervalgsspørsmål. Ta derimot inn i svaret ved hjelp av RadioButtons-widgeten. Sjekk svaret ved bruk av en knapp og fortell brukeren om den svarte riktig eller galt. "
+ ],
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ }
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "source": [
+ "#oppgave d"
+ ],
+ "outputs": [],
+ "metadata": {}
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "#### Hint"
+ ],
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "heading_collapsed": true,
+ "run_control": {
+ "frozen": true
+ }
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "Det kan værte lurt å se [her](https://ipywidgets.readthedocs.io/en/latest/examples/Widget%20List.html#Selection-widgets). Python har også støtte for å definere funksjoner inni funksjoner, les mer om disse [her](https://realpython.com/inner-functions-what-are-they-good-for/)."
+ ],
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "hidden": true,
+ "run_control": {
+ "frozen": true
+ }
+ }
+ }
+ ],
+ "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
+}
\ No newline at end of file
diff --git a/Oving4/Globale variabler.ipynb b/Oving4/Globale variabler.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..1e879f817f942ae43d74625ed29b56994624c6fb
--- /dev/null
+++ b/Oving4/Globale variabler.ipynb
@@ -0,0 +1,388 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "source": [
+ "<nav class=\"navbar navbar-default\">\n",
+ " <div class=\"container-fluid\">\n",
+ " <div class=\"navbar-header\">\n",
+ " <a class=\"navbar-brand\" href=\"_Oving4.ipynb\">Øving 4</a>\n",
+ " </div>\n",
+ " <ul class=\"nav navbar-nav\">\n",
+ " <li><a href=\"Grunnleggende%20om%20funksjoner.ipynb\">Grunnleggende om funksjoner</a></li>\n",
+ " <li><a href=\"Varierte%20funksjoner.ipynb\">Varierte funksjoner</a></li>\n",
+ " <li><a href=\"Lokale%20variabler.ipynb\">Lokale variabler</a></li>\n",
+ " <li class=\"active\"><a href=\"Globale%20variabler.ipynb\">Globale variabler</a></li>\n",
+ " <li><a href=\"Euklids%20algoritme.ipynb\">Euklids algoritme</a></li>\n",
+ " <li><a href=\"Primtall.ipynb\">Primtall</a></li>\n",
+ " <li><a href=\"Multiplikasjon.ipynb\">Multiplikasjon</a></li>\n",
+ " <li><a href=\"Den%20store%20sporreundersokelsen.ipynb\">Den store spørreundersøkelsen</a></li>\n",
+ " <li><a href=\"Arbeidsdager.ipynb\">Arbeidsdager</a></li>\n",
+ " <li><a href=\"Sekantmetoden.ipynb\">Sekantmetoden</a></li>\n",
+ " <li><a href=\"Not%20quite%20Blackjack.ipynb\">Not quite Blackjack</a></li>\n",
+ " <li><a href=\"Funksjoner%20og%20Jupyter%20widgets.ipynb\">Funksjoner og Jupyter widgets</a></li>\n",
+ " </ul>\n",
+ " </div>\n",
+ "</nav>\n",
+ "\n",
+ "# Globale variabler\n",
+ "\n",
+ "**Læringsmål:**\n",
+ "- Funksjoner\n",
+ "\n",
+ "**Starting Out with Python:**\n",
+ "- Kap. 5.6"
+ ],
+ "metadata": {
+ "Collapsed": "false",
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "## Generelt om globale variabler\n",
+ "\n",
+ "Det kan være lurt å lese gjennom dette før du går videre"
+ ],
+ "metadata": {
+ "Collapsed": "false",
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "En global variabel er en variabel som kan aksesseres av alle funksjonene i et program, ved at den opprettes utenfor en funksjon. Globale variabler kan for eksempel brukes for å lagre data som man trenger å huske gjennom hele programutførelsen. Selv om bruk av globale variabler kan være praktisk, er det ofte bedre å bruke lokale variabler i for eksempel en main-funksjon, og så sende dette videre til andre funksjoner ved behov. Ulempen ved å ha funksjoner som bruker globale variabler, er tapet av forutsigbarhet. Funksjonene vil ikke lengre oppføre seg kun som en matematisk funksjon som alltid spytter ut samme svar gitt samme input, men vil kunne oppføre seg forskjellig basert på tilstanden til de globale variablene som funksjonen bruker. Dette betyr at i praksis brukes globale variabler som oftest for å lagre konstanter, altså variabler som bare leses og ikke endres. Slike variabler bruker ofte kun store bokstaver i navnet."
+ ],
+ "metadata": {
+ "Collapsed": "false",
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ }
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "source": [
+ "# EKSEMPEL PÅ GLOBALE VARIABLER BRUKT FOR Å LAGRE KONSTANTER\n",
+ "# Det er verdt å merke seg at denne konstanten også\n",
+ "# er definert i Pythons innebygde math-bibliotek\n",
+ "PI = 3.1415926\n",
+ " \n",
+ "# Funksjon som finner omkretsen til en sirkel med gitt radius\n",
+ "def omkrets(radius):\n",
+ " return 2 * PI * radius\n",
+ " \n",
+ "# Funksjon som finner arealet til en sirkel med gitt radius\n",
+ "def areal(radius):\n",
+ " return PI * radius ** 2"
+ ],
+ "outputs": [],
+ "metadata": {
+ "Collapsed": "false"
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "Som sagt er det også mulig å endre på globale variabler. For å gjøre dette, må man eksplisitt informere om at man skal bruke en global variabel med å bruke nøkkelordet global. Dette er illustrert i eksempelet under, hvor det er verdien som settes i fra kallet til funksjon a som blir stående, selv om b også endrer en variabel med samme navn og kjører etter at funksjon a kjører. Det som skjer her, er at i b lagres tallet i en lokal variabel med samme navn."
+ ],
+ "metadata": {
+ "Collapsed": "false",
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ }
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "source": [
+ "# HVORDAN ENDRE GLOBALE VARIABLER\n",
+ "stored_number = 30\n",
+ " \n",
+ "def a():\n",
+ " global stored_number\n",
+ " stored_number = 20\n",
+ "\n",
+ "def b():\n",
+ " stored_number = 10\n",
+ "\n",
+ "a()\n",
+ "b()\n",
+ " \n",
+ "print(stored_number) # => 20"
+ ],
+ "outputs": [],
+ "metadata": {
+ "Collapsed": "false"
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "## Funksjoner med valgfrie argumenter\n",
+ "\n",
+ "Det kan være lurt å lese gjennom dette før du går videre"
+ ],
+ "metadata": {
+ "Collapsed": "false",
+ "deletable": false,
+ "editable": false,
+ "heading_collapsed": true,
+ "run_control": {
+ "frozen": true
+ }
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "I Python er det mulig for et funksjonsargument å ha en default-verdi. Hvis en funksjon kalles uten en verdi for dette funksjonsargumentet, vil argumentet få denne default-verdien - koden kan altså fortsatt kjøre, selv om man gir funksjonen færre argumenter enn den egentlig tar inn. Du kan definere at en funksjon har default-verdier som vist i koden under."
+ ],
+ "metadata": {
+ "Collapsed": "false",
+ "deletable": false,
+ "editable": false,
+ "hidden": true,
+ "run_control": {
+ "frozen": true
+ }
+ }
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "source": [
+ "# Printer navnet til brukeren med store bokstaver i starten av hvert ord\n",
+ "def pretty_print_name(name, message = 'Hei'):\n",
+ " print(message, name.title())\n",
+ " \n",
+ "pretty_print_name('ola nOrDMaNN')\n",
+ "pretty_print_name('OLA Nordmann', 'Hello')"
+ ],
+ "outputs": [
+ {
+ "output_type": "stream",
+ "name": "stdout",
+ "text": [
+ "Hei Ola Nordmann\n",
+ "Hello Ola Nordmann\n"
+ ]
+ }
+ ],
+ "metadata": {
+ "Collapsed": "false",
+ "ExecuteTime": {
+ "end_time": "2019-07-03T07:48:09.688244Z",
+ "start_time": "2019-07-03T07:48:09.677730Z"
+ },
+ "hidden": true
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "## a) Lagring av konstanter"
+ ],
+ "metadata": {
+ "Collapsed": "false",
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "Gravitasjonsakselerasjonen g på jordoverflaten er omtrent 9.81 m/s². For våre formål kan denne antas å være konstant. Tiden som trengs for at et objekt i fritt fall skal ramle d meter er gitt ved formelen\n",
+ "\\begin{equation*}\n",
+ "t = \\sqrt{\\frac{2d}{g}}\n",
+ "\\end{equation*}\n",
+ "hvor $g$ er gravitasjonsakselerasjonen som gitt tidligere.\n",
+ "\n",
+ "I denne deloppgaven skal du lagre gravitasjonskonstanten i en global variabel med navnet `GRAVITY` på toppen av programmet ditt. Deretter skal du lage en funksjon `get_fall_time` som tar inn et gitt antall meter, og bruker formelen gitt over til å returnere hvor lang tid det tar et objekt å ramle det gitte antallet meter. La så programmet ditt ta inn en fall-lengde i meter fra brukeren, og bruk funksjonen du har laget til å regne ut hvor lang tid det tar å ramle den gitte distansen. Print ut resultatet.\n",
+ "\n",
+ "***Skriv koden i kodeblokken under***"
+ ],
+ "metadata": {
+ "Collapsed": "false",
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ }
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "source": [],
+ "outputs": [],
+ "metadata": {
+ "Collapsed": "false"
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "Eksempel på kjøring:\n",
+ "```python\n",
+ "Antallet meter objektet skal ramle: 20\n",
+ "Det tar 2.019275109384609 sekunder å ramle 20 meter\n",
+ "```"
+ ],
+ "metadata": {
+ "Collapsed": "false",
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "## b) Oppdatere en global variabel\n",
+ "\n",
+ "I denne oppgaven ønsker vi å legge til rette for flere verdier av gravitasjonsakselrasjonen, ettersom denne ikke er helt konstant over hele jordoverflaten, i tillegg til at den vil være forskjellig på f.eks. månen. En mulig måte å løse dette på kunne vært å introdusere en ny funksjon som lar brukeren overskrive verdien til den globale konstanten, som vist i følgende eksempel.\n",
+ "\n",
+ "```python\n",
+ "def set_gravity(gravity):\n",
+ " global GRAVITY\n",
+ " GRAVITY = gravity\n",
+ " \n",
+ "set_gravity(9.67)\n",
+ " \n",
+ "print(get_fall_time(20)) # => 1.4381419703158196\n",
+ "```\n",
+ "Synes du dette er en god løsning på problemet? ***Argumenter for eller i mot denne løsningen*** \n",
+ "***Dobbeltklikk på teksten under og skriv i feltet som dukker opp***"
+ ],
+ "metadata": {
+ "Collapsed": "false",
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "Svar: < dobbeltklikk her>"
+ ],
+ "metadata": {
+ "Collapsed": "false"
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "I tillegg skal du skrive om om funksjonen din fra oppgave a slik at den tar inn et ekstra parameter som lar deg sette hvilken verdi for gravitasjonsakselerasjonen som skal brukes. Parameteret skal ha konstanten GRAVITY som default-verdi. Under demonstreres hvordan denne nye funksjonen skal kunne brukes:\n",
+ "\n",
+ ">```python\n",
+ "print(get_fall_time(20)) # => 2.019275109384609\n",
+ "print(get_fall_time(20, 1.62)) # => 4.969039949999533\n",
+ "```\n",
+ "\n",
+ "***Kopier inn koden din fra oppgave a) nedenfor og gjør den om etter beskrivelsen over***"
+ ],
+ "metadata": {
+ "Collapsed": "false",
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ }
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "source": [],
+ "outputs": [],
+ "metadata": {
+ "Collapsed": "false"
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "Du kan teste ut funksjonen din med denne koden som burde kjøre likt som demonstrasjonen over. (husk å kjøre funksjonen i kodeblokken over før du kjører kodeblokken under slik at funksjonen er oppdatert)"
+ ],
+ "metadata": {
+ "Collapsed": "false",
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ }
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "source": [
+ "print(get_fall_time(20))\n",
+ "print(get_fall_time(20, 1.62))"
+ ],
+ "outputs": [],
+ "metadata": {
+ "Collapsed": "false"
+ }
+ }
+ ],
+ "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": true
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
\ No newline at end of file
diff --git a/Oving4/Grunnleggende om funksjoner.ipynb b/Oving4/Grunnleggende om funksjoner.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..f36a44c4cf8d9c8661457b94a7537d5ac3efd9a1
--- /dev/null
+++ b/Oving4/Grunnleggende om funksjoner.ipynb
@@ -0,0 +1,738 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "source": [
+ "<nav class=\"navbar navbar-default\">\n",
+ " <div class=\"container-fluid\">\n",
+ " <div class=\"navbar-header\">\n",
+ " <a class=\"navbar-brand\" href=\"_Oving4.ipynb\">Øving 4</a>\n",
+ " </div>\n",
+ " <ul class=\"nav navbar-nav\">\n",
+ " <li class=\"active\"><a href=\"Grunnleggende%20om%20funksjoner.ipynb\">Grunnleggende om funksjoner</a></li>\n",
+ " <li><a href=\"Varierte%20funksjoner.ipynb\">Varierte funksjoner</a></li>\n",
+ " <li><a href=\"Lokale%20variabler.ipynb\">Lokale variabler</a></li>\n",
+ " <li><a href=\"Globale%20variabler.ipynb\">Globale variabler</a></li>\n",
+ " <li><a href=\"Euklids%20algoritme.ipynb\">Euklids algoritme</a></li>\n",
+ " <li><a href=\"Primtall.ipynb\">Primtall</a></li>\n",
+ " <li><a href=\"Multiplikasjon.ipynb\">Multiplikasjon</a></li>\n",
+ " <li><a href=\"Den%20store%20sporreundersokelsen.ipynb\">Den store spørreundersøkelsen</a></li>\n",
+ " <li><a href=\"Arbeidsdager.ipynb\">Arbeidsdager</a></li>\n",
+ " <li><a href=\"Sekantmetoden.ipynb\">Sekantmetoden</a></li>\n",
+ " <li><a href=\"Not%20quite%20Blackjack.ipynb\">Not quite Blackjack</a></li>\n",
+ " <li><a href=\"Funksjoner%20og%20Jupyter%20widgets.ipynb\">Funksjoner og Jupyter widgets</a></li>\n",
+ " </ul>\n",
+ " </div>\n",
+ "</nav>\n",
+ "\n",
+ "# Grunnleggende om funksjoner\n",
+ "\n",
+ "**Læringsmål:**\n",
+ "- Funksjoner\n",
+ "\n",
+ "**Starting Out with Python:**\n",
+ "- Kap. 5.1-5.2\n",
+ "- Kap. 5.4\n",
+ "- Kap. 5.8"
+ ],
+ "metadata": {}
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "## Innføring – Del 1: Enkle funksjoner uten parametre og returverdi\n",
+ "Dette er ikke en del av oppgaven, men kan være lurt å lese før du går videre"
+ ],
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "heading_collapsed": true,
+ "run_control": {
+ "frozen": true
+ }
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "Programmet nedenfor tenkes å skulle skrive ut en masse data (hvorav bare fragmenter er vist her).\n",
+ "\n",
+ "Mellom hver bolk av data vil vi ha et skille med blank linje, horisontal strek og en ny blank linje.\n",
+ "\n",
+ "Dette gir identisk kode alle stedene markert med `##`, som er unødig tungvint."
+ ],
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "hidden": true,
+ "run_control": {
+ "frozen": true
+ }
+ }
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "source": [
+ "# EKSEMPEL UTEN FUNKSJON\n",
+ "print(\"Eksempel der vi BURDE brukt en funksjon\")\n",
+ "print() ##\n",
+ "print(\"---------------------\") ##\n",
+ "print() ##\n",
+ "print(\"Data fra måler 1:\", 23.4, 21.2, 21.9)\n",
+ "print(\"Osv., ...\")\n",
+ "print() ##\n",
+ "print(\"---------------------\") ##\n",
+ "print() ##\n",
+ "print(\"Data fra måler 2: ...\")\n",
+ "print() ##\n",
+ "print(\"---------------------\") ##\n",
+ "print() ##\n",
+ "print(\"Data fra måler 3: ...\")\n",
+ "print() ##\n",
+ "print(\"---------------------\") ##\n",
+ "print() ##"
+ ],
+ "outputs": [],
+ "metadata": {
+ "hidden": true
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "Nedenfor er det løst bedre:\n",
+ "\n",
+ "- Kodesnutten som trengs flere steder i programmet, defineres øverst som en funksjon, her med navnet `skille()`\n",
+ "- Trenger da kun skrive `skille()` de stedene i koden hvor vi ønsker disse tre print-setningene utført."
+ ],
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "hidden": true,
+ "run_control": {
+ "frozen": true
+ }
+ }
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "source": [
+ "# EKSEMPEL MED FUNKSJON\n",
+ "def skille():\n",
+ " print()\n",
+ " print(\"---------------------\")\n",
+ " print()\n",
+ "\n",
+ "\n",
+ "print(\"Samme eksempel MED funksjon\")\n",
+ "skille()\n",
+ "print(\"Data fra måler 1:\", 23.4, 21.2, 21.9)\n",
+ "print(\"Osv., ...\")\n",
+ "skille()\n",
+ "print(\"Data fra måler 2:\", 18.4, 19.1, 18.7)\n",
+ "skille()\n",
+ "print(\"Data fra måler 3:\", 19.9, 19.1, 18.2)\n",
+ "skille()"
+ ],
+ "outputs": [],
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2019-07-02T14:08:32.800529Z",
+ "start_time": "2019-07-02T14:08:32.779553Z"
+ },
+ "hidden": true
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "Utførelsen av denne koden starter på toppen av **skriptet**, dvs. koden som som er ute på vanlig marg.\n",
+ "\n",
+ "Det første som printes er derfor \"Samme eksempel MED funksjon\".\n",
+ "\n",
+ "Deretter de tre printene i skille-funksjonen.\n",
+ "\n",
+ "Deretter \"Data fra måling 1: ...\" Osv. Alt i alt blir resultatet dermed identisk med koden der vi ikke hadde funksjon, men koden med funksjon er kortere og ryddigere fordi vi unngår å gjenta identiske kodelinjer flere ganger."
+ ],
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "hidden": true,
+ "run_control": {
+ "frozen": true
+ }
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "## a)"
+ ],
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "Koden under har 4 identiske fragmenter merket med ##.\n",
+ "\n",
+ "***Endre koden på følgende måte:***\n",
+ "\n",
+ "- definer en funksjon `siksak()` som utfører de 4 linjene som er merket med `##`\n",
+ "- i skriptet kan du da erstatte disse 4 kodelinjene med kall til `siksak()`\n",
+ "\n",
+ "Utskriften etter endringen din skal være eksakt den samme som før programmet ble endret. Hvis du er i tvil om hva du skal gjøre her, les tutorial ovenfor som viser et lignende eksempel."
+ ],
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ }
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "source": [
+ "print(\"Data fra spørreundersøkelse\")\n",
+ "print() ##\n",
+ "print(\"** ** ** ** ** ** ** ** **\") ##\n",
+ "print(\" ** ** ** ** ** ** ** **\") ##\n",
+ "print() ##\n",
+ "print(\"Del 1: ... div. data her, ikke vist\")\n",
+ "print() ##\n",
+ "print(\"** ** ** ** ** ** ** ** **\") ##\n",
+ "print(\" ** ** ** ** ** ** ** **\") ##\n",
+ "print() ##\n",
+ "print(\"Del 2: ... mer data ...\")\n",
+ "print() ##\n",
+ "print(\"** ** ** ** ** ** ** ** **\") ##\n",
+ "print(\" ** ** ** ** ** ** ** **\") ##\n",
+ "print() ##\n",
+ "print(\"Del 3: ... enda mer data ...\")\n",
+ "print() ##\n",
+ "print(\"** ** ** ** ** ** ** ** **\") ##\n",
+ "print(\" ** ** ** ** ** ** ** **\") ##\n",
+ "print() ##\n",
+ "print(\"Del 4: ... ytterligere data ...\")"
+ ],
+ "outputs": [],
+ "metadata": {}
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "## Innføring – Del 2: Funksjoner med parametre, men fortsatt uten returverdi\n",
+ "\n",
+ "Dette er ikke en del av oppgaven, men kan være lurt å lese før du går videre"
+ ],
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "heading_collapsed": true,
+ "run_control": {
+ "frozen": true
+ }
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "Innføring – del 1 og oppgave (a) illustrerte hovedpoenget med funksjoner: At vi har lik kode flere sted i et program, denne kan da defineres en gang for alle og deretter kalles ved navn, så slipper vi å gjenta kodelinjer, og programmet blir ryddigere.\n",
+ "\n",
+ "Uten parametre har funksjoner likevel begrenset slagkraft. En funksjon uten parametre gjør eksakt det samme hver gang vi kaller den. Men ofte er behovet å gjøre nesten det samme, men ikke helt. En kvadratrotfunksjon trenger f.eks. å kunne regne ut roten av ulike tall - en funksjon som bare kan regne roten av 2, er ikke særlig nyttig. Nedenfor vises et eksempel som ligner på eksemplet fra oppgave (a). Vi har en utskrift hvor det inngår overskrifter i hashtag-bokser. Men koden er bare nesten lik, siden overskriftens tekst endrer seg fra gang til gang. Hvis vi lager en funksjon som alltid skriver INTRODUKSJON, kan denne ikke brukes for de neste overskriftene."
+ ],
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "hidden": true,
+ "run_control": {
+ "frozen": true
+ }
+ }
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "source": [
+ "# EKSEMPEL UTEN FUNKSJON\n",
+ "print()\n",
+ "print(\"################\")\n",
+ "print(\"# INTRODUKSJON #\")\n",
+ "print(\"################\")\n",
+ "print()\n",
+ "print(\"her kommer noen innledende forklaringer...\")\n",
+ "print()\n",
+ "print(\"##########################\")\n",
+ "print(\"# DATA FRA EKSPERIMENT 1 #\")\n",
+ "print(\"##########################\")\n",
+ "print()\n",
+ "print(\"Div. data:\", 123, 345, 432, 356)\n",
+ "print()\n",
+ "print(\"##########################\")\n",
+ "print(\"# DATA FRA EKSPERIMENT 2 #\")\n",
+ "print(\"##########################\")\n",
+ "print()\n",
+ "print(\"Osv...\") "
+ ],
+ "outputs": [],
+ "metadata": {
+ "hidden": true
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "Løsningen blir å utstyre funksjonen med en **parameter**, som gir funksjonen fleksibilitet til å endre litt oppførsel fra gang til gang:"
+ ],
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "hidden": true,
+ "run_control": {
+ "frozen": true
+ }
+ }
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "source": [
+ "# SAMME EKSEMPEL MED FUNKSJON\n",
+ "def box_heading(tekst):\n",
+ " bredde = len(tekst) + 4\n",
+ " print()\n",
+ " print(\"#\" * bredde )\n",
+ " print(\"# \" + tekst + \" #\")\n",
+ " print(\"#\" * bredde )\n",
+ " print()\n",
+ " \n",
+ "box_heading(\"INTRODUKSJON\")\n",
+ "print(\"her kommer noen innledende forklaringer...\")\n",
+ "box_heading(\"DATA FRA EKSPERIMENT 1\")\n",
+ "print(\"Div. data:\", 123, 345, 432, 356)\n",
+ "box_heading(\"DATA FRA EKSPERIMENT 2\")\n",
+ "print(\"Osv...\")"
+ ],
+ "outputs": [],
+ "metadata": {
+ "hidden": true
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "Programmet starter med å utføre `box_heading(\"INTRODUKSJON\")`. Dette gjør at vi kjører funksjonen `box_heading`, med argumentet `\"INTRODUKSJON\"` byttet inn for parameteren `tekst`.\n",
+ "\n",
+ "Setningen `print(\"# \" + tekst + \" #\")` gjør da at denne strengen skrives midt i boksen.\n",
+ "\n",
+ "Funksjonen `len(tekst)` gir oss lengden på strengen, dette gjør det mulig for oss å tilpasse bredden på boksen til hva som gis inn for parameteren.\n",
+ "\n",
+ "I neste kall av `box_heading` er det derimot argumentet `\"DATA FRA EKSPERIMENT 1\"` som byttes inn for parameteren `tekst`. Osv. Bruk av parameter gjør det dermed mulig for funksjonen `box_heading` å skrive ulik tekst i boksen fra gang til gang."
+ ],
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "hidden": true,
+ "run_control": {
+ "frozen": true
+ }
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "## Innføring - Del 3: Funksjoner med parametre *og* returverdi:\n",
+ "\n",
+ "Dette er ikke en del av oppgaven, men kan være lurt å lese før du går videre"
+ ],
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "heading_collapsed": true,
+ "run_control": {
+ "frozen": true
+ }
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "I (a) og (b) har vi sett på funksjoner uten returverdi. Dette kan være greit for funksjoner som spesifikt skal skrive eller tegne på skjermen.\n",
+ "\n",
+ "Men for funksjoner som skal beregne en verdi (og svært mange funksjoner skal nettopp det), trenger vi å få ut et resultat av beregningen. Til dette brukes **returverdi**.\n",
+ "\n",
+ "Det trenger ikke å være en matematisk beregning. For å vise noe annet, gis under et eksempel relatert til språk, nemlig en funksjon for å gradbøye adjektiv.\n",
+ "\n",
+ "Ideen med funksjonen **komparativ()** er at den får inn et adjektiv i vanlig positiv form, og da kan bøye til komparativ, f.eks. snill -> snillere, interessant -> mer interessant.\n",
+ "\n",
+ "For at ikke koden skal bli for lang, er eksemplet grovt forenklet - mange adjektiver vil bli bøyd feil.\n",
+ "\n",
+ "Å gi returverdi fra en funksjon, oppnås med ordet **return** (linje 7). Verdien av det som står etter return (her: variabelen svar, som vil være en streng, f.eks. \"snillere\") vil bli returnert fra funksjonen.\n",
+ "\n",
+ "Med \"snillere\" som returverdi vil da komparativ(adj) i linje 11 printe \"Hah! Jeg er mye snillere !\"\n",
+ "\n",
+ "Lenger nede i programmet, linje 16, vil bøyningen (f.eks. \"snillere\") bli satt inn i variabelen fasit, som deretter brukes i en if-test."
+ ],
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "hidden": true,
+ "run_control": {
+ "frozen": true
+ }
+ }
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "source": [
+ "def komparativ(adj):\n",
+ " # GROVT FORENKLET FOR Å KUNNE FOKUSERE PÅ HOVEDPOENGET\n",
+ " if len(adj) >= 8: # unøyaktig\n",
+ " svar = \"mer \" + adj\n",
+ " else:\n",
+ " svar = adj + \"ere\"\n",
+ " return svar\n",
+ " \n",
+ "### TILLEGG 1, ny funksjon, kommer her:\n",
+ " \n",
+ "#DEL AV KODEN HVOR SYSTEMET DISSER BRUKEREN\n",
+ "adj = input(\"Beskriv deg selv med et adjektiv: \")\n",
+ "print(\"Hah! Jeg er mye\", komparativ(adj) + \"!\")\n",
+ " \n",
+ "### TILLEGG 2 kommer her ...\n",
+ " \n",
+ "# DEL AV KODEN HVOR BRUKEREN TRENER PÅ Å GRADBØYE\n",
+ "adj = input(\"Skriv inn et adjektiv: \")\n",
+ "svar = input(\"Hva er komparativ for \" + adj + \"? \")\n",
+ "fasit = komparativ(adj)\n",
+ "if svar == fasit:\n",
+ " print(\"Korrekt!\")\n",
+ "else:\n",
+ " print(\"Feil, det var\", fasit)\n",
+ " \n",
+ "### TILLEGG 3 kommer her..."
+ ],
+ "outputs": [],
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2019-07-02T14:35:04.925444Z",
+ "start_time": "2019-07-02T14:34:33.712771Z"
+ },
+ "hidden": true
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "Men hva oppnår vi med returverdi her? Hvorfor ikke like godt bruke print() i slutten av funksjonen, heller enn å returnere en verdi som printes senere??\n",
+ "\n",
+ "**Med returverdi oppnår vi at funksjonen blir mer generelt anvendelig.** Funksjonen lar seg bruke for to ulike behov i dette lille programmet:\n",
+ "\n",
+ "- BRUK 1, linje 11, her er det programmet som autogenererer komparativ form og printer ut på skjermen\n",
+ "- BRUK 2, linje 16, her er det brukeren som prøver å svare hva komparativ er, programmet tester med en if-setning om det var korrekt\n",
+ "\n",
+ "**Hadde vi derimot printet i slutten av funksjonen, ville anvendeligheten har vært mindre.**\n",
+ "\n",
+ "- Printe \"Hah! Jeg er ...\" i slutten av funksjonen? Da passer den bare for BRUK 1\n",
+ "- Gjøre en if-test i slutten av funksjonen og printe Korrekt / Feil? Da passer den bare for BRUK 2\n",
+ "- Gjøre bare print(svar) i slutten av funksjonen i stedet for return svar? Da passer den verken for BRUK 1 eller BRUK 2\n",
+ "\n",
+ "På samme måte ville input i starten av funksjonen (i stedet for parameteren adj) ødelegge den generelle anvendeligheten.\n",
+ "\n",
+ "- input(\"Beskriv deg selv...\") i funksjonen - og den passer kun for BRUK 1\n",
+ "- input(\"Skriv inn...\") osv. i funksjonen - og den passer kun for BRUK 2\n",
+ "\n",
+ "For å lage generelt anvendelige funksjoner er det vanligvis lurt å unngå input og print i funksjonen - annet enn for funksjoner som spesifikt har som mål akkurat å kommunisere med brukeren."
+ ],
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "hidden": true,
+ "run_control": {
+ "frozen": true
+ }
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "# b)"
+ ],
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "Ta utgangspunkt i koden nedenfor, som også er forklart i Tutorial like over. Kjør koden og sjekk at den virker. Ikke la deg bekymre deg om at en del adjektiver bøyes feilaktig."
+ ],
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ }
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "source": [
+ "def komparativ(adj):\n",
+ " # GROVT FORENKLET FOR Å KUNNE FOKUSERE PÅ HOVEDPOENGET\n",
+ " if len(adj) >= 8: # unøyaktig\n",
+ " svar = \"mer \" + adj\n",
+ " else:\n",
+ " svar = adj + \"ere\"\n",
+ " return svar\n",
+ " \n",
+ "### TILLEGG 1, ny funksjon, kommer her:\n",
+ " \n",
+ "#DEL AV KODEN HVOR SYSTEMET DISSER BRUKEREN\n",
+ "adj = input(\"Beskriv deg selv med et adjektiv: \")\n",
+ "print(\"Hah! Jeg er mye\", komparativ(adj), \"!\")\n",
+ " \n",
+ "### TILLEGG 2 kommer her ...\n",
+ " \n",
+ "# DEL AV KODEN HVOR BRUKEREN TRENER PÅ Å GRADBØYE\n",
+ "adj = input(\"Skriv inn et adjektiv: \")\n",
+ "svar = input(\"Hva er komparativ for\" + adj + \"? \")\n",
+ "fasit = komparativ(adj)\n",
+ "if svar == fasit:\n",
+ " print(\"Korrekt!\")\n",
+ "else:\n",
+ " print(\"Feil, det var\", fasit)\n",
+ " \n",
+ "### TILLEGG 3 kommer her..."
+ ],
+ "outputs": [],
+ "metadata": {}
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "***Din oppgave: Lag en tilsvarende funksjon superlativ(adj)*** som tar inn som parameter et adjektiv i vanlig positiv form, bøyer det til superlativ (f.eks. snill -> snillest, interessant -> mest interessant), og returnerer superlativformen.\n",
+ "\n",
+ "Bortsett fra forskjellen i bøyning vil denne funksjonen være svært lik komparativ() som står der nå.\n",
+ "\n",
+ "- Den nye funksjonen skal skrives der kommentaren ### TILLEGG 1 nå står i koden\n",
+ "- Der det står ### TILLEGG 2, legg til en print-setning med et kall til superlativ(). Hvis brukeren skrev adjektivet \"snill\", skal utskriften bli \"Jeg er faktisk snillest i hele verden.\"\n",
+ "- Der det står ### TILLEGG 3, legg til en programdel som spør brukeren \"Hva er superlativ for ...\" (det adjektivet som ble skrevet inn...) og sjekker dette mot fasit på samme måte som koden nå gjør for komparativ.\n",
+ "\n",
+ "Frivillig ekstraoppgave (ikke nødvendig for å få (c) godkjent, men anbefalt å prøve): Etter dette vil du kanskje se at de to kodefragmentene som sjekker svar mot fasit er ganske like. Klarer du å lage en funksjon for dette, og så kalle denne to ganger, i stedet for å gjenta ganske lik kode to ganger i programmet?"
+ ],
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "## Innføring - Del 4: Main-funksjonen\n",
+ "\n",
+ "Dette er ikke en del av oppgaven, men kan være lurt å lese før du går videre"
+ ],
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "Det er vanlig for et program å ha en main-funksjon som blir kalt når programmet starter. Det er denne funksjonen som kaller programmets andre funksjoner når de trengs.\n",
+ "\n",
+ "Et eksempel på et program med en main-funksjon er vist under. Her er det oppdelt slik at funksjonen kvadrattall gjør en beregning, mens main() står for kommunikasjon med brukeren.\n",
+ "\n",
+ "I større programmer kunne det også ha vært egne funksjoner for å kommunisere med brukeren, slik at main() bare hadde gjort den overordende styringen både av beregning og brukerkommunikasjon ved å kalle andre funksjoner.\n",
+ "\n",
+ "Når kode som vi ellers ville hatt i skriptet puttes i en main()-funksjon, blir skriptet kun 1 linje som kaller main-funksjonen, som vist nederst her. Kjør koden selv og se om du skjønner hvordan den funker:"
+ ],
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ }
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "source": [
+ "def kvadrattall(x):\n",
+ " # INN: x, som er ment å være et heltall\n",
+ " # PROSESS: sjekker om x er et kvadrattall\n",
+ " #(dvs. om det fins et heltall y <= x slik at y * y == x)\n",
+ " # UT: hvis ja, returneres y. Ellers returneres False\n",
+ " for y in range(1, x + 1):\n",
+ " if y * y == x:\n",
+ " return y\n",
+ " return False\n",
+ " # vi kommer til siste return bare hvis vi ikke fant kvadrattall\n",
+ " # siden vi ellers vil ha avsluttet funksjonen med return y\n",
+ " \n",
+ "def main():\n",
+ " tall = int(input(\"Gi et heltall >0, eller 0 for å slutte: \"))\n",
+ " while tall > 0:\n",
+ " rot = kvadrattall(tall)\n",
+ " if rot:\n",
+ " print(tall, \"=\", rot, \"*\", rot, \"; m.a.o. et kvadrattall\")\n",
+ " else:\n",
+ " print(tall, \"er ikke et kvadrattall.\")\n",
+ " tall = int(input(\"Gi et heltall >0, eller 0 for å slutte: \"))\n",
+ " \n",
+ "# SKRIPT \n",
+ "main()"
+ ],
+ "outputs": [],
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2019-07-03T06:12:11.307021Z",
+ "start_time": "2019-07-03T06:09:51.377086Z"
+ }
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "Et annet poeng som denne koden illustrerer, er at **return** ikke er begrenset til å stå i siste setning i en funksjon.\n",
+ "\n",
+ "Her har vi dessuten en return som står inni en if-setning. Grunnen er at hvis vi finner svaret, er det ikke vits å fortsette flere runder med løkka; return vil gjøre at vi avslutter funksjonen."
+ ],
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "## c)"
+ ],
+ "metadata": {}
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "***Kopier koden du lagde for adjektiv i oppgave (b) inn under. Endre den ved å lage en main-funksjon for det som nå er skriptet, slik at skriptet bare blir et kall til main().***"
+ ],
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ }
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "source": [],
+ "outputs": [],
+ "metadata": {}
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "Kjøring av koden skal gi samme resultat som tidligere."
+ ],
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "#### Framgangsmåte"
+ ],
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "heading_collapsed": true,
+ "run_control": {
+ "frozen": true
+ }
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "1. Definer funksjonen og kall den main. Funksjonen skal IKKE ta inn noen argumenter.\n",
+ "2. Flytt kodelinjene som nå står i skriptet (dvs., som foreløpig ikke er del av noen funksjon) inn i main-funksjonen. Pass på riktig innrykk!\n",
+ "3. Legg til helt nederst i koden, ute på ytterste marg, et kall til main()."
+ ],
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "hidden": true,
+ "run_control": {
+ "frozen": true
+ }
+ }
+ }
+ ],
+ "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
+}
\ No newline at end of file
diff --git a/Oving4/Lokale variabler.ipynb b/Oving4/Lokale variabler.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..4dbdf1ce521329943c133788bd342cfc4283e200
--- /dev/null
+++ b/Oving4/Lokale variabler.ipynb
@@ -0,0 +1,427 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "source": [
+ "<nav class=\"navbar navbar-default\">\n",
+ " <div class=\"container-fluid\">\n",
+ " <div class=\"navbar-header\">\n",
+ " <a class=\"navbar-brand\" href=\"_Oving4.ipynb\">Øving 4</a>\n",
+ " </div>\n",
+ " <ul class=\"nav navbar-nav\">\n",
+ " <li><a href=\"Grunnleggende%20om%20funksjoner.ipynb\">Grunnleggende om funksjoner</a></li>\n",
+ " <li><a href=\"Varierte%20funksjoner.ipynb\">Varierte funksjoner</a></li>\n",
+ " <li class=\"active\"><a href=\"Lokale%20variabler.ipynb\">Lokale variabler</a></li>\n",
+ " <li><a href=\"Globale%20variabler.ipynb\">Globale variabler</a></li>\n",
+ " <li><a href=\"Euklids%20algoritme.ipynb\">Euklids algoritme</a></li>\n",
+ " <li><a href=\"Primtall.ipynb\">Primtall</a></li>\n",
+ " <li><a href=\"Multiplikasjon.ipynb\">Multiplikasjon</a></li>\n",
+ " <li><a href=\"Den%20store%20sporreundersokelsen.ipynb\">Den store spørreundersøkelsen</a></li>\n",
+ " <li><a href=\"Arbeidsdager.ipynb\">Arbeidsdager</a></li>\n",
+ " <li><a href=\"Sekantmetoden.ipynb\">Sekantmetoden</a></li>\n",
+ " <li><a href=\"Not%20quite%20Blackjack.ipynb\">Not quite Blackjack</a></li>\n",
+ " <li><a href=\"Funksjoner%20og%20Jupyter%20widgets.ipynb\">Funksjoner og Jupyter widgets</a></li>\n",
+ " </ul>\n",
+ " </div>\n",
+ "</nav>\n",
+ "\n",
+ "# Lokale variabler\n",
+ "\n",
+ "**Læringsmål:**\n",
+ "- Kodeforståelse\n",
+ "- Funksjoner\n",
+ "\n",
+ "**Starting Out with Python:**\n",
+ "- Kap. 5.4"
+ ],
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "## Generelt om lokale variabler\n",
+ "Dette er ikke en del av øvingen, men kan være lurt å lese før du går videre."
+ ],
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "heading_collapsed": true,
+ "run_control": {
+ "frozen": true
+ }
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "En lokal variabel er en variabel som blir lagd inne i en funksjons kodeblokk, og som ikke kan benyttes av kall utenfor funksjonen. Koden under viser et eksempel på dette. Prøv å kjøre koden og se hva som skjer. Hva tror du er galt?"
+ ],
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "hidden": true,
+ "run_control": {
+ "frozen": true
+ }
+ }
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "source": [
+ "def getName():\n",
+ " name = input(\"Hva heter du? \") \n",
+ "\n",
+ "getName()\n",
+ "print(\"Hei,\",name)"
+ ],
+ "outputs": [],
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2019-07-03T07:05:49.515891Z",
+ "start_time": "2019-07-03T07:05:47.759406Z"
+ },
+ "hidden": true
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "Her er `name` en lokal variabel for funksjonen `getName()`. Dette medfører at koden i linje 5 ikke kan aksessere variabelen `name` slik den prøver, og at programmet krasjer. Vi får her feilmeldingen \"NameError: name 'name' is not defined\", som rett og slett betyr at programmet ikke har kjennskap til noen variabel eller funksjon ved navnet 'name'.\n",
+ "\n",
+ "For å få koden til å fungere slik vi ønsker kan vi returnere name-variabelen og tilordne denne til en egen variabel - som kan kalles name eller noe helt annet - som linje 5 har tilgang til. Koden kan da se ut som under. Test gjerne koden og se at den virker."
+ ],
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "hidden": true,
+ "run_control": {
+ "frozen": true
+ }
+ }
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "source": [
+ "def getName():\n",
+ " name = input(\"Hva heter du? \")\n",
+ " return name\n",
+ " \n",
+ "name = getName()\n",
+ "print(\"Hei,\",name)"
+ ],
+ "outputs": [],
+ "metadata": {
+ "hidden": true
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "Koder kan også inneholde parametere som også fungerer som lokale variabler. Eksempelvis."
+ ],
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "hidden": true,
+ "run_control": {
+ "frozen": true
+ }
+ }
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "source": [
+ "def printName(name):\n",
+ " print(\"Hei \", name)\n",
+ " \n",
+ " \n",
+ "printName(\"Ola\")"
+ ],
+ "outputs": [],
+ "metadata": {
+ "hidden": true
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "Her vil \"Ola\" bli til **name**-variabelen og kun være tilgjengelig innenfor funksjonen."
+ ],
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "hidden": true,
+ "run_control": {
+ "frozen": true
+ }
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "## a)"
+ ],
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "Alle kodesnuttene under inneholder en feil, men en av dem vil fortsatt kjøre uten å krasje; hvilken og hvorfor? **Prøv å finne feilen i hver kodesnutt.**"
+ ],
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ }
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "source": [
+ "#Kodesnutt 1:\n",
+ "def cupcakes():\n",
+ " cupcakes = 24\n",
+ " print(\"Jeg har laget\",cupcakes,\"cupcakes\")\n",
+ "\n",
+ "def cakes():\n",
+ " print(\"Men jeg har bare bakt\",cake,\"kake\")\n",
+ " cake = 1\n",
+ "\n",
+ "cupcakes()\n",
+ "cakes()"
+ ],
+ "outputs": [],
+ "metadata": {}
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "source": [
+ "#Kodesnutt 2:\n",
+ "def cupcakes():\n",
+ " cupcake = 1\n",
+ " print(\"Jeg har laget\",cupcake,\"cupcake\")\n",
+ "\n",
+ "def cakes():\n",
+ " print(\"Og jeg har bakt\",cupcake,\"kake\")\n",
+ "\n",
+ "cupcakes()\n",
+ "cakes()"
+ ],
+ "outputs": [],
+ "metadata": {}
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "source": [
+ "#Kodesnutt 3:\n",
+ "def cupcakes():\n",
+ " cupcakes = 24\n",
+ " print(\"Jeg har laget\",cupcakes,\"cupcakes\")\n",
+ "\n",
+ "def cakes():\n",
+ " print(\"Men jeg har bare bakt\",cake,\"kake\")\n",
+ "\n",
+ "cupcakes()"
+ ],
+ "outputs": [],
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2019-07-03T07:12:49.707507Z",
+ "start_time": "2019-07-03T07:12:49.696917Z"
+ }
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "***Dobbelklikk på teksten under og skriv svaret ditt i boksen som kommer opp***"
+ ],
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "Svar: < dobbeltklikk her>"
+ ],
+ "metadata": {}
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "#### Hint"
+ ],
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "heading_collapsed": true,
+ "run_control": {
+ "frozen": true
+ }
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "Feilen i hver kode befinner seg i cakes()-funksjonen. Tenk på plassering av variabelen brukt i cakes-funksjonen.\n",
+ "\n",
+ "For å finne ut hvilken kodesnutt som ikke vil krasje ved kjøring av koden, tenk på funksjonskall. Er det et tilfelle der koden med feil i ikke vil bli utført?"
+ ],
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "hidden": true,
+ "run_control": {
+ "frozen": true
+ }
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "## b)"
+ ],
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "I denne oppgaven skal du skrive to funksjoner. Den første skal ta inn to argumenter `x` og `y`, lage en variabel `num` = `x//y`, og returnere resultatet slik at programmet kan skrive til skjerm \"Heltallsdivisjon av `x` over `y` gir `num`\".\n",
+ "\n",
+ "Den andre funksjonen skal ta inn ett argument x, lage en varibel num = x\\*\\*2, og returnere resultatet slik at programmet kan skrive til skjerm \"Kvadratet av `x` er `num`\".\n",
+ "\n",
+ "***Skriv koden din i kodeblokken under***"
+ ],
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ }
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "source": [],
+ "outputs": [],
+ "metadata": {}
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "Eksempel på kjøring:\n",
+ "```python\n",
+ "Heltallsdivisjon av 23 over 4 gir 5\n",
+ "Kvadratet av 3 er 9\n",
+ "```"
+ ],
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "## c)"
+ ],
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "Begge funksjonene i b) har en variabel kalt num. Kan dette føre til noen problemer i koden? Hvorfor/Hvorfor ikke?\n",
+ "\n",
+ "***Dobbelklikk på teksten under og skriv svaret ditt i boksen som kommer opp***"
+ ],
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "Svar: < dobbelklikk her>"
+ ],
+ "metadata": {}
+ }
+ ],
+ "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
+}
\ No newline at end of file
diff --git a/Oving4/Multiplikasjon.ipynb b/Oving4/Multiplikasjon.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..de6ed087f0d5eaf42ef9b5c879cc3f290f9dc3c8
--- /dev/null
+++ b/Oving4/Multiplikasjon.ipynb
@@ -0,0 +1,177 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "source": [
+ "<nav class=\"navbar navbar-default\">\n",
+ " <div class=\"container-fluid\">\n",
+ " <div class=\"navbar-header\">\n",
+ " <a class=\"navbar-brand\" href=\"_Oving4.ipynb\">Øving 4</a>\n",
+ " </div>\n",
+ " <ul class=\"nav navbar-nav\">\n",
+ " <li><a href=\"Grunnleggende%20om%20funksjoner.ipynb\">Grunnleggende om funksjoner</a></li>\n",
+ " <li><a href=\"Varierte%20funksjoner.ipynb\">Varierte funksjoner</a></li>\n",
+ " <li><a href=\"Lokale%20variabler.ipynb\">Lokale variabler</a></li>\n",
+ " <li><a href=\"Globale%20variabler.ipynb\">Globale variabler</a></li>\n",
+ " <li><a href=\"Euklids%20algoritme.ipynb\">Euklids algoritme</a></li>\n",
+ " <li><a href=\"Primtall.ipynb\">Primtall</a></li>\n",
+ " <li class=\"active\"><a href=\"Multiplikasjon.ipynb\">Multiplikasjon</a></li>\n",
+ " <li><a href=\"Den%20store%20sporreundersokelsen.ipynb\">Den store spørreundersøkelsen</a></li>\n",
+ " <li><a href=\"Arbeidsdager.ipynb\">Arbeidsdager</a></li>\n",
+ " <li><a href=\"Sekantmetoden.ipynb\">Sekantmetoden</a></li>\n",
+ " <li><a href=\"Not%20quite%20Blackjack.ipynb\">Not quite Blackjack</a></li>\n",
+ " <li><a href=\"Funksjoner%20og%20Jupyter%20widgets.ipynb\">Funksjoner og Jupyter widgets</a></li>\n",
+ " </ul>\n",
+ " </div>\n",
+ "</nav>\n",
+ "\n",
+ "# Multiplikasjon\n",
+ "\n",
+ "**Læringsmål:**\n",
+ "- Løkker\n",
+ "- Funksjoner\n",
+ "\n",
+ "**Starting Out with Python:**\n",
+ "- Kap. 4.2-4.3"
+ ],
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "## a)"
+ ],
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "Skriv en funksjon som tar inn en toleransegrense `tol` og returnerer `prod` og `count`, hvor `prod` er definert som:\n",
+ "\n",
+ "$(1+\\frac{1}{1^{2}})(1+\\frac{1}{2^{2}})(1+\\frac{1}{3^{2}})...$\n",
+ "\n",
+ "og `count` er antall iterasjoner som har blitt kjørt.\n",
+ "\n",
+ "Avslutt iterasjonen når endringen i produktet er mindre enn toleransegrensen `tol`. \n",
+ "\n",
+ "Skriv ut verdien og hvor mange iterasjoner som trengs. Hvis `tol` er 0.01 skal programmet skrive ut følgende:\n",
+ "```\n",
+ "Produktet ble 3.49 etter 19 iterasjoner.\n",
+ "```\n",
+ "\n",
+ "***Skriv koden i kodeblokken under***"
+ ],
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ }
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "source": [],
+ "outputs": [],
+ "metadata": {}
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "## b) (FRIVILLIG) (OG VANSKELIG)"
+ ],
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "Denne oppgaven krever at du bruker rekursjon, det vil si at funksjonen \"kaller\" på seg selv. Dette er en mye brukt programmeringsteknikk som vil bli gjennomgått senere i kurset. \n",
+ "\n",
+ "Lag en ny funksjon som gjør det samme som a) rekursivt. Avslutt rekursjonen når\n",
+ "\n",
+ "$(1+\\frac{1}{k^{2}}) < 1 + tol$\n",
+ "\n",
+ "Skriv også ut rekusjonsdybden\n",
+ "\n",
+ "**Eksempel på kjøring:**\n",
+ "\n",
+ "```\n",
+ "Skriv inn tol: 0.01\n",
+ "Rekursjonsdybden er 10\n",
+ "Produktet ble: 3.37\n",
+ "```\n",
+ "\n",
+ "*Merk: den rekursive funksjonen i b) vil ikke gi samme svar som a) pga. at betingelsene som blir brukt er forskjellige.*\n",
+ "\n",
+ "***Skriv koden i kodeblokken under***"
+ ],
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ }
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "source": [],
+ "outputs": [],
+ "metadata": {}
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.7.3"
+ },
+ "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
+}
\ No newline at end of file
diff --git a/Oving4/Not quite Blackjack.ipynb b/Oving4/Not quite Blackjack.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..dcc7d4ac3a1f3d59a2968a942879859e82ae6a46
--- /dev/null
+++ b/Oving4/Not quite Blackjack.ipynb
@@ -0,0 +1,131 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "source": [
+ "<nav class=\"navbar navbar-default\">\n",
+ " <div class=\"container-fluid\">\n",
+ " <div class=\"navbar-header\">\n",
+ " <a class=\"navbar-brand\" href=\"_Oving4.ipynb\">Øving 4</a>\n",
+ " </div>\n",
+ " <ul class=\"nav navbar-nav\">\n",
+ " <li><a href=\"Grunnleggende%20om%20funksjoner.ipynb\">Grunnleggende om funksjoner</a></li>\n",
+ " <li><a href=\"Varierte%20funksjoner.ipynb\">Varierte funksjoner</a></li>\n",
+ " <li><a href=\"Lokale%20variabler.ipynb\">Lokale variabler</a></li>\n",
+ " <li><a href=\"Globale%20variabler.ipynb\">Globale variabler</a></li>\n",
+ " <li><a href=\"Euklids%20algoritme.ipynb\">Euklids algoritme</a></li>\n",
+ " <li><a href=\"Primtall.ipynb\">Primtall</a></li>\n",
+ " <li><a href=\"Multiplikasjon.ipynb\">Multiplikasjon</a></li>\n",
+ " <li><a href=\"Den%20store%20sporreundersokelsen.ipynb\">Den store spørreundersøkelsen</a></li>\n",
+ " <li><a href=\"Arbeidsdager.ipynb\">Arbeidsdager</a></li>\n",
+ " <li><a href=\"Sekantmetoden.ipynb\">Sekantmetoden</a></li>\n",
+ " <li class=\"active\"><a href=\"Not%20quite%20Blackjack.ipynb\">Not quite Blackjack</a></li>\n",
+ " <li><a href=\"Funksjoner%20og%20Jupyter%20widgets.ipynb\">Funksjoner og Jupyter widgets</a></li>\n",
+ " </ul>\n",
+ " </div>\n",
+ "</nav>\n",
+ "\n",
+ "\n",
+ "# Not quite Blackjack\n",
+ "\n",
+ "**Læringsmål:**\n",
+ "- Funksjoner\n",
+ "- Betingelser\n",
+ "- Løkker\n",
+ "\n",
+ "**Starting Out with Python:**\n",
+ "- Kap. 3: Decision Structures and Boolean Logic \n",
+ "- Kap. 4.2: The while Loop\n",
+ "- Kap. 5: Functions\n",
+ "\n",
+ "I denne oppgaven skal du lage spillet Blackjack med en vri. Vanlige Blackjack reglene som skal implementeres er som følger:\n",
+ "\n",
+ "- Et ess teller enten 1 eller 11\n",
+ "- Alle bildekort (J, Q, K) har verdi 10\n",
+ "- Du får alltid utdelt to kort til å begynne med\n",
+ "- Hvis den samlede verdien på kortene er over 21 er du ute\n",
+ "- Et ess med 10 eller et bildekort er en «ekte» blackjack\n",
+ "- Du vinner på én av tre måter:\n",
+ " - Du får ekte blackjack uten at dealer gjør det samme,\n",
+ " - Du oppnår en høyere hånd enn dealer uten å overstige 21, eller\n",
+ " - Din hånd har verdi mindre enn 21, mens dealerens hånd overstiger 21\n",
+ "\n",
+ "Det som er annerledes med vår Blackjack, er at dealer bare får to kort, og at spilleren ikke får velge verdien ess vil ha. Spillet vil automatisk ta den verdien som er nærmest 21, men som ikke overstiger 21, og så fort en verdi for ess er satt, vil ikke denne endres senere. Dvs. at om man først får 1 (ess) og 8, vil verdien bli satt til 11+8=19. Om man deretter velger å trekke enda et kort og får 4, vil verdien bli 19+4=23, og man vil tape. Det blir altså ikke tatt hensyn til at 1+8+4<21. Om man derimot først fikk 4 og 8, og deretter fikk 1 (ess), så ville verdien blitt 4+8+1=13. \n",
+ "\n",
+ "**Eksempel på kjøring:**\n",
+ "```\n",
+ "Dealers cards are 9 and ?\n",
+ "Your score is: 16\n",
+ "Do you want another card? (J/N) J\n",
+ "Your score is: 19\n",
+ "Do you want another card? (J/N) N\n",
+ "Dealers score is: 18\n",
+ "You won!\n",
+ " \n",
+ "Dealers cards are 10 and ?\n",
+ "Your score is: 20\n",
+ "Do you want another card? (J/N) N\n",
+ "Dealers score is: 21\n",
+ "You lost\n",
+ " \n",
+ " \n",
+ "Dealers cards are 10 and ?\n",
+ "Your score is: 15\n",
+ "Do you want another card? (J/N) J\n",
+ "You got: 25\n",
+ "You lost\n",
+ "```\n",
+ "\n",
+ "***Skriv koden din i kodeblokken under***"
+ ],
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ }
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "source": [],
+ "outputs": [],
+ "metadata": {}
+ }
+ ],
+ "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
+}
\ No newline at end of file
diff --git a/Oving4/Primtall.ipynb b/Oving4/Primtall.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..54510525265a1ce151ce6ac56a571ff968834fc2
--- /dev/null
+++ b/Oving4/Primtall.ipynb
@@ -0,0 +1,289 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "source": [
+ "<nav class=\"navbar navbar-default\">\n",
+ " <div class=\"container-fluid\">\n",
+ " <div class=\"navbar-header\">\n",
+ " <a class=\"navbar-brand\" href=\"_Oving4.ipynb\">Øving 4</a>\n",
+ " </div>\n",
+ " <ul class=\"nav navbar-nav\">\n",
+ " <li><a href=\"Grunnleggende%20om%20funksjoner.ipynb\">Grunnleggende om funksjoner</a></li>\n",
+ " <li><a href=\"Varierte%20funksjoner.ipynb\">Varierte funksjoner</a></li>\n",
+ " <li><a href=\"Lokale%20variabler.ipynb\">Lokale variabler</a></li>\n",
+ " <li><a href=\"Globale%20variabler.ipynb\">Globale variabler</a></li>\n",
+ " <li><a href=\"Euklids%20algoritme.ipynb\">Euklids algoritme</a></li>\n",
+ " <li class=\"active\"><a href=\"Primtall.ipynb\">Primtall</a></li>\n",
+ " <li><a href=\"Multiplikasjon.ipynb\">Multiplikasjon</a></li>\n",
+ " <li><a href=\"Den%20store%20sporreundersokelsen.ipynb\">Den store spørreundersøkelsen</a></li>\n",
+ " <li><a href=\"Arbeidsdager.ipynb\">Arbeidsdager</a></li>\n",
+ " <li><a href=\"Sekantmetoden.ipynb\">Sekantmetoden</a></li>\n",
+ " <li><a href=\"Not%20quite%20Blackjack.ipynb\">Not quite Blackjack</a></li>\n",
+ " <li><a href=\"Funksjoner%20og%20Jupyter%20widgets.ipynb\">Funksjoner og Jupyter widgets</a></li>\n",
+ " </ul>\n",
+ " </div>\n",
+ "</nav>\n",
+ "\n",
+ "# Primtall\n",
+ "\n",
+ "**Læringsmål:**\n",
+ "- Løkker\n",
+ "\n",
+ "**Starting Out with Python:**\n",
+ "- Kap. 4.2-4.3"
+ ],
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "## a)"
+ ],
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "Skriv funksjonen `divisable(a, b)` som returnerer `True` dersom `a` er delelig med `b` og `False` ellers.\n",
+ "\n",
+ "***Skriv koden i kodeblokken under***"
+ ],
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ }
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "source": [],
+ "outputs": [],
+ "metadata": {}
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "Sjekk at funksjonen din fungerer med testkoden under. Output fra denne burde være:\n",
+ "```\n",
+ "True\n",
+ "False\n",
+ "```\n",
+ "\n",
+ "(Husk å trykke `ctrl + enter` i kodeblokken med funksjonen din før du kjører testkoden)"
+ ],
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ }
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "source": [
+ "# TESTKODE FOR divisable\n",
+ "print(divisable(10,5))\n",
+ "print(divisable(10,3))"
+ ],
+ "outputs": [],
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2019-07-03T09:00:50.589088Z",
+ "start_time": "2019-07-03T09:00:50.258480Z"
+ }
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "#### Hint"
+ ],
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "heading_collapsed": true,
+ "run_control": {
+ "frozen": true
+ }
+ }
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "source": [],
+ "outputs": [],
+ "metadata": {}
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "En modulo-operasjon (% i python) blir brukt i informatikk og i matematikk til å finne resten av et opprinnelig heltall etter en divisjon med et annet tall.\n",
+ "\n",
+ "Eksempel på en modulo-operasjon: 5%2 = 1"
+ ],
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "hidden": true,
+ "run_control": {
+ "frozen": true
+ }
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "## b)"
+ ],
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "Lag funksjonen `isPrime` som tar inn et tall `a`. Funksjonen skal ha en for-løkke som itererer fra *b = 2,3,...,a-1* og bruke funksjonen fra forrige oppgave for å sjekke om `a` er delelig med `b`. Om de er delelige avslutter du og returnerer `False`. Ellers skal du returnere `True`.\n",
+ "\n",
+ "***Skriv koden i kodeblokken under***"
+ ],
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ }
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "source": [],
+ "outputs": [],
+ "metadata": {}
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "Sjekk at funksjonen din fungerer med testkoden under. Output fra denne burde være:\n",
+ "```\n",
+ "True\n",
+ "False\n",
+ "```\n",
+ "\n",
+ "Test gjerne også med andre verdier"
+ ],
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ }
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "source": [
+ "# TESTKODE FOR isPrime\n",
+ "print(isPrime(11))\n",
+ "print(isPrime(15))"
+ ],
+ "outputs": [],
+ "metadata": {}
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "## c)"
+ ],
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "Algoritmen skal nå gjøres raskere ved hjelp av 2 små inngrep som beskrevet nedenfor. Kall den nye funksjonen for isPrime2 og ta utgangspunkt i koden du skrev i b).\n",
+ "\n",
+ "- Du skal nå bare iterere deg gjennom oddetall. Men du må fortsatt sjekke om a er delelig med 2.\n",
+ "- Istedenfor å gå helt til $i=a−1$, skal du nå avslutte når $i>round(\\sqrt{a}+0.5)$\n",
+ "\n",
+ "***Skriv koden din i kodeblokken under og sjekk at den fungerer***"
+ ],
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ }
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "source": [],
+ "outputs": [],
+ "metadata": {}
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.7.3"
+ },
+ "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
+}
\ No newline at end of file
diff --git a/Oving4/Sekantmetoden.ipynb b/Oving4/Sekantmetoden.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..1b2c2c622add69b0f9513f0d8e0d0caa82d74c88
--- /dev/null
+++ b/Oving4/Sekantmetoden.ipynb
@@ -0,0 +1,291 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "source": [
+ "<nav class=\"navbar navbar-default\">\n",
+ " <div class=\"container-fluid\">\n",
+ " <div class=\"navbar-header\">\n",
+ " <a class=\"navbar-brand\" href=\"_Oving4.ipynb\">Øving 4</a>\n",
+ " </div>\n",
+ " <ul class=\"nav navbar-nav\">\n",
+ " <li><a href=\"Grunnleggende%20om%20funksjoner.ipynb\">Grunnleggende om funksjoner</a></li>\n",
+ " <li><a href=\"Varierte%20funksjoner.ipynb\">Varierte funksjoner</a></li>\n",
+ " <li><a href=\"Lokale%20variabler.ipynb\">Lokale variabler</a></li>\n",
+ " <li><a href=\"Globale%20variabler.ipynb\">Globale variabler</a></li>\n",
+ " <li><a href=\"Euklids%20algoritme.ipynb\">Euklids algoritme</a></li>\n",
+ " <li><a href=\"Primtall.ipynb\">Primtall</a></li>\n",
+ " <li><a href=\"Multiplikasjon.ipynb\">Multiplikasjon</a></li>\n",
+ " <li><a href=\"Den%20store%20sporreundersokelsen.ipynb\">Den store spørreundersøkelsen</a></li>\n",
+ " <li><a href=\"Arbeidsdager.ipynb\">Arbeidsdager</a></li>\n",
+ " <li class=\"active\"><a href=\"Sekantmetoden.ipynb\">Sekantmetoden</a></li>\n",
+ " <li><a href=\"Not%20quite%20Blackjack.ipynb\">Not quite Blackjack</a></li>\n",
+ " <li><a href=\"Funksjoner%20og%20Jupyter%20widgets.ipynb\">Funksjoner og Jupyter widgets</a></li>\n",
+ " </ul>\n",
+ " </div>\n",
+ "</nav>\n",
+ "\n",
+ "# Sekantmetoden\n",
+ "\n",
+ "**Læringsmål:**\n",
+ "- Funksjoner\n",
+ "- Løkker\n",
+ "\n",
+ "**Starting Out with Python:**\n",
+ "- Kap. 4.2-4.3\n",
+ "- Kap. 5.5\n",
+ "- Kap. 5.8-5.9\n",
+ "\n",
+ "I denne oppgaven skal vi implementere Sekantmetoden i Python.\n",
+ "\n",
+ "Sekantmetoden kan benyttes for å finne nullpunkt til en matematisk funksjon. En matematisk funksjon har et nullpunkt der $f(x) = 0$, dvs. at grafen krysser x-aksen. \n",
+ "\n",
+ "Sekantmetoden er gitt ved:\n",
+ "\n",
+ "$x_{k+1}=x_k-f(x_k)\\frac{x_k-x_{k-1}}{f(x_k)-f(x_{k-1})}$\n"
+ ],
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "## a)"
+ ],
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "Lag en funksjon `f` som tar inn et tall `x` som argument og returnerer verdien til\n",
+ "\n",
+ "$f(x)=(x-12)e^{x/2}-8(x+2)^{2}$\n",
+ "\n",
+ "og en annen funksjon `g` som tar inn `x` som argument og returnerer verdien til\n",
+ "\n",
+ "$g(x)=-x-2x^{2}-5x^{3}+6x^{4}$\n",
+ "\n",
+ "***Skriv koden din i kodeblokken under***"
+ ],
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ }
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "source": [],
+ "outputs": [],
+ "metadata": {}
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "Test også koden din med et par verdier. Du kan for eksempel sjekke at `f(0)` returnerer `-44` og at `g(1)` returnerer `-2`."
+ ],
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "## b)"
+ ],
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "Sekantmetoden er en tilnærming av Newtons metode:\n",
+ "\n",
+ "$x_{k+1}=x_{k}-\\frac{f(x_{k})}{f'(x_{k})}$ hvor\n",
+ "\n",
+ "$f'(x_k) \\approx \\frac{f(x_{k})- f(x_{k-1})}{x_{k}-x_{k-1}}$\n",
+ "\n",
+ "Lag en funksjon `differentiate(x_k, x_k1, func)` som bruker formelen for den approksimerte (**f'(x)**) gitt i oppgaveteksten til å derivere. Funksjonen skal ta inn tre argumenter: `x_k`, `x_k1` og `func`, og returnere den deriverte (et flyttall):\n",
+ "\n",
+ "- `x_k`: punktet hvor vi ønsker å finne den deriverte\n",
+ "- `x_k1`: et tidligere punkt som vi bruker for å finne stigningstall\n",
+ "- `func`: funksjonen man ønsker å derivere (i denne oppgaven vil `func` alltid tilsvare enten `f` eller `g` fra **a)**)\n",
+ "\n",
+ "***Skriv koden i kodeblokken under***"
+ ],
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ }
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "source": [],
+ "outputs": [],
+ "metadata": {}
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "For å teste funksjonen kan du kjør funksjonskallet `differentiate(9,10,f)`. dette skal returnere: -210.7749243035878"
+ ],
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "## c)"
+ ],
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "Lag en funksjon `secant_method(x0, x1, func, tol)` som benytter seg av `differentiate(x_k, x_k1, func)` til å utføre sekantmetoden. Funksjonen skal returnere verdien(/avslutte) når endringen i `x` er mindre enn toleransegrensen `tol`. \n",
+ "\n",
+ "Test funksjonen din med følgende verdier:\n",
+ "```python\n",
+ "secant_method(11,13,f,0.00001)\n",
+ "secant_method(1,2,g,0.00001)\n",
+ "secant_method(0,1,g,0.00001)\n",
+ "```\n",
+ "\n",
+ "***Skriv koden i kodeblokken under***"
+ ],
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "hide_input": true,
+ "run_control": {
+ "frozen": true
+ }
+ }
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "source": [],
+ "outputs": [],
+ "metadata": {}
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "**Eksempel på kjøring av kode:**\n",
+ "```python\n",
+ "Funksjonen nærmer seg et nullpunkt når x = 13.92 , da er f(x) = -1.59e-06\n",
+ "Funksjonen nærmer seg et nullpunkt når x = 1.22 , da er f(x) = -9.66e-08\n",
+ "Funksjonen nærmer seg et nullpunkt når x = 0.0 , da er f(x) = 0.0\n",
+ "```"
+ ],
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "#### Hint"
+ ],
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "heading_collapsed": true,
+ "run_control": {
+ "frozen": true
+ }
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "Som du kan se, trenger sekantmetoden to tidligere punkter for å finne et nytt. Pass på å skifte ut punktene etterhvert som det trengs."
+ ],
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "hidden": true,
+ "run_control": {
+ "frozen": true
+ }
+ }
+ }
+ ],
+ "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.1"
+ },
+ "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
+}
\ No newline at end of file
diff --git a/Oving4/Varierte funksjoner.ipynb b/Oving4/Varierte funksjoner.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..ef1294a0ad8d4a5e9473f83cae03f6e15830ea62
--- /dev/null
+++ b/Oving4/Varierte funksjoner.ipynb
@@ -0,0 +1,442 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "source": [
+ "<nav class=\"navbar navbar-default\">\n",
+ " <div class=\"container-fluid\">\n",
+ " <div class=\"navbar-header\">\n",
+ " <a class=\"navbar-brand\" href=\"_Oving4.ipynb\">Øving 4</a>\n",
+ " </div>\n",
+ " <ul class=\"nav navbar-nav\">\n",
+ " <li><a href=\"Grunnleggende%20om%20funksjoner.ipynb\">Grunnleggende om funksjoner</a></li>\n",
+ " <li class=\"active\"><a href=\"Varierte%20funksjoner.ipynb\">Varierte funksjoner</a></li>\n",
+ " <li><a href=\"Lokale%20variabler.ipynb\">Lokale variabler</a></li>\n",
+ " <li><a href=\"Globale%20variabler.ipynb\">Globale variabler</a></li>\n",
+ " <li><a href=\"Euklids%20algoritme.ipynb\">Euklids algoritme</a></li>\n",
+ " <li><a href=\"Primtall.ipynb\">Primtall</a></li>\n",
+ " <li><a href=\"Multiplikasjon.ipynb\">Multiplikasjon</a></li>\n",
+ " <li><a href=\"Den%20store%20sporreundersokelsen.ipynb\">Den store spørreundersøkelsen</a></li>\n",
+ " <li><a href=\"Arbeidsdager.ipynb\">Arbeidsdager</a></li>\n",
+ " <li><a href=\"Sekantmetoden.ipynb\">Sekantmetoden</a></li>\n",
+ " <li><a href=\"Not%20quite%20Blackjack.ipynb\">Not quite Blackjack</a></li>\n",
+ " <li><a href=\"Funksjoner%20og%20Jupyter%20widgets.ipynb\">Funksjoner og Jupyter widgets</a></li>\n",
+ " </ul>\n",
+ " </div>\n",
+ "</nav>\n",
+ "\n",
+ "# Varierte funksjoner\n",
+ "\n",
+ "**Læringsmål:**\n",
+ "- Kodeforståelse\n",
+ "- Funksjoner\n",
+ "\n",
+ "**Starting Out with Python:**\n",
+ "- Kap. 5.1, 5.2, 5.5, 5.8\n",
+ "\n",
+ "Oppgaven *grunnleggende om funksjoner* dreier seg mest om å omstrukturere eksisterende kode. I denne oppgaven skal du få prøve å skrive funksjoner helt fra grunnen av."
+ ],
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "## a)"
+ ],
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "Absoluttverdi er en funksjon med mange nyttige anvendelser, bl.a. i statistisk analyse (f.eks. utregning av standardavvik).\n",
+ "\n",
+ "Python har allerede funksjonen `abs()`. Men siden dette er en enkel funksjon å lage, later vi her som om den ikke fins, slik at det er behov for å skrive den.\n",
+ "\n",
+ "Kall din funksjon `absol()` så ikke navnet kolliderer med den eksisterende funksjonen. Reglene for `absol(x)` skal da være:\n",
+ "\n",
+ "- hvis x >= 0, er absoluttverdien til x identisk med x\n",
+ "- hvis x < 0, er absoluttverdien -x (minus minus gir pluss, absoluttverdi skal alltid være positiv)\n",
+ "\n",
+ "***Skriv koden i feltet under***"
+ ],
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ }
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "source": [],
+ "outputs": [],
+ "metadata": {}
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "Under har vi skrevet et test-skript slik at du kan teste funksjonen etter at du har skrevet den"
+ ],
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ }
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "source": [
+ "# skript for å teste funksjonen:\n",
+ "print(\"Absoluttverdien til 5 er\", absol(5))\n",
+ "print(\"Absoluttverdien til -3 er\", absol(-3))\n",
+ "print(\"Absoluttverdien til 0 er\", absol(0))"
+ ],
+ "outputs": [],
+ "metadata": {}
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "Resultat av kjøring med det gitte testskriptet skal bli:\n",
+ "\n",
+ "```python\n",
+ "Absoluttverdien til 5 er 5\n",
+ "Absoluttverdien til -3 er 3\n",
+ "Absoluttverdien til 0 er 0\n",
+ "```\n",
+ "\n",
+ "Kjør kodeblokken og sjekk om din kode gir det samme resultatet"
+ ],
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "## b)"
+ ],
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "Skriv en funksjon som får inn hastighet i knop og returnerer hastighet i km/t ved hjelp av følgende opplysninger:\n",
+ "\n",
+ "- 1 knop er 0.514444444 m/s\n",
+ "- 1 m/s er 3.6 km/t\n",
+ "\n",
+ "***Kall funksjonen for `knop2km_t` og skriv den i feltet under***"
+ ],
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ }
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "source": [],
+ "outputs": [],
+ "metadata": {}
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "Under har du et skript for å teste funksjonen din:"
+ ],
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ }
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "source": [
+ "# testskript for knop2km_t\n",
+ "knop = float(input(\"Oppgi fart i knop:\"))\n",
+ "km_t = knop2km_t(knop)\n",
+ "print(\"Det blir\", round(km_t, 2), \"km/t\")"
+ ],
+ "outputs": [],
+ "metadata": {}
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "Hvis du har skrevet funksjonen riktig skal skriptet gi følgende output:\n",
+ "```python\n",
+ "Oppgi fart i knop: 15.2\n",
+ "Det blir 28.15 km/t.\n",
+ "```"
+ ],
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "## c)"
+ ],
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ " I England og USA har det vært vanlig å oppgi personers høyde i fot og tommer (feet, inches - såkalte **imperial** måleenheter).\n",
+ "\n",
+ "Lag en funksjon med navn `imp2cm()` som får inn som parametrenen antall fot og antall tommer og returnerer antall cm som dette tilsvarer.\n",
+ "\n",
+ "Til dette kan man bruke følgende opplysninger:\n",
+ "\n",
+ "en fot tilsvarer 12 tommer\n",
+ "en tomme tilsvarer 2.54 cm\n",
+ "Funksjonen skal returnere antall cm avrundet til nærmeste heltall.\n",
+ "\n",
+ "***Skriv funksjonen din under***"
+ ],
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ }
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "source": [],
+ "outputs": [],
+ "metadata": {}
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "Kjør skriptet under for å teste funksjonen:"
+ ],
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ }
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "source": [
+ "# Testskript for funksjonen imp2cm\n",
+ "fot = int(input(\"Oppgi antall fot: \"))\n",
+ "tommer = int(input(\"Oppgi antall tommer: \"))\n",
+ "cm = imp2cm(fot, tommer)\n",
+ "print(\"Det blir\", cm, \"cm\")"
+ ],
+ "outputs": [],
+ "metadata": {}
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "Eksempel på kjøring av testskript dersom funksjonen din er riktig:\n",
+ "```python\n",
+ "Oppgi antall fot: 5\n",
+ "Oppgi antall tommer: 9\n",
+ "Det blir 175 cm\n",
+ "```"
+ ],
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "## d)"
+ ],
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "Farger for utskrift på papir angis i CMYK, med 4 flyttall mellom 0-1 for hvor mye cyan (C), gult (Y), magenta (M) og sort (K) printerblekk.\n",
+ "\n",
+ "Når farger skal vises på skjerm, angis de i RGB, dvs. som 3 heltall 0-255 som angir intensiteten av rødt (R), grønt (G) og blått (B) lys.\n",
+ "\n",
+ "\"Nina\" har jobbet som designer av brosjyremateriell på papir og vet om mange kule farger som hun kjenner CMYK-verdiene for.\n",
+ "\n",
+ "Kundene går i økende grad over til nettbasert infomateriell, så hun ønsker nå et program for å konvertere fra CMYK til RGB.\n",
+ "\n",
+ "Gitt verdier for C, M, Y, K som flyttall mellom 0 og 1, er formlene for konvertering slik:\n",
+ "\n",
+ "- R = 255 * (1-C) * (1-K)\n",
+ "- G = 255 * (1-M) * (1-K)\n",
+ "- B = 255 * (1-Y) * (1-K)\n",
+ "Mesteparten av programmet er gjort ferdig av en annen programmerer, men funksjonen **cmyk2rgb()** for selve konverteringen mangler.\n",
+ "\n",
+ "***Skriv inn den manglende koden i kodeblokken nedenfor; kjør deretter koden og se om den virker.***"
+ ],
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ }
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "source": [
+ "# skriv funksjonen cmyk2rgb() her øverst\n",
+ " \n",
+ " \n",
+ "print(\"Oppgi farge i CMYK og få det konvertert til RGB.\")\n",
+ "C = float(input(\"C: \"))\n",
+ "M = float(input(\"M: \"))\n",
+ "Y = float(input(\"Y: \"))\n",
+ "K = float(input(\"K: \"))\n",
+ "R, G, B = cmyk2rgb(C, M, Y, K)\n",
+ "print(\"Som RGB:\", R, G, B)"
+ ],
+ "outputs": [],
+ "metadata": {}
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "#### Hint"
+ ],
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "heading_collapsed": true,
+ "run_control": {
+ "frozen": true
+ }
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "**Hint 1:** Du må navngi funksjonen akkurat `cmyk2rgb` hvis den skal virke med den koden som er gitt på forhånd, siden dette navnet brukes i et kall midt nede i koden.\n",
+ "\n",
+ "Funksjonen må ha et antall parametre som stemmer med antallet argumenter i kallet cmyk2rgb(C, M, Y, K) - dvs. 4 parametre.\n",
+ "\n",
+ "\n",
+ "\n",
+ "**Hint 2:** Siden det står R, G, B = cmyk2rgb... i skriptet, må det komme **3 verdier** fra funksjonen for at alle disse variablene skal få innhold.\n",
+ "\n",
+ "Altså trenger funksjonen å returnere 3 verdier, ikke bare 1 som vi har sett tidligere.\n",
+ "\n",
+ "Dette er imidlertid ikke spesielt vanskelig - å returnere flere verdier fra en funksjon gjøres simpelthen ved å liste opp flere returverdier med komma mellom.\n",
+ "\n",
+ "F.eks., `return x, y, z` vil returnere verdiene til 3 variable x, y, z fra en funksjon (men du kan godt gi dine variable litt mer intelligente navn)\n",
+ "\n",
+ " \n",
+ "\n",
+ "**Hint 3:** C, M, Y, K inneholder flyttall mellom 0 og 1. Utregningene med formlene gitt over vil dermed også gi flyttall som resultat.\n",
+ "\n",
+ "Du trenger imidlertid heltall 0-255 som verdier for R, G, B. Husk derfor å bruke round() eller int() på sluttresultatet av formlene før du returnerer verdier fra funksjonen."
+ ],
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "hidden": true,
+ "run_control": {
+ "frozen": true
+ }
+ }
+ }
+ ],
+ "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
+}
\ No newline at end of file
diff --git a/Oving4/_Oving4.ipynb b/Oving4/_Oving4.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..fceab518353816e2e9107bcc4b60b912c07b0864
--- /dev/null
+++ b/Oving4/_Oving4.ipynb
@@ -0,0 +1,93 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "source": [
+ "# Øving 4\n",
+ "\n",
+ "**Læringsmål:**\n",
+ "- Funksjoner\n",
+ "- Løkker\n",
+ "- Betingelser\n",
+ "\n",
+ "**Starting Out with Python:**\n",
+ "- Kap. 5: Functions\n",
+ "\n",
+ "**Theory book:**\n",
+ "- Kap. 7: Representing Information Digitally\n",
+ "- Kap. 8: Representing Multimedia Digitally\n",
+ "- Kap. 12: Representing Integers\n",
+ " \n",
+ "\n",
+ "## Godkjenning:\n",
+ "\n",
+ "For å få godkjent øvingen må du gjøre ***4*** av ***12*** oppgaver.\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",
+ "[Grunnleggende om funksjoner](Grunnleggende%20om%20funksjoner.ipynb)|Funksjoner|\n",
+ "[Varierte funksjoner](Varierte%20funksjoner.ipynb)|Funksjoner|\n",
+ "[Lokale variabler](Lokale%20variabler.ipynb)|Funksjoner|\n",
+ "[Globale variabler](Globale%20variabler.ipynb)|Funksjoner|\n",
+ "[Euklids algoritme](Euklids%20algoritme.ipynb)|Funksjoner, Algoritmer|\n",
+ "[Primtall](Primtall.ipynb)|Funksjoner, Løkker|\n",
+ "[Multiplikasjon](Multiplikasjon.ipynb)|Funksjoner, Løkker|\n",
+ "[Den store spørreundersøkelsen](Den%20store%20sporreundersokelsen.ipynb)|Funksjoner, Løkker|\n",
+ "[Arbeidsdager](Arbeidsdager.ipynb)|Funksjoner, Løkker|\n",
+ "[Sekantmetoden](Sekantmetoden.ipynb)|Funksjoner, Løkker|\n",
+ "[Not quite Blackjack](Not%20quite%20Blackjack.ipynb)|Funksjoner, Løkker, Betingelser|\n",
+ "[Funksjoner og Jupyter widgets](Funksjoner%20og%20Jupyter%20widgets.ipynb)|Funksjoner, Jupyter widgets|"
+ ],
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ }
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.7.3"
+ },
+ "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": {
+ "height": "calc(100% - 180px)",
+ "left": "10px",
+ "top": "150px",
+ "width": "231px"
+ },
+ "toc_section_display": true,
+ "toc_window_display": false
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
\ No newline at end of file