diff --git a/Ovinger/Oving01/Bakekurs.ipynb b/Ovinger/Oving01/Bakekurs.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..2938949085006840bd88e16ee5a188fa3713f90b
--- /dev/null
+++ b/Ovinger/Oving01/Bakekurs.ipynb
@@ -0,0 +1,265 @@
+{
+ "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=\"_Oving1.ipynb\">Øving 1</a>\n",
+ " </div>\n",
+ " <ul class=\"nav navbar-nav\">\n",
+ " <li><a href=\"Intro%20til%20jupyter.ipynb\">Intro til Jupyter</a></li>\n",
+ " <li ><a href=\"Jeg%20elsker%20ITGK!.ipynb\">Jeg elsker ITGK!</a></li>\n",
+ " <li ><a href=\"Kalkulasjoner.ipynb\">Kalkulasjoner</a></li>\n",
+ " <li><a href=\"Input%20og%20variable.ipynb\">Input og variable</a></li>\n",
+ " <li><a href=\"Tallkonvertering.ipynb\">Tallkonvertering</a></li>\n",
+ " <li ><a href=\"Peppes%20Pizza.ipynb\">Peppes Pizza</a></li>\n",
+ " <li ><a href=\"Geometri.ipynb\">Geometri</a></li>\n",
+ " <li ><a href=\"Vitenskapelig%20notasjon.ipynb\">Vitenskapelig notasjon</a></li>\n",
+ " <li ><a href=\"Tetraeder.ipynb\">Tetraeder</a></li>\n",
+ " <li class=\"active\"><a href=\"Bakekurs.ipynb\">Bakekurs</a></li>\n",
+ " <li ><a href=\"James%20Bond%20and%20Operation%20round().ipynb\">James Bond and Operation Round</a></li>\n",
+ " </ul>\n",
+ " </div>\n",
+ "</nav>\n",
+ "\n",
+ "# Bakekurs\n",
+ "\n",
+ "**Læringsmål:**\n",
+ "\n",
+ "* Printe ut tekst til skjerm på en fin måte\n",
+ "\n",
+ "* Kalkulasjoner i Python\n",
+ "\n",
+ "**Starting Out with Python:**\n",
+ "\n",
+ "* Kap. 2.3\n",
+ "\n",
+ "* Kap. 2.8\n",
+ "\n",
+ "* Kap. 8\n",
+ "\n",
+ "I denne oppgaven skal du beregne mengden ingredienser som trengs for å lage cookies og printe resultatet på et fint format. \n",
+ "\n",
+ "Du skal lage cookies og har en oppskrift som gir 48 cookies. Den oppskriften krever følgende ingredienser:\n",
+ "\n",
+ "* 400 g sukker \n",
+ "* 320 g smør\n",
+ "* 500 g sjokolade\n",
+ "* 2 egg \n",
+ "* 460 g hvetemel "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "## a)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Spør brukeren om hvor mange cookies han eller hun ønsker å bake og skriv ut hvor mange ingredienser som trengs for å lage så mange cookies.\n",
+ "\n",
+ "Eksempel på kjøring:\n",
+ "\n",
+ " \n",
+ "```python\n",
+ "Hvor mange cookies ønsker du å bake? 24\n",
+ "Antall cookies: 24 \n",
+ "sukker(g): 200.0\n",
+ "smør(g): 160.0\n",
+ "sjokolade(g): 250.0\n",
+ "egg: 1.0\n",
+ "hvetemel(g): 230.0\n",
+ "```\n",
+ " \n",
+ "***Skriv koden din i blokka under.***"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "heading_collapsed": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "#### Tips til oppgave a: Escape Character"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "hidden": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "`\\n` er nyttig Ã¥ bruke her for Ã¥ fÃ¥ en ny linje! Eks. `print(“hei\\npÃ¥\\ndegâ€)` gir\n",
+ "\n",
+ "**Utskrift**\n",
+ " \n",
+ "```\n",
+ "hei \n",
+ "på \n",
+ "deg\n",
+ "```"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "## b)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Be brukeren om hvor mange cookies han eller hun ønsker å lage tre ganger og skriv ut ingrediensene på en fin og elegant måte. Du trenger kun å skrive ut antall cookies, og hvor mye sjokolade og sukker som trengs i gram.\n",
+ "\n",
+ "Eksempel på kjøring:\n",
+ "\n",
+ " \n",
+ "```python\n",
+ "Hvor mange cookies vil du lage? 24\n",
+ "og hvor mange cookies vil du lage nå? 48\n",
+ "og hvor mange cookies vil du lage til slutt? 72\n",
+ "Antall cookies: sukker(g) sjokolade(g)\n",
+ "24 200.0 250.0\n",
+ "48 400.0 500.0\n",
+ "72 600.0 750.0\n",
+ "```\n",
+ "\n",
+ "`rjust()` og `ljust()` er nyttige funksjoner her, men for å bruke dem må man først konvertere antall cookies til en streng vha. `str()`. Andre ting som kan være nyttig er `\\t` som lager et innrykk i teksten.\n",
+ "\n",
+ "***Skriv koden din i blokka under.***"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "heading_collapsed": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "#### ljust() og rjust()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "hidden": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "`streng.ljust(width)` returnerer strengen \"left justified\" i en streng av lengde `width`. `streng.rjust(width)` gjør det sammen bare at strengen blir \"right justified\". For eksempel blir `print('hei'.rjust(15))` til:\n",
+ "\n",
+ " \n",
+ "```python\n",
+ " hei #teksten printes altså ut etter 12 white spaces, ettersom strengen har lengde 3\n",
+ "```\n",
+ " \n",
+ "Du kan lese mer om `rjust()` og `ljust()` [her](https://docs.python.org/2/library/stdtypes.html?highlight=rjust#str.rjust). "
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.7.4"
+ },
+ "toc": {
+ "base_numbering": 1,
+ "nav_menu": {},
+ "number_sections": false,
+ "sideBar": true,
+ "skip_h1_title": false,
+ "title_cell": "Table of Contents",
+ "title_sidebar": "Contents",
+ "toc_cell": false,
+ "toc_position": {},
+ "toc_section_display": true,
+ "toc_window_display": false
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/Ovinger/Oving01/Geometri.ipynb b/Ovinger/Oving01/Geometri.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..ae882d7025539fd81d98893ab05cc5f595f2ecbe
--- /dev/null
+++ b/Ovinger/Oving01/Geometri.ipynb
@@ -0,0 +1,293 @@
+{
+ "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=\"_Oving1.ipynb\">Øving 1</a>\n",
+ " </div>\n",
+ " <ul class=\"nav navbar-nav\">\n",
+ " <li><a href=\"Intro%20til%20jupyter.ipynb\">Intro til Jupyter</a></li>\n",
+ " <li ><a href=\"Jeg%20elsker%20ITGK!.ipynb\">Jeg elsker ITGK!</a></li>\n",
+ " <li ><a href=\"Kalkulasjoner.ipynb\">Kalkulasjoner</a></li>\n",
+ " <li><a href=\"Input%20og%20variable.ipynb\">Input og variable</a></li>\n",
+ " <li><a href=\"Tallkonvertering.ipynb\">Tallkonvertering</a></li>\n",
+ " <li ><a href=\"Peppes%20Pizza.ipynb\">Peppes Pizza</a></li>\n",
+ " <li class=\"active\"><a href=\"Geometri.ipynb\">Geometri</a></li>\n",
+ " <li><a href=\"Vitenskapelig%20notasjon.ipynb\">Vitenskapelig notasjon</a></li>\n",
+ " <li><a href=\"Tetraeder.ipynb\">Tetraeder</a></li>\n",
+ " <li><a href=\"Bakekurs.ipynb\">Bakekurs</a></li>\n",
+ " <li ><a href=\"James%20Bond%20and%20Operation%20round().ipynb\">James Bond and Operation Round</a></li>\n",
+ " </ul>\n",
+ " </div>\n",
+ "</nav>\n",
+ "\n",
+ "# Geometri\n",
+ "\n",
+ "**Læringsmål:**\n",
+ "\n",
+ "* Forstå at kode må være feilfri for å kjøre, og rette enkle syntaksfeil\n",
+ "\n",
+ "* Debugging\n",
+ "\n",
+ "**Starting Out with Python:**\n",
+ "\n",
+ "* Kap. 2\n",
+ "\n",
+ "I denne oppgaven skal vi rette feil i koden og endre utskriftsformat.\n",
+ "\n",
+ "Norsklæreren din kunne utmerket godt lest en stil og forstått den på tross av noen småfeil, og til og med gitt god karakter hvis innholdet forøvrig var bra. Datamaskinen er ikke like tilgivende: I et Python-program må alt være pinlig nøyaktig, en enkelt skrivefeil kan være nok til at programmet slett ikke kjører."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "## a)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Rett alle syntaksfeilene i koden under slik at koden kjører uten problemer. Hver av syntaksfeilene her kan rettes ved Ã¥ fjerne, legge til eller endre ett enkelt tegn, dvs. det er ikke nødvendig Ã¥ gjøre større endringer i koden. Ved Ã¥ kjøre programmet (velg â€Run†i menyen) og se pÃ¥ feilmeldinger vil du fÃ¥ hint om hvor hver enkelt syntaksfeil befinner seg."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2019-07-01T11:56:48.846273Z",
+ "start_time": "2019-07-01T11:56:48.833816Z"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "r = 5\n",
+ "print(\"Vi har en sirkel med radius\" + r)\n",
+ "omkrets = 2 * 3.14 * r\n",
+ "print(\"Omkretsen er\", omkrets))\n",
+ "areal = 3.14 * radius * * 2\n",
+ "print(\"Arealet er\", areal\n",
+ "h = 8\n",
+ "volum = aral * h\n",
+ "Print(\"Sylinder med høyde\", h, \": Volumet er, volum)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Når koden fungerer bør du få følgende output:\n",
+ "\n",
+ " \n",
+ "```python\n",
+ "Vi har en sirkel med radius 5\n",
+ "Omkretsen er 31.400000000000002\n",
+ "Arealet er 78.5\n",
+ "Sylinder med høyde 8 : Volumet er 628.0\n",
+ " ```"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2019-07-01T11:57:35.984163Z",
+ "start_time": "2019-07-01T11:57:35.979863Z"
+ },
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "#### Hint"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Tenk på parenteser, fnutter, variabelnavn og (+/,) i kombinasjon av tekst og variabelnavn."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "#### Formatering av antall desimaler"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "At omkretsen får en liten hale med ...002 skyldes at flyttall ikke kan lagres helt nøyaktig i dataens minne. Derfor kan det være ønskelig med kun to desimaler. Det er en innebygd funksjon i Python som tar seg av formatering og den ser slik ut: `format(tall, formatering)`. `tall` er her tallet som skal konverteres, dvs. omkretsen i eksempelet over, mens formatering går ut på hvordan man ønsker å formere tallet. Et eksempel er format`(2/3, ‘.3f’)` som gir `0.667`. 3-tallet indikerer at det ønskes 3 desimaler."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "## b"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Endre koden fra **a)** til å skrive ut omkretsen med kun 2 desimaler. Dvs. at linje to over skal bli endret til Omkretsen er 31.40.\n",
+ "\n",
+ "Kjøring av oppdatert kode:\n",
+ "\n",
+ " \n",
+ "```python\n",
+ "Vi har en sirkel med radius 5\n",
+ "Omkretsen er 31.40\n",
+ "Arealet er 78.5\n",
+ "Sylinder med høyde 8 : Volumet er 628.0\n",
+ " ```"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "## c)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "(frivillig vanskelig oppgave) I oppgave a får omkretsen verdien 31.400...002, hvorfor blir ikke omkretsen sin verdi lik 31.400...000?"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Dobbelklikk på teksten under og skriv svaret ditt der:"
+ ]
+ },
+ {
+ "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"
+ },
+ "toc": {
+ "base_numbering": 1,
+ "nav_menu": {},
+ "number_sections": false,
+ "sideBar": true,
+ "skip_h1_title": false,
+ "title_cell": "Table of Contents",
+ "title_sidebar": "Contents",
+ "toc_cell": false,
+ "toc_position": {},
+ "toc_section_display": true,
+ "toc_window_display": false
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/Ovinger/Oving01/Input og variable.ipynb b/Ovinger/Oving01/Input og variable.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..b33b6226589bb9443ad3a9d09fd05e094e8b54cc
--- /dev/null
+++ b/Ovinger/Oving01/Input og variable.ipynb
@@ -0,0 +1,718 @@
+{
+ "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=\"_Oving1.ipynb\">Øving 1</a>\n",
+ " </div>\n",
+ " <ul class=\"nav navbar-nav\">\n",
+ " <li><a href=\"Intro%20til%20jupyter.ipynb\">Intro til Jupyter</a></li>\n",
+ " <li ><a href=\"Jeg%20elsker%20ITGK!.ipynb\">Jeg elsker ITGK!</a></li>\n",
+ " <li ><a href=\"Kalkulasjoner.ipynb\">Kalkulasjoner</a></li>\n",
+ " <li class=\"active\"><a href=\"Input%20og%20variable.ipynb\">Input og variable</a></li>\n",
+ " <li><a href=\"Tallkonvertering.ipynb\">Tallkonvertering</a></li>\n",
+ " <li><a href=\"Peppes%20Pizza.ipynb\">Peppes Pizza</a></li>\n",
+ " <li><a href=\"Geometri.ipynb\">Geometri</a></li>\n",
+ " <li><a href=\"Vitenskapelig%20notasjon.ipynb\">Vitenskapelig notasjon</a></li>\n",
+ " <li><a href=\"Tetraeder.ipynb\">Tetraeder</a></li>\n",
+ " <li><a href=\"Bakekurs.ipynb\">Bakekurs</a></li>\n",
+ " <li ><a href=\"James%20Bond%20and%20Operation%20round().ipynb\">James Bond and Operation Round</a></li>\n",
+ " </ul>\n",
+ " </div>\n",
+ "</nav>\n",
+ "\n",
+ "# Input og variable\n",
+ "\n",
+ "**Læringsmål:**\n",
+ "\n",
+ "* Lage programmer der brukeren gir inn tekst med input()\n",
+ "\n",
+ "* Enkel bruk av variable\n",
+ "\n",
+ "* Korrekt navngivning av variable\n",
+ "\n",
+ "**Starting Out with Python:**\n",
+ "\n",
+ "* Kap. 2.2\n",
+ "\n",
+ "* Kap. 2.5-2.6"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "heading_collapsed": true
+ },
+ "source": [
+ "## **Tutorial del 1: funksjonen input()**"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "hidden": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "**Hvorfor trenger vi input?** I mange programmer er det viktig å kunne la brukeren gi input. I en nettbutikk må kunden kunne velge produkt, oppgi adresse det skal sendes til, betalingsmåte, osv.\n",
+ "\n",
+ "Input kan gis på mange måter, f.eks. via berøringsskjermer, mus, eller med stemme. Her skal du lære den måten som er lettest å programmere, nemlig input av tekst fra tastatur.\n",
+ "Dette gjøres i Python ved hjelp av funksjonen `input()`. I likhet med `print()` er dette en funksjon i Pythons standardbibliotek.\n",
+ "Kjør koden under, så ser du noen viktige forskjeller på print() og input()\n",
+ "\n",
+ "**print() og input()**"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "hidden": true
+ },
+ "outputs": [],
+ "source": [
+ "print(\"print() skriver tekst ut på skjerm og skifter linje\")\n",
+ "input(\"input() venter at du skriver noe og slår Enter: \")\n",
+ "print(\"print() kan ha\", \"mange tekster\", \"skilt med komma\")\n",
+ "input(\"input() tillater kun en tekst! OK? \")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "hidden": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Den ene teksten `input()` kan inneholde, er den såkalte **ledeteksten** som skal forklare brukeren hva slags input som forventes.\n",
+ "Ledeteksten bør være presis så brukeren vet hva slags opplysning det er spurt om. \n",
+ "F.eks. er \"Oppgi vekt i kg: \" en bedre ledetekst enn bare \"Oppgi vekt: \", som igjen er mye bedre enn \"Skriv et tall: \" eller \"Gi input: \".\n",
+ "Blankt tegn bakerst i ledeteksten er ofte en fordel, ellers kommer brukerens input kloss i ledeteksten. \n",
+ "I det lille eksemplet over brukte vi ikke resultatet fra `input()`, men vanligvis ber vi brukeren om data fordi dataen trengs til noe.\n",
+ "For noe litt mer nyttig, anta at vi ønsker å spørre brukeren om navn - og deretter benytte dette navnet i en påfølgende print-setning, så vi får en liten dialog mellom bruker og maskin:\n",
+ "\n",
+ "```\n",
+ "Hei, hva heter du? Nina \n",
+ "Nina - det var et fint navn. \n",
+ ">>>\n",
+ "```\n",
+ "\n",
+ "Her spør maskinen \"Hei, hva heter du?\", brukeren svarer \"Nina\" og maskinen skriver \"Nina - det var et fint navn.\" \n",
+ "Denne lille dialogen kan oppnås med følgende kodelinje:\n",
+ "\n",
+ "**Enkel dialog med bruker:**"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "hidden": true
+ },
+ "outputs": [],
+ "source": [
+ "print(input(\"Hei, hva heter du? \"), \"- det var et fint navn.\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "hidden": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Denne koden funker fordi parenteser alltid utføres innenfra og ut. Print-setningen kan ikke kjøres før man vet hva som skal printes,\n",
+ "Derfor må input-setningen kjøres først, den gir som resultat det navnet brukeren skriver inn (f.eks. Nina). \n",
+ "Dette navnet skrives deretter ut sammen med den påfølgende teksten \"- det var et fint navn.\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "## a) Simpel bruk av input direkte i print()-setning"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Ta utgangspunkt i tutorial-koden nedenfor (og kjør den gjerne en gang for å se hvordan den virker; hvis du ikke forstår hvordan, les først tutorial):"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "print(input(\"Hei, hva heter du? \"), \"- det var et fint navn.\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Endre tekststrengene i denne kodelinjen så dialogen med brukeren i stedet blir som vist nedenfor. Maskinen skal alltid gjenta det navnet brukeren skrev, Nina er bare et eksempel.\n",
+ "```\n",
+ "Navn? Nina \n",
+ "Nina - kult navn!\n",
+ "```\n",
+ "Legg så til en ny, lignende kodelinje som spør om brukerens favorittfag. Ved ferdig program skal dialogen se ut som nedenfor. \n",
+ "Utskriften til programmet skal selvsagt tilpasse seg det brukeren skriver inn som navn og favorittfag.\n",
+ "```\n",
+ "Navn? Per\n",
+ "Per - kult navn! \n",
+ "favorittfag? Ex.phil. \n",
+ "Ex.phil. - interessant!\n",
+ "```\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "## Tutorial del 2: variable - grunnleggende intro"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Hvorfor trenger vi variable? Poenget med variable er å **huske data underveis** i utførelsen av et program.\n",
+ "\n",
+ "Variable er derfor et sentralt konsept i programmering, ikke bare i Python men uansett hva slags språk man programmerer i.\n",
+ "\n",
+ "Uten variable støter vi fort på en rekke problemer fordi programmet vårt ikke kan huske noe, f.eks. at\n",
+ "\n",
+ "* vi må be brukeren gi inn opplysninger på nytt som brukeren har gitt tidligere\n",
+ "* vi må regne ut på nytt data vi allerede har regnet ut tidligere\n",
+ "\n",
+ "Dette sløser tid og strøm og vil i mange tilfeller gjøre programmet fullstendig ubrukelig.\n",
+ "\n",
+ "I det lille eksempelprogrammet i tutorial del 1 klarte vi oss uten noen variabel, fordi navnet vi innhentet fra bruker kun ble benyttet én gang, og dette skjedde umiddelbart etter at det var tastet inn.\n",
+ "\n",
+ " \n",
+ "```python \n",
+ "print(input(\"Hei, hva heter du? \"), \"- det var et fint navn.\") \n",
+ "```\n",
+ "\n",
+ " \n",
+ "```\n",
+ "Hei, hva heter du? Nina \n",
+ "Nina - det var et fint navn. \n",
+ ">>>>\n",
+ "```\n",
+ "\n",
+ "Men ofte skal samme data brukes flere ganger, og etter at vi har gjort andre ting i mellomtiden. Da må data huskes i variable. Anta at vi ønsker en bare litt mer avansert dialog med brukeren:\n",
+ "\n",
+ " \n",
+ "```\n",
+ "Hei, hva heter du? Nina \n",
+ "Nina - det var et fint navn. \n",
+ "Lykke til med ITGK, Nina! \n",
+ ">>>>\n",
+ "```\n",
+ "\n",
+ "Her vil vi bruke det innleste navnet i to påfølgende print-setninger. Hvis vi prøver samme triks som tidligere med å sette input-setning direkte i print-setning, får vi koden:\n",
+ "\n",
+ " \n",
+ "```python\n",
+ "print(input(\"Hei, hva heter du? \"), \"- det var et fint navn.\")\n",
+ "print(\"Lykke til med ITGK,\", input(\"Hei, hva heter du?\")) \n",
+ "```\n",
+ "\n",
+ "Kjøring viser hva som er dumt med denne koden, nemlig at spørsmålet \"Hei, hva heter du?\" kommer to ganger.\n",
+ "\n",
+ "\n",
+ "```\n",
+ "Hei, hva heter du? Nina \n",
+ "Nina - det var et fint navn. \n",
+ "Hei, hva heter du? Nina \n",
+ "Lykke til med ITGK, Nina\n",
+ "```\n",
+ "\n",
+ "Ikke noe katastrofalt problem her, men tenk deg et program hvor samme opplysning skal brukes 100 ganger eller mer i en kritisk arbeidsoppgave som haster.\n",
+ "\n",
+ "Kan vi løse det på en bedre måte? JA - med en variabel for å huske navnet. Koden blir da"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "navn = input(\"Hei, hva heter du?\" )\n",
+ "print(navn, \"- det var et fint navn.\")\n",
+ "print(\"Lykke til med ITGK,\", navn)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Dette programmet kan forklares som følger:\n",
+ "\n",
+ "* linje 1, til høyre for `=` : bruker `input()` for å spørre hva brukeren heter\n",
+ "* linje 1, til venstre for `=`: oppretter en variabel som heter `navn`.\n",
+ "* linje 1, tegnet `=`. Dette er **tilordningsoperatoren**. Betyr at verdien av uttrykket på høyre side, resultatet av `input()`, blir husket i variabelen kalt `navn`. Hvis brukeren skriver Nina, vil variabelen `navn` da inneholde strengen `'Nina'`\n",
+ "* linje 2, variabelen `navn` brukes fremst i print-setningen. Merk at variabelnavnet **ikke** skal ha fnutter rundt seg. Med fnuttter ville vi i stedet ha skrevet \"navn - det var et fint navn\". Ordet navn som står bakerst i setningen \"det var et fint navn.\" er ikke variabelen, her er ordet navn bare del av en tekststreng.\n",
+ "* linje 3, variabelen `navn` brukes bakerst i print-setningen. Igjen uten fnutter; det er ikke ordet navn vi ønsker å skrive, men den tekststrengen som variabelen `navn` inneholder (f.eks. Nina)\n",
+ "\n",
+ "Ved hjelp av variabelen som her ble kalt navn, unngår vi å stille samme spørsmål to ganger. Vi spør bare én gang, i starten av programmet, og husker da opplysningen brukeren gir oss ved å putte den inn i en variabel.\n",
+ "\n",
+ "Videre i programmet kan vi benytte denne variabelen hver gang vi trenger navnet - enten det som her var bare to ganger, eller om det hadde vært flere."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "## b) Huske input i variable"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Kjør koden under for å se hvordan den virker. Som du vil se, plager den brukeren med å gjenta begge spørsmålene to ganger.\n",
+ "\n",
+ "Forbedre koden ved å introdusere en variabel for navn og en annen variabel for favorittfag, slik at brukeren får hvert av spørsmålene bare en gang (dvs. spørres kun en gang om navn og kun en gang om favorittfag).\n",
+ "\n",
+ "Hvis du er i tvil om hvordan du skal angripe problemet, se lignende eksempel i tutorial like over."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "print(\"Hei,\", input(\"Navn? \"))\n",
+ "print(input(\"Favorittfag? \"), \"- interessant!\")\n",
+ "print(\"Ha en fin dag,\", input(\"Navn? \"))\n",
+ "print(\"- og lykke til med\", input(\"Favorittfag? \"))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Hvis du får til å bruke de to variablene som tenkt, skal kjøringen av det forbedrede programmet se slik ut (men også funke om brukeren skriver inn noe annet enn Ada på spørsmålet Navn? og noe annet enn ITGK på Favorittfag?)\n",
+ "\n",
+ "```\n",
+ "Navn? Ada \n",
+ "Hei, Ada \n",
+ "Favorittfag? ITGK \n",
+ "ITGK - interessant! \n",
+ "Ha en fin dag, Ada \n",
+ "- og lykke til med ITGK\n",
+ "```"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "heading_collapsed": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "## Tutorial del 3 - bruk av variable i beregninger"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "hidden": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Variable brukes ikke bare i sammenheng med `input()`, men i alle mulige slags program. I matematiske beregninger skal resultatet av en beregning ofte brukes videre i nye beregninger. Da må disse tallene huskes i variable. \n",
+ "Koden under viser samme eksempel gjort på to måter, nemlig utregning av areal for en sirkel, samt volum for en sylinder som har denne sirkelen som grunnflate. Versjon 1 er gjort uten variable, mens Versjon 2 bruker variable.\n",
+ "\n",
+ "**Sirkel og sylinder**"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "hidden": true
+ },
+ "outputs": [],
+ "source": [
+ "import math\n",
+ " \n",
+ "# VERSJON 1, uten variable\n",
+ "print(\"Areal av sirkelen:\", math.pi * 5.4**2)\n",
+ "print(\"Volum av sylinderen:\", math.pi * 5.4**2 * 7.9)\n",
+ " \n",
+ "print()\n",
+ " \n",
+ "# VERSJON 2, med variable\n",
+ "r = 5.4 # radius for en sirkel\n",
+ "A_sirkel = math.pi * r**2\n",
+ "print(\"Areal av sirkelen:\", A_sirkel)\n",
+ "h = 7.9 # høyde sylinder hvor sirkelen er grunnflate\n",
+ "V_syl = A_sirkel * h\n",
+ "print(\"Volum av sylinderen:\", V_syl)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "hidden": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Hvis du kjører koden, vil du se at begge gir samme resultat. Hva er da forskjellen?\n",
+ "\n",
+ "* Versjon 2 er vesentlig lenger (6 kodelinjer, mot bare 2) fordi det brukes ekstra linjer på variable. Lenger kode er en mulig ulempe. MEN:\n",
+ "* Formlene i Versjon 2 er lettere å forstå fordi det er intuitive navn som `r`, `h`, `A_sirkel` heller enn bare tall direkte.\n",
+ "* Koden i V2 er mer fleksibel for å kjapt endre verdier. Hvis radius skal byttes fra 5.4 til 6.2 må dette tallet bare endres ett sted i V2, mens flere i V1.\n",
+ "* Versjon 1 utfører **5 operasjoner** av type `*` og `**`, mens Versjon 2 bare utfører ***3***. Dette fordi Versjon 2 husker arealet i A_sirkel og deretter kan bruke dette, mens Versjon 1 må regne ut `math.pi * 5.4**2` på nytt.\n",
+ "**Med færre multiplikasjoner vil VERSJON 2 spare både strøm og tid i forhold til VERSJON 1, dvs. koden utfører mindre jobb og går raskere selv om det er flere kodelinjer.**"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "## c) Bruke variable i beregninger "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Nedenfor står et program hvor vi regner ut omkrets og areal for en sirkel etter de velkjente formlene O=2πr og A = πr2. Bortsett fra de innebygde konstantene `math.pi` og `math.tau` (=2π) bruker vi ingen variable. Dette gjør at når vi skal regne ut arealet av en sylinder hvor sirkelen er grunnflate, må vi gjøre om igjen flere beregninger som vi allerede har gjort tidligere.\n",
+ "\n",
+ "Arealet av sylinderen med høyde h vil være `mOmkrets_sirkel * h + 2 * Areal_sirkel`, hvor det første leddet er arealet av sylinderveggen og det siste leddet er topp- og bunnlokket.\n",
+ "\n",
+ "***Oppgave: Endre koden ved å tilordne og deretter bruke variable for radiusen, høyden, sirkelens omkrets og areal, slik at programmet unngår å gjøre på nytt beregninger som allerede er gjort før.***"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2019-07-01T10:54:16.358742Z",
+ "start_time": "2019-07-01T10:54:16.351684Z"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "import math\n",
+ " \n",
+ "print(\"Har en sirkel med radius\", 5.4, \"som er grunnflate i en sylinder med høyde\", 7.9)\n",
+ "print(\"Omkrets av sirkelen:\", math.tau * 5.4) #tau er det samme som 2 pi\n",
+ "print(\"Areal av sirkelen:\", math.pi * 5.4**2)\n",
+ "print(\"Areal av sylinderen:\", math.tau * 5.4 * 7.9 + 2 * math.pi * 5.4 ** 2)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Resultatet av kjøring av koden skal være uendret, dvs utskrift skal bli som vist nedenfor (men hvis du vil, kan du gjerne i tillegg avrunde svarene til én desimal).\n",
+ "\n",
+ " \n",
+ "```\n",
+ "Har en sirkel med radius 5.4 som er grunnflate i en sylinder med høyde 7.9\n",
+ "Omkrets av sirkelen: 33.929200658769766\n",
+ "Areal av sirkelen: 91.60884177867838\n",
+ "Areal av sylinderen: 451.25836876163794\n",
+ "```"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "## Tutorial del 4: Navngiving av variable"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "En variabel er et navn som representerer en verdi som lagres i datamaskinens minne. Den vanligste måten å opprette en variabel på er ved en tilordningssetning:\n",
+ "\n",
+ "`variable = expression`\n",
+ "\n",
+ "I dette tilfellet er variable navnet til variabelen, mens expression er verdien. Noen regler for slike tilordningssetninger:\n",
+ "\n",
+ "* variabelen som opprettes skal alltid stå på venstre side av uttrykket, og venstre side skal kun inneholde denne variabelen, ikke noe annet\n",
+ "* høyde side kan alt fra en enkelt verdi (f.eks. et tall) eller en enkelt variabel, til mer sammensatte uttrykk som må beregnes. Hvis høyre side inneholder variable, må dette være variable som allerede er opprettet tidligere i koden.\n",
+ "* variabelnavnet må tilfredsstille følgende regler:\n",
+ " * ord som er reserverte ord i Python, f.eks. `if`, `def`, eller som er navn på standardfunksjoner som `print`, `min`, `max`, ... bør unngås som varibelnavn\n",
+ " * variabelnavn må begynne med en bokstav eller tegnet _ (understrek)\n",
+ " * kan ellers inneholde bokstaver, tall og understrek, dvs. kan f.eks. ikke inneholde blanke tegn.\n",
+ "* Python skiller mellom små og store bokstaver, så `Areal` og `areal` vil være to ulike variable.\n",
+ "\n",
+ "Det anbefales å lage variabelnavn som er intuitivt forståelige, f.eks. er `areal` et bedre navn enn `x` på en variabel som inneholder et areal. Sammensatte variabelnavn skrives typisk som pukkelord (eng.: camelCase) eller med understrek for å vise hvor ett ord slutter og det neste begynner, f.eks. `startTime`, `pricePerLiter` eller `start_time`, `price_per_liter`, siden direkte sammensetning uten noe som helst skille vil gi lange variabelnavn som blir vanskelige å lese.\n",
+ "\n",
+ "Kodeblokka under viser eksempler på variable som funker og ikke funker:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# Eksempel på tilordningssetninger som funker\n",
+ "pokemon_name = \"Tyranitar\"\n",
+ "MaxCP = 3670\n",
+ "antall = 3\n",
+ "antall = antall + 1 # høyre side regnes ut som 3+1, så 4 blir ny verdi i variabelen antall\n",
+ "resists_fighting = False\n",
+ "level42 = \"to be done\" # tall er OK i variabelnavn unntatt helt fremst\n",
+ " \n",
+ "# Eksempel på tilordninger som IKKE funker\n",
+ "1 = antall # variabelen må stå på venstre side\n",
+ "antall + 1 = antall # og v.s. kan KUN inneholde et variabelnavn, ikke et større uttrykk\n",
+ "10kamp = \"gøy\" # variabel kan ikke begynne med tall, kun bokstav eller _\n",
+ "antall = 3 # denne er OK, men se neste linje\n",
+ "antall = Antall + 1 # Python skiller mellom store og små bokstaver, Antall vil være en annen\n",
+ " # variabel og gir NameError her fordi den ikke er opprettet i en tidligere setning\n",
+ "happy hour = 20 # navn kan ikke inneholde mellomrom, burde vært happy_hour eller happyHour\n",
+ "alkohol% = 4.5 # % kan ikke brukes i variabelnavn (betyr modulo). Samme gjelder andre spesialtegn,\n",
+ " # hold deg til vanlige bokstaver og tall"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "## d) Variabelnavn"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Prøv å kjør koden under. Som du vil se, funker den ikke pga. diverse feil med variabelnavn og tilordningssetninger. Fiks feilene så programmet kjører som det skal."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "4navn = \"Per\"\n",
+ "ideal alder = 42\n",
+ "37 = kundensAlder\n",
+ "differanse = ideal alder - kundensAlder\n",
+ "print(4navn, \"er\", Differanse, \"Ã¥r unna idealalderen\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "## e) Variabel-program"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Lag et program i kodeblokka under som først lagrer navnet ditt i en variabel og alderen din i en annen variabel, for så å printe det ut med `print()`-funksjonen. Her trenger du altså ikke å bruke `input()`-funksjonen!\n",
+ "\n",
+ "Eksempel på kjøring:\n",
+ "```\n",
+ "Jeg heter Bob Bernt, og er 46 år.\n",
+ "```\n",
+ "\n",
+ "***Skriv koden din i blokka under.***"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.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
+}
diff --git a/Ovinger/Oving01/Intro til jupyter.ipynb b/Ovinger/Oving01/Intro til jupyter.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..82dc916027564868ac044a776919bccb3dae2d9c
--- /dev/null
+++ b/Ovinger/Oving01/Intro til jupyter.ipynb
@@ -0,0 +1,356 @@
+{
+ "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=\"_Oving1.ipynb\">Øving 1</a>\n",
+ " </div>\n",
+ " <ul class=\"nav navbar-nav\">\n",
+ " <li class=\"active\"><a href=\"Intro%20til%20jupyter.ipynb\">Intro til Jupyter</a></li>\n",
+ " <li><a href=\"Jeg%20elsker%20ITGK!.ipynb\">Jeg elsker ITGK!</a></li>\n",
+ " <li ><a href=\"Kalkulasjoner.ipynb\">Kalkulasjoner</a></li>\n",
+ " <li><a href=\"Input%20og%20variable.ipynb\">Input og variable</a></li>\n",
+ " <li><a href=\"Tallkonvertering.ipynb\">Tallkonvertering</a></li>\n",
+ " <li><a href=\"Peppes%20Pizza.ipynb\">Peppes Pizza</a></li>\n",
+ " <li><a href=\"Geometri.ipynb\">Geometri</a></li>\n",
+ " <li><a href=\"Vitenskapelig%20notasjon.ipynb\">Vitenskapelig notasjon</a></li>\n",
+ " <li><a href=\"Tetraeder.ipynb\">Tetraeder</a></li>\n",
+ " <li><a href=\"Bakekurs.ipynb\">Bakekurs</a></li>\n",
+ " <li ><a href=\"James%20Bond%20and%20Operation%20round().ipynb\">James Bond and Operation Round</a></li>\n",
+ " </ul>\n",
+ " </div>\n",
+ "</nav>\n",
+ "\n",
+ "# Introduksjon til Jupyter\n",
+ "\n",
+ "Hei, og velkommen til Jupyter, en annen måte å skrive kode på! Jupyter er et system som lar deg lage dokumenter som inneholder både tekst og kode på en gang. Det fine her er at du kan kjøre koden i dokumentet og se resultatet umiddelbart. Dette kan du prøve ut nå. \n",
+ "\n",
+ "**oppgave a)** Klikk på kodeblokken under og trykk `ctrl + enter` på tastaturet for å kjøre koden. (Det er også mulig å klikke på kodeblokken for så å klikke `run` i menyen på toppen)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "print(\"Velkommen til jupyter\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Som du ser kommer resultatet av koden ut rett nedenfor kodeblokken. Dette er veldig praktisk og du kan kjøre koden så mange ganger du vil! Hvis du trykker på `ctrl + enter` i kodeblokken over en gang til vil du se at tallet til venstre for kodeblokken øker. Dette tallet brukes bare som referanse og er ikke noe du trenger å tenke på til vanlig.\n",
+ "\n",
+ "Alle kodeblokker i et dokument kan endres på, og dette oppfordres på det sterkeste! Det er mye god læring i å endre kode, tenke seg til hva som skal skje og sjekke om dette faktisk skjer. Du kan for eksempel prøve å kjøre programmet under med `ctrl + enter`, gjøre et par endringer og sjekke om den nye versjonen din gjør det du hadde tenkt."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "**Oppgave b)** Endre første linje i koden under til `print(\"Dette er mitt første Jupyter-program\")`"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "print(\"Dette er et program i jupyter\") #endre denne linjen\n",
+ "print(\"Nå skal programmet stille et spørsmål\")\n",
+ "navn = input(\"Hva heter du? \")\n",
+ "print(\"Hei\", navn)\n",
+ "\n",
+ "alder = int(input(\"Hvor gammel er du? \")) # Her må du kun skrive et tall\n",
+ "print(\"Da er du\", alder + 5, \"år gammel om 5 år\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "# Variabler mellom kodeblokker"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Noe som er verdt å merke seg er at data kan eksistere mellom kodeblokkene i en Jupyter Notebook. La oss se på et eksempel. Trykk `ctrl + enter` i kodeblokken nedenfor slik at den kjører."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "message = \"Wow! Dette var kult!\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Kjør så kodeblokken nedenfor:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "print(message)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Som du ser får vi printet ut verdien av `message` selv om `message` ikke er definert i den nederste kodeblokken. Dette kan være veldig praktisk, men kan noen ganger være forvirrende. Prøv å endre på verdien til `message` (\"Wow! Dette var kult!\") i den første kodeblokken, for så å trykke `ctrl + enter` i den andre blokken.\n",
+ "\n",
+ "Som du ser er ikke `message` blitt oppdatert. Dette er fordi **vi er nødt til å kjøre kodeblokken med `message =` for at `message` skal bli oppdatert**. \n",
+ "\n",
+ "Prøv nå å kjøre kodeblokken med `message =` igjen for så å kjøre blokken med `print` på nytt. Da burde riktig melding printes.\n",
+ "\n",
+ "**Oppgave c)** Endre message til `\"Wow, Jupyter er kult!\"`, og print det ut i blokken under.\n",
+ "\n",
+ "Dette gjelder ikke bare for *variabler*, men også for *funksjoner*, som dere skal lære å bruke etterhvert. Hvis du skriver en funksjon og ønsker å bruke den i en annen kodeblokk må du kjøre kodeblokken hver gang funksjonen endres akkurat som med variabler."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "# Restarting dersom problemer skulle oppstå"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Hvis du ønsker å fjerne all output fra dokumentet og *starte på nytt* kan du trykke på `Kernel -> Restart and clear output` i menyen på toppen. Det vil komme opp en boks med en skummel rød knapp, men dette går helt fint. Å kunne restarte kan også være nyttig hvis dokumentet henger seg opp. Dette skal vi se et eksempel på nå.\n",
+ "\n",
+ "Kjør kodeblokken under to ganger uten å taste inn noe i inputfeltet som dukker opp (du må trykke på blokken igjen for å kjøre den andre gang)."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "navn = input(\"Hva heter du?\")\n",
+ "print(\"Hei,\", navn)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Dette var veldig uheldig. Nå skjer det ingenting og vi kan heller ikke kjøre andre kodeblokker i dokumentet :(\n",
+ "\n",
+ "Når en kodeblokk venter på input kan man ikke kjøre andre kodeblokker, så hvis man da prøver å kjøre andre kodeblokker vil disse bli satt på vent.\n",
+ "\n",
+ "Nå ser vi at det står `In [*]` ved flere av blokkene våre, dette betyr at de venter på andre blokker før de selv kjører, i vårt tilfelle kjørte vi input-blokken på nytt, uten å gi inn noe til forrige kjøring av blokken. Programmet venter fortsatt på input til forrige kjøring av blokken, selv om feltet er borte, som ikke er helt optimalt! Om du ikke forstår helt hva som skjer her er ikke det noe farlig. For å komme oss ut av dette kan vi restarte med `Kernel -> Restart and clear output` i toppmenyen. **Merk: Dette endrer ikke på koden du selv har skrevet.**\n",
+ "\n",
+ "**Oppgave d)** Restart notebooken med kommandoen beskrevet over."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "# Endring av tekst"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Det er også mulig å endre på teksten i et dokument ved å dobbelklikke på en tekstboks, men dette er noe du sjeldent trenger å gjøre. For å gjøre teksten «vanlig» igjen etter at du har endret trykker du her også på `ctrl + enter`.\n",
+ "\n",
+ "Jupyter bruker noe som heter markdown til formatering av tekst. Dette er ikke pensum, men hvis du ønsker å se litt på det finnes det en ganske fin oversikt (på engelsk) [her](https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet?fbclid=IwAR2PRFaYr3YAPnKBzNRpgaumRufU4WHbT6Xd-0v9EsJwxtgqxOyzLluvPOA#tables). Det er også mulig å legge til LaTeX (et tekst-format til å lage fine matteuttrykk) i jupyter-tekstbokser. Dette er heller ikke pensum.\n",
+ "\n",
+ "Hvis vi skal be dere om et tekst-svar vil vi dere se noe sånt som under. Her kan dere selv fjerne det som står inne i krokodilletegnene.\n",
+ "\n",
+ "**Oppgave e)** Endre tekstboksen under til `ITGK er gøy`. *Merk: I en tekstboks trenger man ikke skrive python-kode*"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Ditt svar:** <dobbelklikk her for å svare\\>"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "# En advarsel"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Jupyter er generelt ikke så glad i at du har samme dokument åpnet i flere faner. Hvis du har dette er det mulig at endringene du gjør i den ene fanen overskriver endringene du gjør i en annen fane, noe som kan være uheldig. Sørg derfor for at du aldri har mer enn en fane åpnet med det samme dokumentet."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "# Til slutt"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Det er mange muligheter som ligger inne i jupyter, og vi skal ikke bruke alt i dette kurset. Det er ingenting som hindrer dere fra i å finne andre jupyter-notatbøker på nettet selv hvis dere ønsker mer utfordring eller å utforske hva som er mulig.\n",
+ "\n",
+ "**Lykke til videre med jupyter!**"
+ ]
+ }
+ ],
+ "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
+}
diff --git a/Ovinger/Oving01/James Bond and Operation round().ipynb b/Ovinger/Oving01/James Bond and Operation round().ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..38b12bfa00a8c93cd12a618ac4d12efb1f746f42
--- /dev/null
+++ b/Ovinger/Oving01/James Bond and Operation round().ipynb
@@ -0,0 +1,256 @@
+{
+ "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=\"_Oving1.ipynb\">Øving 1</a>\n",
+ " </div>\n",
+ " <ul class=\"nav navbar-nav\">\n",
+ " <li><a href=\"Intro%20til%20jupyter.ipynb\">Intro til Jupyter</a></li>\n",
+ " <li ><a href=\"Jeg%20elsker%20ITGK!.ipynb\">Jeg elsker ITGK!</a></li>\n",
+ " <li ><a href=\"Kalkulasjoner.ipynb\">Kalkulasjoner</a></li>\n",
+ " <li><a href=\"Input%20og%20variable.ipynb\">Input og variable</a></li>\n",
+ " <li><a href=\"Tallkonvertering.ipynb\">Tallkonvertering</a></li>\n",
+ " <li ><a href=\"Peppes%20Pizza.ipynb\">Peppes Pizza</a></li>\n",
+ " <li ><a href=\"Geometri.ipynb\">Geometri</a></li>\n",
+ " <li ><a href=\"Vitenskapelig%20notasjon.ipynb\">Vitenskapelig notasjon</a></li>\n",
+ " <li ><a href=\"Tetraeder.ipynb\">Tetraeder</a></li>\n",
+ " <li ><a href=\"Bakekurs.ipynb\">Bakekurs</a></li>\n",
+ " <li class=\"active\"><a href=\"James%20Bond%20and%20Operation%20round().ipynb\">James Bond and Operation Round</a></li>\n",
+ " </ul>\n",
+ " </div>\n",
+ "</nav>\n",
+ "\n",
+ "# James Bond and Operation round()\n",
+ "\n",
+ "**Læringsmål:**\n",
+ "\n",
+ "* Bruk av heltallsdivisjon og modulo, konvertering av data\n",
+ "\n",
+ "* Avrunding\n",
+ "* (særlig c) Oppdeling / håndtering av strenger\n",
+ "\n",
+ "**Starting Out with Python:**\n",
+ "\n",
+ "* Kap. 2.3\n",
+ "\n",
+ "* Kap. 3.1\n",
+ "\n",
+ "* Kap. 4.2\n",
+ "\n",
+ "* Kap. 8.2"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "## a) Kjøpmannsavrunding"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "\"Kjøpmannsavrunding\" innebærer at man alltid runder opp når et tall er midt mellom to runde tall. F.eks. at 2.5 rundes til 3 og 3.5 til 4 hvis vi skal ha hele tall, og 2.25 likeledes rundes til 2.3 hvis vi skal ha en desimal. Som forklart i tutorial i oppgaven Tallkonvertering (tidligere i denne samme øvingen) bruker Pythons funksjon `round()` **ikke** kjøpmannsavrunding, men runder i stedet i partallsretning i situasjoner hvor tallet er midt mellom to alternativer. Dvs., 2.5 vil da rundes ned til 2 fordi 2 er partall, mens 3.5 rundes opp til 4. Det er fornuftige grunner til dette (unngå systematiske feil som man får hvis man alltid runder opp). I noen situasjoner - f.eks. hvis man er kjøpmann - kan det imidlertid være at man faktisk ønsker kjøpmannsavrunding.\n",
+ "\n",
+ "Oppgaven din her er å lage et program som får til kjøpmannsavrunding. Det skal be bruker om å skrive inn et desimaltall, samt ønsket antall desimaler det skal avrundes til - og så foreta denne avrundingen. Dette må da gjøres på annet vis enn å bruke Pythons `round()`-funksjon, siden du f.eks. skal runde 2.5 til 3 (hvis null desimaler) og 2.25 til 2.3 (hvis en desimal) mens `round()` ville runde nedover her. Et par eksempler på kjøring:\n",
+ "\n",
+ " \n",
+ "```python\n",
+ "Gi inn et desimaltall: 2.5 \n",
+ "Antall desimaler i avrunding: 0 \n",
+ "Avrundet til 0 desimaler: 3\n",
+ "```\n",
+ " \n",
+ "```python\n",
+ "Gi inn et desimaltall: 2.25 \n",
+ "Antall desimaler i avrunding: 1 \n",
+ "Avrundet til 1 desimal: 2.3\n",
+ " ```\n",
+ " \n",
+ "```python\n",
+ "Gi inn et desimaltall: 2500.0 \n",
+ "Antall desimaler i avrunding: -3 \n",
+ "Avrundet til -3 desimaler: 3000 \n",
+ "```\n",
+ "\n",
+ "Som eksemplet viser skal det også være mulig å gi inn negativt antall desimaler for å få grovere avrunding enn nærmeste heltall. Også da med kjøpmannsavrunding (dvs. 2500 blir 3000, ikke 2000).\n",
+ "\n",
+ "***Skriv koden din i blokka under.***"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "## b) Avrunding som unngår unøyaktig tallrepresentasjon"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Selv hvis vi er fornøyde med IEEE-standarden for avrunding (heller enn kjøpmannsavrunding), kan `round()` av og til gi overraskende resultater. F.eks.\n",
+ "\n",
+ "* `round(2.50000000000000000001)` gir 2, selv om tallet er litt nærmere 3\n",
+ "* `round(2.15, 1)` gir 2.1, selv om regelen om å gå mot partall skulle tilsi 2.2\n",
+ "\n",
+ "Begge disse og andre lignende tilfeller skyldes egentlig ikke noen feil ved `round()`-funksjonen, men problemer med selve representasjonen av tall i det binære systemet.\n",
+ "\n",
+ "2.50000000000000000001 lar seg ikke representere eksakt i maskinen, så den tar det nærmeste den får til, som her blir 2.5 - og dermed vipper `round()` ned.\n",
+ "\n",
+ "2.15 lar seg heller ikke representere eksakt (i det binære tallsystemet, selv om det kun trengs tre siffer i titallssystemet), det nærmeste maskinen får til er 2.14999999999999999999. Dermed ligger tallet ikke lenger midt imellom men litt nærmere 2.1, så avrunding vipper ned.\n",
+ "\n",
+ "Oppgaven her er å lage et program som klarer å avrunde korrekt selv med slike tall som dette. For å klare oss mest mulig med det som er undervist av pensum hittil, kan heltallsdelen og desimaldelen til tallet vi skal behandle, leses inn hver for seg. Eksempel på kjøring blir da:\n",
+ "\n",
+ " \n",
+ "```\n",
+ "Oppgi heltallsdelen av tallet (det foran punktum): 2\n",
+ "Oppgi desimaldelen av tallet (det bak punktum): 5\n",
+ "Oppgi ønsket antall desimaler i avrunding: 0\n",
+ "2.5 avrundet til 0 desimaler blir 2\n",
+ "\n",
+ "Oppgi heltallsdelen av tallet (det foran punktum): 2\n",
+ "Oppgi desimaldelen av tallet (det bak punktum): 15\n",
+ "Oppgi ønsket antall desimaler i avrunding: 1\n",
+ "2.15 avrundet til 1 desimal blir 2.2\n",
+ "\n",
+ "Oppgi heltallsdelen av tallet (det foran punktum): 2\n",
+ "Oppgi desimaldelen av tallet (det bak punktum): 500000000000000000001\n",
+ "Oppgi ønsket antall desimaler i avrunding: 0\n",
+ "2.500000000000000000001 avrundet til 0 desimaler blir 3\n",
+ "```\n",
+ "\n",
+ "Denne oppgaven går delvis utenfor det som undervist hittil i emnet.\n",
+ "\n",
+ "***Skriv koden din i blokka under.***"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "## c) Strenghåndtering"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Lag et program hvor brukeren skriver inn navnet sitt fra tastaturet etter ledeteksten \"Jeg heter:\", og la maskinen svare med setningen The name is... som vist i boksen under.\n",
+ "\n",
+ " \n",
+ "```\n",
+ "Jeg heter: James Bond\n",
+ "The name is Bond, James Bond\n",
+ "```\n",
+ "\n",
+ "Her vil du mest sannsynlig måtte benytte deg av programmeringsmekanismer som ikke er forelest ennå, enten if-setninger, løkker og strengindeksering, eller strengmetoder som `split()` med tilhørende listebehandling. Hvis du vil gjøre det ekstra vanskelig for deg selv (**VALGFRITT**, ikke nødvendig for å få godkjent), prøv å lage et program som også funker for personer med flere enn to navn (f.eks. The name is Hopper, Grace Murray Hopper), men som tar hensyn til at preposisjoner som Von, Van, De, Di er del av etternavnet (f.eks. The name is Von Neumann, John Von Neumann; The name is De Morgan, Augustus De Morgan... dog likevel bare hvis dette kommer i midten, det må fortsatt bli The name is Morrison, Van Morrison). Dessuten, hvis et navn slutter med Jr, Sr eller romertall, er det ikke det siste ordet som er etternavnet men det nest siste: The name is Northug, Petter Northug Jr; The name is Huxtable, Henry Huxtable III.\n",
+ "\n",
+ "***Skriv koden din i blokka under.***"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.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
+}
diff --git a/Ovinger/Oving01/Jeg elsker ITGK!.ipynb b/Ovinger/Oving01/Jeg elsker ITGK!.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..6262d5fb8933a407bcf38de9a56522d8488a2ac1
--- /dev/null
+++ b/Ovinger/Oving01/Jeg elsker ITGK!.ipynb
@@ -0,0 +1,527 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ },
+ "solution": "hidden"
+ },
+ "source": [
+ "<nav class=\"navbar navbar-default\">\n",
+ " <div class=\"container-fluid\">\n",
+ " <div class=\"navbar-header\">\n",
+ " <a class=\"navbar-brand\" href=\"_Oving1.ipynb\">Øving 1</a>\n",
+ " </div>\n",
+ " <ul class=\"nav navbar-nav\">\n",
+ " <li><a href=\"Intro%20til%20jupyter.ipynb\">Intro til Jupyter</a></li>\n",
+ " <li class=\"active\"><a href=\"Jeg%20elsker%20ITGK!.ipynb\">Jeg elsker ITGK!</a></li>\n",
+ " <li ><a href=\"Kalkulasjoner.ipynb\">Kalkulasjoner</a></li>\n",
+ " <li><a href=\"Input%20og%20variable.ipynb\">Input og variable</a></li>\n",
+ " <li><a href=\"Tallkonvertering.ipynb\">Tallkonvertering</a></li>\n",
+ " <li><a href=\"Peppes%20Pizza.ipynb\">Peppes Pizza</a></li>\n",
+ " <li><a href=\"Geometri.ipynb\">Geometri</a></li>\n",
+ " <li><a href=\"Vitenskapelig%20notasjon.ipynb\">Vitenskapelig notasjon</a></li>\n",
+ " <li><a href=\"Tetraeder.ipynb\">Tetraeder</a></li>\n",
+ " <li><a href=\"Bakekurs.ipynb\">Bakekurs</a></li>\n",
+ " <li ><a href=\"James%20Bond%20and%20Operation%20round().ipynb\">James Bond and Operation Round</a></li>\n",
+ " </ul>\n",
+ " </div>\n",
+ "</nav>\n",
+ "\n",
+ "# Jeg elsker ITGK!\n",
+ "\n",
+ "**Læringsmål:**\n",
+ "\n",
+ "* Printe tekst og tall til konsoll\n",
+ "\n",
+ "* Skrive et enkelt program\n",
+ "\n",
+ "**Starting Out with Python:**\n",
+ "\n",
+ "* Kap. 1.5\n",
+ "\n",
+ "* Kap. 2.2-2.4"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "heading_collapsed": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "### print() - tutorial del 1:\n",
+ "Les gjerne denne før du gjør de neste oppgavene, særlig hvis du ikke kan programmere fra før."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "hidden": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Programmer som skal brukes av mennesker, må ofte vise informasjon på skjermen. En enkel måte for dette i Python er funksjonen print().\n",
+ "\n",
+ "Nedenstående kode gir en mest mulig selvforklarende intro til print-setningen.\n",
+ "\n",
+ "**Trykk control + enter med cellen under aktiv for å kjøre koden, prøv eventuelt å endre på noe og se hva som skjer!**"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2019-06-25T13:22:53.510622Z",
+ "start_time": "2019-06-25T13:22:53.493007Z"
+ },
+ "hidden": true,
+ "scrolled": true
+ },
+ "outputs": [],
+ "source": [
+ "print('Det som skal ut på skjermen, settes inni parentesen bak print.')\n",
+ "print('Tekst må omsluttes med fnutter (apostrof)')\n",
+ "print(\"eller med dobbelfnutter (hermetegn).\")\n",
+ "print(\"Tall trenger ikke fnutter rundt seg:\")\n",
+ "print(42)\n",
+ "print('En blank linje kan printes med tom parentes:')\n",
+ "print()\n",
+ "print('Du kan printe flere ting', 'med komma mellom:', 5, 6)\n",
+ "print('Desimaltall må skrives med punktum i Python:', 3.14)\n",
+ "print('Hvis du bruker komma, tolkes det som to adskilte tall:', 3,14)\n",
+ "print('Komma inni en tekst kommer ut på skjermen: ,,,,,', 'komma', 'mellom', 'tekster gjør ikke det.')"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "hidden": true
+ },
+ "source": [
+ "Som forklaringen sier, er det **to alternative tegn** som kan brukes for å omslutte tekststrenger i Python:\n",
+ "\n",
+ "* Apostrof. På norsk PC-tastatur er den mellom Æ og Enter. På Mac på tasten til venstre for tallet 1.\n",
+ "* Hermetegn - både på PC og Mac på samme tast som tallet 2.\n",
+ "\n",
+ "Om du bruker apostrof eller hermetegn, er et spørsmål om smak og behag - bare du er konsekvent og bruker samme tegn foran og bak tekststrengen. I visse situasjoner vil ett av alternativene være å foretrekke, som forklart i del 2 av tutorialen.\n",
+ "\n",
+ "Hvis du ved et uhell får feil tegn, som bøyd apostrof eller bøyd hermetegn i stedet for rett (nøytral) apostrof og rett (nøytralt) hermetegn som det er snakk om her, vil koden din ikke funke. Hvis du f.eks. skriver Python-kode i Word, kan Word automatisk omforme hermetegn til bøyde hermetegn (som ser forskjellig ut avhengig av om det står før eller etter teksten som hermes). Dette er en av mange gode grunner til å ikke skrive Python-kode i Word - bruk en dedikert kode-editor som Jupyter, Spyder eller PyCharm."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ },
+ "solution": "hidden"
+ },
+ "source": [
+ "### a)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "**Lag et program som gir følgende utskrift til skjermen:**\n",
+ "\n",
+ "```\n",
+ "Jeg elsker ITGK!\n",
+ "```\n",
+ "\n",
+ "***Skriv koden din i boksen under.***"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "### b)\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Lag et program som bruker fire print-setninger for å skrive informasjonen nedenfor til skjermen (linje 2 skal være blank). Tallene skal skrives ut som tall, **ikke** som en del av en tekststreng omgitt av fnutter."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2019-06-25T13:03:36.211485Z",
+ "start_time": "2019-06-25T13:03:36.201649Z"
+ },
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "```python\n",
+ "Norge\n",
+ " \n",
+ " \n",
+ "Areal (kv.km): 385180\n",
+ " \n",
+ "Folketall (mill.): 5.3\n",
+ "```\n",
+ "\n",
+ "***Skriv koden din i boksen under.***"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "heading_collapsed": true,
+ "run_control": {
+ "frozen": true
+ },
+ "solution": "hidden"
+ },
+ "source": [
+ "### print() - tutorial del 2:\n",
+ "Nyttig info om fnutter i streng før oppgave c og d."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "hidden": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Koden under viser hvorfor Python har flere alternativer for fnutter rundt tekststrenger heller enn å standardisere på bare ett fast tegn for dette formålet. **Ta gjerne å endre på koden for å se hva som skjer!**"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2019-06-25T13:37:55.517387Z",
+ "start_time": "2019-06-25T13:37:55.490047Z"
+ },
+ "hidden": true
+ },
+ "outputs": [],
+ "source": [
+ "print('Hvorfor tilbys både enkle', \"og doble fnutter?\")\n",
+ "print('Jo, hvis det er doble \"fnutter\" i teksten, funker kun enkle rundt,')\n",
+ "print(\"og med enkle fnutter i teksten er'e bare doble som funker rundt.\")\n",
+ "print(\"Med samme fnutt både rundt og inni, tror Python teksten slutter midt i.\")\n",
+ "print(\"Skal du ha begge typer fnutter i teksten? Da må du ha triple fnutter rundt:\")\n",
+ "print('''Er'u gær'n? spurte \"Arne\" og lo sykt.''')\n",
+ "print(\"\"\"Trippel apostrof ' og trippel hermetegn \" funker begge deler\"\"\")\n",
+ "print(\"\"\"Triple fnutter kan også brukes\n",
+ "for tekststrenger\n",
+ "som skal gå over flere linjer.\"\"\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "### c)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "**Lag et program som skriver ut på skjermen teksten:** \n",
+ "```\n",
+ "\"Jeg elsker ITGK\" ropte studenten da 1c funket.\n",
+ "```\n",
+ "\n",
+ "Hermetegnene rundt teksten skal være med i det som kommer ut på skjermen. \n",
+ "\n",
+ "***Skriv koden i boksen under.***"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "### d)\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Lag et program som skriver ut på skjermen teksten vist under.\n",
+ "\n",
+ "Hint: For å slippe å skrive så mye, kopier teksten inn i boksen under, så trenger du bare selv å skrive print, parenteser og passende fnutter rundt teksten.\n",
+ "\n",
+ "**Tekst til oppgave d:**"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "```\n",
+ "Noen barn sto og hang ved lekeplassen.\n",
+ "Diskusjonstemaet deres var noe uventet.\n",
+ "\n",
+ "- Hvorfor heter'e \"Python\"?\n",
+ "- Var'e slanger som laget det? - Nei, Guido van Rossum.\n",
+ "- Likte slanger kanskje da? - Nei, digga \"Monty Python\".\n",
+ "- Hva er det? Et fjell?\n",
+ "- Nei, engelsk komigruppe. Begynte i '69\n",
+ "- Wow! Var'e fremdeles dinosaurer da?\n",
+ "```\n",
+ "***Skriv koden i boksen under.***"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "heading_collapsed": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "### Kommentarer i Python - tutorial del 3:\n",
+ "Nyttig info før oppgave e"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "hidden": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Kommentarer er en annen nyttig ting når vi skriver kode. Det brukes mest for din egen del, i tillegg til andre som skal tyde koden, ettersom det gjør koden mer oversiktlig. Det er blant annet veldig nyttig viss du eller andre skal se gjennom kode i etterkant. Kommentarer ignoreres av programmet når koden kjører, så hva du skriver i en kommentar påvirker ikke koden. Kommentarer lages ved å sette en hashtag(#) foran det du ønsker å skrive. Prøver du å kjøre koden under vil du få en feil. **Prøv å rette opp koden!**"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2019-06-25T13:30:57.214061Z",
+ "start_time": "2019-06-25T13:30:57.200831Z"
+ },
+ "hidden": true
+ },
+ "outputs": [],
+ "source": [
+ "# Dette er en kommentar!\n",
+ "Dette er ikke en kommentar. Mangler #."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "### e)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Legg til to kommentarer i koden din fra b) og c) hvor du forklarer hva som ble gjort i hver av oppgavene. Legg også til kommentaren `print('Hei\")` i en av deloppgavene.\n",
+ "\n",
+ "Merk at dersom du hadde skrevet print('Hei\") i koden ville ikke koden kjørt. Dette skyldes at det først blir brukt en enkel fnutt og deretter en dobbel fnutt. Så lenge dette er skrevet i en kommentar slik det ble gjort i e) vil det ikke påvirke koden og alt går fint. "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "### f)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Koden i kodeblokken under kjører ikke pga. syntaksfeil i alle print-funksjonene. Din oppgave er å rette opp i feilene slik at koden kjører."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "print(\"Heihei, jeg vil visst ikke kompilere jeg :(')\n",
+ "print(\"Halla, så \"bra\" du ser ut i dag\")\n",
+ "print(Hei på deg)\n",
+ "print \"Er ikke dette gøy?\")"
+ ]
+ }
+ ],
+ "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
+}
diff --git a/Ovinger/Oving01/Kalkulasjoner.ipynb b/Ovinger/Oving01/Kalkulasjoner.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..c6a4edbddf73d6b5b69329a6867785218dbeb9ff
--- /dev/null
+++ b/Ovinger/Oving01/Kalkulasjoner.ipynb
@@ -0,0 +1,559 @@
+{
+ "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=\"_Oving1.ipynb\">Øving 1</a>\n",
+ " </div>\n",
+ " <ul class=\"nav navbar-nav\">\n",
+ " <li><a href=\"Intro%20til%20jupyter.ipynb\">Intro til Jupyter</a></li>\n",
+ " <li ><a href=\"Jeg%20elsker%20ITGK!.ipynb\">Jeg elsker ITGK!</a></li>\n",
+ " <li class=\"active\"><a href=\"Kalkulasjoner.ipynb\">Kalkulasjoner</a></li>\n",
+ " <li><a href=\"Input%20og%20variable.ipynb\">Input og variable</a></li>\n",
+ " <li><a href=\"Tallkonvertering.ipynb\">Tallkonvertering</a></li>\n",
+ " <li><a href=\"Peppes%20Pizza.ipynb\">Peppes Pizza</a></li>\n",
+ " <li><a href=\"Geometri.ipynb\">Geometri</a></li>\n",
+ " <li><a href=\"Vitenskapelig%20notasjon.ipynb\">Vitenskapelig notasjon</a></li>\n",
+ " <li><a href=\"Tetraeder.ipynb\">Tetraeder</a></li>\n",
+ " <li><a href=\"Bakekurs.ipynb\">Bakekurs</a></li>\n",
+ " <li ><a href=\"James%20Bond%20and%20Operation%20round().ipynb\">James Bond and Operation Round</a></li>\n",
+ " </ul>\n",
+ " </div>\n",
+ "</nav>\n",
+ "\n",
+ "# Kalkulasjoner\n",
+ "\n",
+ "**Læringsmål**:\n",
+ "\n",
+ "* Basisferdigheter, sekvensiell programmering\n",
+ "\n",
+ "* Utføre enkle kalkulasjoner\n",
+ "\n",
+ "**Starting Out with Python:**\n",
+ "\n",
+ "* Kap. 2.7\n",
+ "\n",
+ "I denne oppgaven skal du lære hvordan du skriver matematiske uttrykk for å gjøre utregninger i Python."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "heading_collapsed": true,
+ "run_control": {
+ "frozen": true
+ },
+ "solution": "hidden"
+ },
+ "source": [
+ "### Tutorial - Matteoperasjoner del 1: Vanlige operatorer, parenteser, presedens"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "hidden": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Det er mange likheter mellom Python og vanlig matematisk skrivemåte av aritmetiske uttrykk, men også noen forskjeller.\n",
+ "\n",
+ "Tabellen under oppsummerer det mest grunnleggende:\n",
+ " \n",
+ "Matematikk | Python | Merknad\n",
+ "--- | --- | ---\n",
+ "a + b | a + b | Det er vanlig å sette et mellomrom på hver side av + men ikke påkrevd. <br> Kunne også ha skrevet a+b. Samme gjelder for andre regneoperatorer. <br> Smak og behag, men litt luft gjør ofte uttrykk lettere å lese.\n",
+ "a - b | a - b | Bruk det vanlige bindestrek-tegnet for minus\n",
+ "a · b |a * b| Bruk stjerntegn (asterisk) for multiplikasjon\n",
+ "ab|<span style=\"color:red\">**NEI**</span>| I Python må gangetegn **alltid** skrives eksplisitt, kan ikke utelates\n",
+ "a : b|a / b|Vanlig skråstrek brukes for divisjon, **ikke** kolon eller horsintal brøkstrek.\n",
+ "a<sup>b</sup>|a ** b| Dobbel stjerne for potens. De to stjernene må stå kloss inntil hverandre.\n",
+ "[(a + b) * c - d]|((a + b) * c - d)|I matematisk notasjon brukes av og til ulike parentessymboler () [] {} <br> hvis det er uttrykk med flere nivåer av parenteser nøstet inn i hverandre. <br> I Python må vanlig parentes () brukes for **alle** nivåer. [] og {} har en annen betydning.\n",
+ "\n",
+ "**Presedens** mellom operatorer fungerer som i matematikken.\n",
+ "\n",
+ "* Multiplikasjon og divisjon har høyere presedens enn addisjon og subtraksjon.\n",
+ " * 3 + 2 * 5 blir 13, fordi * gjøres før +.\n",
+ " * 5 - 1 / 2 blir 4.5, fordi / gjøres før -.\n",
+ "* Potens har høyere presedens enn multiplikasjon og divisjon.\n",
+ " * 5 * 2 ** 3 blir 40, fordi ** gjøres før *.\n",
+ "* Parenteser kan brukes for å få en annen rekkefølge på regneoperasjonene:\n",
+ " * (3 + 2) * 5 blir 25, fordi + gjøres før *.\n",
+ " * (5 - 1) / 2 blir 2, fordi - gjøres før /.\n",
+ " * (5 * 2) ** 3 blir 343, fordi * nå gjøres før **.\n",
+ "* Hvis du skal \"oversette\" et matematisk uttrykk med parenteser til Python, bruk parenteser på samme sted også i Python-koden.\n",
+ "\n",
+ "**I noen tilfeller kan du trenge ekstra parenteser i Python-koden som ikke var i det matematiske uttrykket. F.eks.:** \n",
+ "\n",
+ " $$\\frac{2-x}{2+x}$$ \n",
+ "\n",
+ "Horisontal brøkstrek viser tydelig at hele 2-x er teller og hele 3+x nevner. Med Pythons skråstrek for divisjon må man bruke parenteser her: (2 - x) / (3 + x)\n",
+ "\n",
+ " $$3^{xy+1}$$\n",
+ "\n",
+ "Opphøyet skrift viser at hele xy+1 er potensen. I Python må man skrive 3 ** (x * y + 1)."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "### a) Korrekt programmering av aritmetiske utrykk"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Fyll inn riktig Python-kode i stedet for None på samme måte som vist i de tre øverste linjene,\n",
+ "\n",
+ "Kjør deretter programmet for å se at det virker (kjør gjerne hver gang du har fullført en ny linje, så du får testet en og en)."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "print('1+2(−3) =', 1 + 2 * (-3))\n",
+ "print('[(3+5·2) + 1] : 2 =', ((3 + 5 * 2) + 1) / 2)\n",
+ "print('-3^2+5*3-7 =', -3**2 + 5 * 3 - 7)\n",
+ "#1)\n",
+ "print('5:2-4 =', None)\n",
+ "#2)\n",
+ "print('5·12+6-1 =', None)\n",
+ "#3)\n",
+ "print('3(5+2) =', None)\n",
+ "#4)\n",
+ "print('4[(5+3):2 +7] =', None)\n",
+ "#5)\n",
+ "print('(−4)^(-3)+5·(3−7:2) =', None)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Hvis du har fått det til riktig, skal utskrift til skjerm ved kjøring av programmet bli:\n",
+ "\n",
+ "**Utskrift til skjerm:**\n",
+ "```python\n",
+ "1+2(-3) = -5\n",
+ "[(3+5· 2)+1]:2 = 7.0\n",
+ "-3^2 + 5*3 - 7 = -1\n",
+ "5:2-4 = -1.5\n",
+ "5· 12+6-1 = 65\n",
+ "3(5+2) = 21\n",
+ "4[(5+3):2 +7] = 44.0\n",
+ "(-4)^(-3)+5·(3-7:2) = -2.515625\n",
+ "```"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "heading_collapsed": true,
+ "run_control": {
+ "frozen": true
+ },
+ "solution": "hidden"
+ },
+ "source": [
+ "### Tutorial - Matteoperasjoner del 2: Heltallsdivisjon og Modulo:"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "hidden": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "I tillegg til vanlig divisjon / har Python også heltallsdivisjon som skrives // og modulo som skrives med operatoren %.\n",
+ "\n",
+ "Heltallsdivisjon og modulo minner om måten du lærte divisjon på barneskolen før du hadde lært desimaltall, altså med hele tall og rest.\n",
+ "\n",
+ "Tabellen under illustrerer hvordan disse operatorene virker:\n",
+ "\n",
+ "**Utrykk i Python**|**Resultat**|**Forklaring**\n",
+ "---|---|---\n",
+ "17 / 5\t|3.4\t|Vanlig divisjon\n",
+ "17 // 5|\t3\t|Heltallsdivisjon, gir hvor mange hele ganger nevneren 5 går opp i telleren 17\n",
+ "17 % 5\t|2|\tModulo, gir resten av 17 // 5, dvs. de 2 som blir til over\n",
+ "7.75 / 2.5\t|3.1|\tVanlig divisjon\n",
+ "7.75 // 2.5\t|3.0|\tHeltallsdivisjon, gir hvor mange hele ganger nevneren 2.5 går opp i 7.75.<br> Her blir svaret et flyttall (3.0) heller enn heltallet 3, fordi teller og nevner er flyttall.\n",
+ "7.75 % 2.5\t|0.25|\tModulo, Resten av 7.75//2.5 er 0.25 fordi 2.5 * 3.0 er 7.5\n",
+ "\n",
+ "Heltallsdivisjon og modulo har en rekke nyttige bruksområder i programmering.\n",
+ "\n",
+ "Ett eksempel er regning med enheter som aggregeres på andre måter enn det typiske 10, 100, 1000, slik som 60 sekund per minutt, 60 minutt per time, 24 timer per døgn, 7 døgn per uke.\n",
+ "\n",
+ "Koden under viser hvordan // og % kan brukes til slike beregninger. Prøv å kjør den."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "hidden": true
+ },
+ "outputs": [],
+ "source": [
+ "print(215, \"sekund blir\", 215 // 60, \"minutt og\", 215 % 60, \"sekund.\")\n",
+ "print(53, \"dager blir\", 53 // 7, \"uker og\", 53 % 7, \"dager\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2019-07-01T09:01:23.971652Z",
+ "start_time": "2019-07-01T09:01:23.962336Z"
+ },
+ "deletable": false,
+ "editable": false,
+ "hidden": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Det fins også mange andre nyttige anvendelser av // og %, som vil vise seg etter hvert som vi kommer til mer avanserte problemer."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "### b) Bruk av heltallsdivisjon og modulo\n",
+ "\n",
+ "Erstatt ordet **None** i print-setningene i linje 2, 3 og 4 med uttrykk med // og % på tilsvarende måte som i linje 1, så påstandene blir riktige."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "print(355, \"minutt blir\", 355 // 60, \"timer og\", 355 % 60, \"minutt.\")\n",
+ "print(403, \"sekund blir\", None, \"minutt og\", None, \"sekund.\")\n",
+ "print(67, \"dager blir\", None, \"uker og\", None, \"dager.\")\n",
+ "print(100, \"timer blir\", None, \"døgn og\", None, \"timer.\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "**Riktig utskrift hvis du har fått det til, skal bli**\n",
+ "```\n",
+ "355 minutt blir 5 timer og 55 minutt. \n",
+ "403 sekund blir 6 minutt og 43 sekund. \n",
+ "67 dager blir 9 uker og 4 dager. \n",
+ "100 timer blir 4 døgn og 4 timer.\n",
+ "```"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "heading_collapsed": true,
+ "run_control": {
+ "frozen": true
+ },
+ "solution": "hidden"
+ },
+ "source": [
+ "### Tutorial - Matteoperasjoner del 3: Innebygde funksjoner og konstanter"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "hidden": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Python har en rekke innebygde funksjoner. Vi kan skille mellom\n",
+ "\n",
+ "* funksjoner i **standardbiblioteket**. Disse er alltid tilgjengelige og kan dermed brukes uten videre.\n",
+ "* funksjoner i **andre biblioteker**. For å kunne bruke slike funksjoner må vi importere det aktuelle biblioteket i starten av programmet.\n",
+ "\n",
+ "En fullstendig liste over funksjoner i standardbiblioteket fins [her](https://docs.python.org/3/library/functions.html).\n",
+ "\n",
+ "Noen standardfunksjoner som inngår i ulike deloppgaver på Øving 1 er print(), input(), str(), int(), float().\n",
+ "\n",
+ " Spesielt relatert til matematikk fins dessuten **abs()** for absoluttverdi og **round()** for avrunding i standardbiblioteket.\n",
+ "\n",
+ "Kodeblokken under viser bruk av noen standardfunksjoner:\n",
+ "\n",
+ "**Standardfunksjoner**"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "hidden": true
+ },
+ "outputs": [],
+ "source": [
+ "print(\"Standardfunksjoner kan brukes direkte.\")\n",
+ "print(\"Funksjonen print() viser info på skjermen.\")\n",
+ "print(\"|-3|, dvs. absoluttverdien til -3, er\", abs(-3) )\n",
+ "print(4.75, \"avrundet til helt tall er\", round(4.75) )\n",
+ "print(4.75, \"avrundet til én desimal er\", round(4.75, 1) )"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "hidden": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Noen andre biblioteker som man vil komme borti i dette emnet:\n",
+ "\n",
+ "* **math** som inneholder en rekke matematiske funksjoner, som f.eks. sin(), cos(), tan(), sqrt(), log(), gcd(), factorial(), samt noen vanlige matematiske konstanter som pi og e.\n",
+ "* **random**. som inneholder funksjoner for å generere tilfeldige tall, f.eks. random() som gir et tilfeldig tall mellom 0 og 1, og randint(a, b) for tilfeldige heltall a <= x <= b.\n",
+ "* **turtle**, som inneholder funksjoner for å tegne enkle grafiske figurer på skjermen, f.eks. circle() for å tegne en sirkel. Kan ikke brukes med Jupyter.\n",
+ "\n",
+ "Kodeblokken under viser bruk av noen funksjoner og konstanter fra math-biblioteket.\n",
+ "\n",
+ "**Math-funksjoner**"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "hidden": true
+ },
+ "outputs": [],
+ "source": [
+ "import math\n",
+ "print(\"Kvadratroten til 8 er\", math.sqrt(8) )\n",
+ "print(\"Sinus til 2 er\", math.sin(2) )\n",
+ "print(\"Største felles faktor for 18 og 12 er\", math.gcd(18, 12) )\n",
+ "print(\"Konstantene pi og e er lagret i Python som hhv.\", math.pi, \"og\", math.e)\n",
+ "print(\"Har også konstanten tau som tilsvarer 2*pi:\", math.tau)\n",
+ "print(\"En sirkel med radius 4 har areal\", math.pi * r**2, \"og omkrets\", math.tau * r)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "hidden": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Til forskjell fra standardbiblioteket må math-biblioteket importeres, jfr. setningen import math\n",
+ "\n",
+ "Hver funksjon fra math-biblioteket er også prefikset med ordet math. i kodeeksemplet over.\n",
+ "\n",
+ "Hvis du ønsker å slippe det gjentatte prefikset math foran funksjonsnavn, kan alternativ importsetning brukes:\n",
+ "\n",
+ "**Alternativ import**"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2019-07-01T09:14:10.412403Z",
+ "start_time": "2019-07-01T09:14:10.400269Z"
+ },
+ "hidden": true
+ },
+ "outputs": [],
+ "source": [
+ "from math import sqrt, sin, gcd, pi, e, tau\n",
+ "print(\"Kvadratroten til 8 er\", sqrt(8) )\n",
+ "print(\"Sinus til 2 er\", sin(2) )\n",
+ "print(\"Største felles faktor for 18 og 12 er\", gcd(18, 12) )\n",
+ "print(\"Konstantene pi og e er lagret i Python som hhv.\", pi, \"og\", e)\n",
+ "print(\"Har også konstanten tau som tilsvarer 2*pi:\", tau)\n",
+ "print(\"En sirkel med radius 4 har areal\", pi * 4**2, \"og omkrets\", tau * 4)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "hidden": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Et enda latere alternativ er å skrive **from math import *** i første linje over, * betyr da \"alt mulig\". Da slipper du å liste opp sqrt, sin, ... Ulempen vil være at du i så fall importerer alt som fins i math-biblioteket, ikke bare de få funksjonene og konstantene du faktisk bruker. I profesjonelle programmer hvor hurtighet og ryddighet vil være viktig, er det derfor ikke anbefalt å bruke **from ... import *** , men det kan være greit i små eksempler."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "### c) Bruk av innebygde funksjoner og konstanter\n",
+ "\n",
+ "Se på koden i blokken under. Legg til en passende import-setning øverst i programmet i stedet for # ??\n",
+ "\n",
+ "Bytt ut alle forekomster av **None** med bruk av innebygde funksjoner og konstanter fra standardbiblioteket og math-biblioteket, slik at svarene blir riktige.\n",
+ "\n",
+ "Dvs., der det nå står None skal det fylles inn en eller annen funksjon eller matematisk uttrykk tilsvarende det som allerede er gjort i print-setning nr 3.\n",
+ "\n",
+ "Hvis du er usikker på hvilke funksjoner og konstanter det er lurt å bruke, ta først en kikk på Tutorial like foran deloppgaven."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "\n",
+ "# ??\n",
+ "# importerer fra math-biblioteket\n",
+ " \n",
+ "print(\"|-8|, dvs. absoluttverdien til -8, er\", None)\n",
+ "print(2.544, \"avrundet til helt tall er\", None)\n",
+ "print(\"Funksjonen int() derimot bare kutter vekk desimalene:\", int(2.544) )\n",
+ "print(2.544, \"avrundet til to desimaler er\", None)\n",
+ "print(\"Kvadratroten til\", 10, \"er\", None)\n",
+ "print(\"En sirkel med radius 7 har omkrets\", None)\n",
+ "print(\"En sirkel med radius 7 har areal\", None)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "**Utskrift til skjerm**\n",
+ "``` \n",
+ "|-8|, dvs. absoluttverdien til -8, er 8 \n",
+ "2.544 avrundet til helt tall er 3 \n",
+ "Funksjonen int() derimot bare kutter vekk desimalene: 2 \n",
+ "2.544 avrundet til to desimaler er 2.54 \n",
+ "Kvadratroten til 10 er 3.1622776601683795 \n",
+ "En sirkel med radius 7 har omkrets 43.982297150257104 \n",
+ "En sirkel med radius 7 har areal 153.93804002589985\n",
+ "```"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.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
+}
diff --git "a/Ovinger/Oving01/MUSTEK-\303\230VING_1.ipynb" "b/Ovinger/Oving01/MUSTEK-\303\230VING_1.ipynb"
new file mode 100644
index 0000000000000000000000000000000000000000..1e5d33df19b8d5c8cfa60b3ef5fce0892429f0ab
--- /dev/null
+++ "b/Ovinger/Oving01/MUSTEK-\303\230VING_1.ipynb"
@@ -0,0 +1,277 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# ØVING 1"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Under ser du eksempler på ulike variabeltyper i Python. Prøv å kjøre snutten og ta en titt på hva den printer ut."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "('Python', 3, 0.7, 3.7, 'Python 3.7')\n"
+ ]
+ }
+ ],
+ "source": [
+ "#streng / string\n",
+ "var1 = \"Python\"\n",
+ "\n",
+ "#heltall / integer\n",
+ "var2 = 3\n",
+ "\n",
+ "#flyttall / float\n",
+ "var3 = 0.7\n",
+ "\n",
+ "#heltall + flyttall = flyttall\n",
+ "var4 = var2 + var3\n",
+ "\n",
+ "#konverterer flyttall til streng og slår sammen / konkatenerer til en lengre streng\n",
+ "var5 = var1 + \" \" + str(var4)\n",
+ "\n",
+ "#print out\n",
+ "print(var1,var2,var3,var4,var5)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Oppgave 1\n",
+ "\n",
+ "Skriv et enkelt program som ber brukeren om navn, lagrer dette i en variabel og printer ut en en vennlig hilsen som svar. \n",
+ "\n",
+ "Eksempel på kjøring av koden:\n",
+ "\n",
+ "Hva er navnet ditt? Anders\n",
+ "\n",
+ "Heisann, Anders! Fryktelig hyggelig å møte deg!"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Hva er navnet ditt? Anders\n",
+ "Heisann, Anders! Fryktelig hyggelig å møte deg!\n"
+ ]
+ }
+ ],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "input() og print() er eksempler på innebygde funksjoner i Python. Ved å importere bibliotek kan vi utvide Pythons funksjonalitet. Under ser du for eksempel hvordan vi kan inkludere modulen date fra datetime-biblioteket, og med det finne ut hvilket år det er i år.\n",
+ "\n",
+ "Utvid koden under til å spørre om brukerens alder, og anslå omtrentlig fødselsår. Print ut en beskjed som inneholder både brukerens navn og anslått fødselsår.\n",
+ "\n",
+ "\n",
+ "\n",
+ "\n",
+ "Eksempel på kjøring av koden:\n",
+ "\n",
+ "Hvor gammel er du, Anders? 28\n",
+ "\n",
+ "Okay, Anders! Etter mine kalkulasjoner er du født enten i 1991 eller i 1990!"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "2019\n"
+ ]
+ }
+ ],
+ "source": [
+ "from datetime import date\n",
+ "presentyear = date.today().year\n",
+ "print(presentyear)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Oppgave 2\n",
+ "\n",
+ "På planeten vår har vi et atmosfærisk trykk som ligger på 101.325 kiloPascal (kPa) ved havoverflaten og når en beveger seg oppover. All lyd som beveger seg gjennom luft er variasjoner i luftpartiklenes posisjon rundt et \"nullpunkt\" gitt av det atmosfæriske trykket - en oscillasjon skyver og trekker luftpartiklene ved sitt høy- og lavtrykk. Svingningen med lavest intensitet et menneske potensielt er i stand til å høre ligger på 20 microPascal (µPa). Dette er utgangspunktet for den logaritmiske amplitudeskalaen deciBel Sound Pressure Level (dBSPL), som har sitt laveste punkt - 0dBSPL, satt til nettopp 20µPa. Maksamplituden til en norsk konsert er satt til 90dBSPL, et lydtrykknivå som vil påføre skade om en utsettes for det over lengre tid. En jagerflymotor kan ha et lydtrykknivå opp mot 150dBSPL på én meters avstand, som medfører umiddelbar hørselsskade. \n",
+ "\n",
+ "Likningen for omregning fra Pascal til dBSPL:\n",
+ "\n",
+ "Lp(dBSPL)=20·log(10)p/p0\n",
+ "\n",
+ "hvor p0 er den lavest hørbare lufttrykksendringen (20µPa) og p er input til likningen i form av en verdi i Pacal. \n",
+ "\n",
+ "Likningen for omregning fra dBSPL til Pascal:\n",
+ "\n",
+ "p(Pa)=p0·10^Lp(dBSPL)/20\n",
+ "\n",
+ "hvor p0 fortsatt er 20µPa og Lp er input til likningen i form av en verdi i dBSPL. Disse formlene finner du i kodesnutten under. Legg merke til at vi har importert math-biblioteket som lar oss bruke mer avanserte matematiske funksjoner, slik som log10.\n",
+ "\n",
+ "I denne oppgaven skal du lage et program som spør brukeren om en amplitudeverdi i dBSPL. Denne verdien skal du putte inn i likningen som konverterer fra dBSPL til Pascal, og resultatet av denne konverteringen skal så konverteres tilbake til dBSPL. Formater de to konverterte verdiene slik at programmet printer ut Pascal-verdien som et flyttall med fem desimaler og dBSPL som kun et heltall (uten desimaler).\n",
+ "\n",
+ "\n",
+ "\n",
+ "Eksempel på kjøring:\n",
+ "\n",
+ "Amplitude i dBSPL? 50\n",
+ "\n",
+ "0.00632 Pascal\n",
+ "\n",
+ "50 dBSPL\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import math\n",
+ "amp = 50\n",
+ "pascal = 0.00002*(10**(int(amp)/20))\n",
+ "dbspl = 20*math.log10(pascal/0.00002)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "En fin kilde for å undersøke temaet videre finner du her: http://www.sengpielaudio.com/calculator-soundlevel.htm"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Oppgave 3\n",
+ "\n",
+ "En sinusbølge kan forstås som en sirkulær bevegelse hvor en gitt grad mellom 0 og 360 representerer et punkt i bølgen - et utsving gitt i en amplitudeverdi. Om en sinustone blir gitt en relativ amplitude på 1 vil for eksempel 0° tilsvare startpunktet og ha en amplitude på 0, 90° tilsvarer maksimalt positivt utsving og har en verdi på 1, mens 270° tilsvarer maksimalt negativt utsving og har en verdi på -1. Denne gradverdien kan også leses som bølgens fase.\n",
+ "\n",
+ "Likningen for amplitudeverdien på en gitt grad i en sinusbølge er som følger:\n",
+ "\n",
+ "A=dB·sin(w·t+phase)\n",
+ "\n",
+ "hvor w=2piFREKVENS. \n",
+ "\n",
+ "Ta utgangspunkt i koden fra oppgave 1 og utvid med å la brukeren sjekke utsvinget på ulike punkter (0-360) i en sinusbølge med amplitude gitt av input fra oppgave 1. Resultatet skal printes som et flyttall med to desimaler rundet opp eller ned til andre desimalplass. Programmet skal også printe en absolutt prosentverdi for målepunktets utsving fra nullpunktet, hvor 100% tilsvarer den maksimale amplituden gitt som input."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "degree = 72\n",
+ "y = dbspl * math.sin(math.radians(degree))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Se mer om temaet her: http://www.sengpielaudio.com/calculator-timedelayphase.htm"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Oppgave 4 \n",
+ "\n",
+ "Turtle er et Python-library som lar deg tegne enkle illustrasjoner med Python. I koden under ser du et eksempel på Turtle-kode som først plotter et koordinatsystem og så en sirkel inn i det. Endre de tre variablene du finner øverst i koden, slik at fase- og amplitude-informasjon fra oppgave 3 vises grafisk."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import turtle\n",
+ "\n",
+ "\n",
+ "radius = 180\n",
+ "vinkel = 300\n",
+ "amplitude = 177.94\n",
+ "\n",
+ "\n",
+ "turtle.hideturtle()\n",
+ "turtle.screensize(radius*3,radius*3)\n",
+ "turtle.pensize(1)\n",
+ "turtle.color('black')\n",
+ "turtle.setheading(-90)\n",
+ "turtle.forward(radius)\n",
+ "turtle.backward(radius*2)\n",
+ "turtle.home()\n",
+ "turtle.backward(radius)\n",
+ "turtle.forward(radius*2)\n",
+ "\n",
+ "turtle.color('green')\n",
+ "turtle.setheading(90)\n",
+ "turtle.circle(radius)\n",
+ "\n",
+ "turtle.color('red')\n",
+ "turtle.home()\n",
+ "turtle.setheading(degree)\n",
+ "turtle.forward(radius)\n",
+ "\n",
+ "turtle.penup()\n",
+ "turtle.color('blue')\n",
+ "turtle.write(str(degree)+'° = ',True)\n",
+ "turtle.write(round(amplitude,2),True)\n",
+ "turtle.write('dBFS',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"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/Ovinger/Oving01/Peppes Pizza.ipynb b/Ovinger/Oving01/Peppes Pizza.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..d6e99b4ac5538289497ec6795e1aba710a4e5a81
--- /dev/null
+++ b/Ovinger/Oving01/Peppes Pizza.ipynb
@@ -0,0 +1,305 @@
+{
+ "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=\"_Oving1.ipynb\">Øving 1</a>\n",
+ " </div>\n",
+ " <ul class=\"nav navbar-nav\">\n",
+ " <li><a href=\"Intro%20til%20jupyter.ipynb\">Intro til Jupyter</a></li>\n",
+ " <li ><a href=\"Jeg%20elsker%20ITGK!.ipynb\">Jeg elsker ITGK!</a></li>\n",
+ " <li ><a href=\"Kalkulasjoner.ipynb\">Kalkulasjoner</a></li>\n",
+ " <li><a href=\"Input%20og%20variable.ipynb\">Input og variable</a></li>\n",
+ " <li><a href=\"Tallkonvertering.ipynb\">Tallkonvertering</a></li>\n",
+ " <li class=\"active\"><a href=\"Peppes%20Pizza.ipynb\">Peppes Pizza</a></li>\n",
+ " <li><a href=\"Geometri.ipynb\">Geometri</a></li>\n",
+ " <li><a href=\"Vitenskapelig%20notasjon.ipynb\">Vitenskapelig notasjon</a></li>\n",
+ " <li><a href=\"Tetraeder.ipynb\">Tetraeder</a></li>\n",
+ " <li><a href=\"Bakekurs.ipynb\">Bakekurs</a></li>\n",
+ " <li ><a href=\"James%20Bond%20and%20Operation%20round().ipynb\">James Bond and Operation Round</a></li>\n",
+ " </ul>\n",
+ " </div>\n",
+ "</nav>\n",
+ "\n",
+ "# Peppes Pizza\n",
+ "\n",
+ "**Læringsmål:**\n",
+ "\n",
+ "* Gjøre enkle kalkulasjoner i python\n",
+ "* Skrive et enkelt program\n",
+ "\n",
+ "**Starting Out with Python:**\n",
+ "\n",
+ "* Kap. 2\n",
+ "\n",
+ "Du har nettopp spist middag på Peppes Pizza med noen venner, og mottar denne kvitteringen:\n",
+ "\n",
+ " \n",
+ "```python\n",
+ "Pizza: 750kr\n",
+ "Studentrabatt: 20%\n",
+ "Tips: 8%\n",
+ "```"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "## a)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Lag et program som lagrer verdiene fra regningen i variabler. Variablene skal altså være `Pizza`, `Studentrabatt` og `Tips`.\n",
+ "\n",
+ "***Skriv koden i blokken under***"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "heading_collapsed": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "#### Eksempel på lignende tilfelle"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "hidden": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Bob Bernt var på kino i helgen og mottok denne regningen:\n",
+ "\n",
+ "**Regning fra Prinsen kino:**\n",
+ " \n",
+ "```python\n",
+ "Kinobillett: 125kr\n",
+ "Popcorn: 70kr\n",
+ "Brus: 25kr\n",
+ "Rabatt = 10%\n",
+ "```\n",
+ "\n",
+ "I programmet under er verdiene fra regningen blitt lagret i variablene `Kinobillett`, `Popcorn` og `Brus`.\n",
+ "\n",
+ "**Kode:**\n",
+ "\n",
+ " \n",
+ "```python\n",
+ "Kinobillett = 125\n",
+ "Popcorn = 70\n",
+ "Brus = 25\n",
+ "Rabatt = 0.10\n",
+ "```"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "## b)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Lag en variabel `totalt` som er lik den totale summen av middagen. Du kan skrive i samme kodeblokk som oppgave a."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "heading_collapsed": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "#### Eksempel på lignende tilfelle"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "hidden": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Tar utgangspunkt i regningen fra Prinsen kino som Bob Bernt fikk under Eksempel på lignende tilfelle under oppgave a. For å regne ut den totale summen kan dette gjøres på følgende måte:\n",
+ "\n",
+ " \n",
+ "```python\n",
+ "Total = (Kinobillett + Brus + Popcorn) * (1-Rabatt)\n",
+ "```"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "## c) "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Gjør slik at brukeren kan skrive inn hvor mange som deltok på middagen, og print ut hvor mye hver person må betale.\n",
+ "\n",
+ "**Eksempel på kjøring:**\n",
+ "\n",
+ " \n",
+ "```python\n",
+ "Total pris: 648.0\n",
+ "Hvor mange deltok på middagen? 6\n",
+ "Ettersom dere var 6 personer, så må hver person betale 108.0 kroner.\n",
+ "```\n",
+ "\n",
+ "***Skriv koden i blokken under***"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "heading_collapsed": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "### Hint"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "hidden": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "For at man skal bruke input i beregninger må den gjøres om til en int."
+ ]
+ }
+ ],
+ "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
+}
diff --git a/Ovinger/Oving01/Tallkonvertering.ipynb b/Ovinger/Oving01/Tallkonvertering.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..65a8f1f42011eed855a3f5338c4c7fd0a08bc56d
--- /dev/null
+++ b/Ovinger/Oving01/Tallkonvertering.ipynb
@@ -0,0 +1,495 @@
+{
+ "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=\"_Oving1.ipynb\">Øving 1</a>\n",
+ " </div>\n",
+ " <ul class=\"nav navbar-nav\">\n",
+ " <li><a href=\"Intro%20til%20jupyter.ipynb\">Intro til Jupyter</a></li>\n",
+ " <li ><a href=\"Jeg%20elsker%20ITGK!.ipynb\">Jeg elsker ITGK!</a></li>\n",
+ " <li ><a href=\"Kalkulasjoner.ipynb\">Kalkulasjoner</a></li>\n",
+ " <li><a href=\"Input%20og%20variable.ipynb\">Input og variable</a></li>\n",
+ " <li class=\"active\"><a href=\"Tallkonvertering.ipynb\">Tallkonvertering</a></li>\n",
+ " <li><a href=\"Peppes%20Pizza.ipynb\">Peppes Pizza</a></li>\n",
+ " <li><a href=\"Geometri.ipynb\">Geometri</a></li>\n",
+ " <li><a href=\"Vitenskapelig%20notasjon.ipynb\">Vitenskapelig notasjon</a></li>\n",
+ " <li><a href=\"Tetraeder.ipynb\">Tetraeder</a></li>\n",
+ " <li><a href=\"Bakekurs.ipynb\">Bakekurs</a></li>\n",
+ " <li ><a href=\"James%20Bond%20and%20Operation%20round().ipynb\">James Bond and Operation Round</a></li>\n",
+ " </ul>\n",
+ " </div>\n",
+ "</nav>\n",
+ "\n",
+ "# Tallkonvertering\n",
+ "\n",
+ "**Læringsmål:**\n",
+ "\n",
+ "* Konvertering mellom datatyper med standardfunksjoner som int() og float()\n",
+ "\n",
+ "* Forstå definisjonen av heltall og flyttall\n",
+ "\n",
+ "**Starting Out with Python:**\n",
+ "\n",
+ "* Kap. 2.6\n",
+ "\n",
+ "* Kap. 2.8"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "heading_collapsed": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "## Tutorial del 1: Konvertering mellom datatyper"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "hidden": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Vi kan ha ulike typer data, som tekststrenger (f.eks. `\"Python\"`), heltall (f.eks. `42`), flyttall (f.eks. `9.80`) og sannhetsverdier (`True`, `False`). Ofte kommer vi i situasjoner hvor vi har data av en viss type, men vi trenger samme data bare med en annen type. Da må vi konvertere dataene. Noen vanlige konverteringsfunksjoner:\n",
+ "\n",
+ "**`int()`** - konverterer til heltall.\n",
+ "- `int('423')` gir 423 (dvs. tekststrengen blir konvertert til et tall). Virker kun hvis tekststrengen faktisk inneholder et heltall.\n",
+ "- `int(5.69)` gir 5 (dvs. for flyttall blir desimaldelen fjernet)\n",
+ "\n",
+ "**`float()`** - konverterer til flyttall\n",
+ "- `float('5.69')` gir 5.69 (tekststreng konvertert til tall)\n",
+ "- `float('5')` gir 5.0, dvs. float() virker på tekststrenger enten de inneholder flyttall eller heltall (men ikke på strenger som er noe annet enn tall)\n",
+ "- `float(5)` gir 5.0\n",
+ "\n",
+ "**`str()`** - konverterer til tekststreng\n",
+ "- `str(42)` gir '42'\n",
+ "- `str(5.69)` gir '5.69'\n",
+ "Koden under feiler fordi vi har glemt å konvertere. Kjør den og se hva som skjer."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "hidden": true
+ },
+ "outputs": [],
+ "source": [
+ "alder = input(\"Hvor gammel er du?\")\n",
+ "alder_mor = input(\"Hvor gammel er din mor?\")\n",
+ "sum_alder = alder + alder_mor\n",
+ "print(\"Gratulerer, til sammen er dere\", sum_alder, \"Ã¥r!\")\n",
+ "svar = input(\"Hva syns dere om å være \", sum_alder, \"? \")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "hidden": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Et eksempel på kjøring kan være som følger:\n",
+ " \n",
+ " \n",
+ "```python\n",
+ "Hvor gammel er du? 13\n",
+ "Hvor gammel er din mor? 37\n",
+ "Gratulerer, til sammen er dere 1337 år!\n",
+ "Traceback (most recent call last):\n",
+ " File \"/Users/guttorm/Documents/tut2.py\", line 5, in <module>\n",
+ " svar = input(\"Hva syns dere om å være \", sum_alder, \"? \")\n",
+ "TypeError: input expected at most 1 arguments, got 3\n",
+ ">>>\n",
+ "```\n",
+ "\n",
+ "Den første feilen viser seg i linjen \"Gratulerer...\" Summen skulle ha blitt 50 år. Men vi har de to alderne fortsatt bare lagret som tekststrenger. Da betyr `+` å hekte sammen strengene, ikke å gjøre noen addisjon. Altså får vi `'13' + '37'` som blir `'1337'` heller enn `13 + 37` som blir `50`. Her måtte vi ha konvertert fra tekst til tall før vi gjorde addisjonen.\n",
+ "\n",
+ "Den andre feilen oppstår i input-setninga. I `print()` er det lov å liste opp mange argumenter, både tekst og tall, med komma mellom. I en `input()` er det bare lov å ha ett argument, som må være en tekststreng (ledeteksten). Som det sies i feilmeldinga: \"input expected at most 1 arguments, got 3\". For å klare oss med bare ett argument - men samtidig få stilt det spørsmålet vi ønsker (\"Hva syns dere om å være 50?\" hvis summen var 50) - må vi plusse sammen delene til én tekststreng heller enn å ha delene skilt med komma. `input(\"Hva syns dere om å være\" + sum_alder + \"? \")` vil imidlertid ikke funke hvis sum_alder er et tall, for å det går ikke å plusse sammen tekst og tall. To tekster kan derimot godt plusses sammen (som vi nettopp så med `'1337'`). Hvis vi konverterer `sum_alder` til tekst, vil det funke. Fikset kode vist under:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "hidden": true
+ },
+ "outputs": [],
+ "source": [
+ "alder = int(input(\"Hvor gammel er du?\"))\n",
+ "alder_mor = int(input(\"Hvor gammel er din mor?\"))\n",
+ "sum_alder = alder + alder_mor\n",
+ "print(\"Gratulerer, til sammen er dere\", sum_alder, \"Ã¥r!\")\n",
+ "svar = input(\"Hva syns dere om å være \" + str(sum_alder) + \"? \")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "hidden": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Altså: bruker `int()` i linje 1 og 2, dette gjør at vi får heltall i variablene `alder` og `alder_mor` så vi blir i stand til å regne med dem. Bruker deretter `str()` i linje 5 så denne opplysningen kan settes sammen med annen tekst og brukes i ledeteksten til en ny `input()`. Dette eksemplet viser dermed både et tilfelle hvor vi har tekst men trenger tall, og ett hvor vi har et tall men trenger tekst. Hvis det er aktuelt at brukeren skriver inn desimaltall på alder (f.eks. `13.5`) vil imidlertid koden over ikke funke. Da måtte vi ha brukt funksjonen `float()` der vi nå har brukt `int()`."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "## a)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Be brukeren om å skrive inn 3 flyttall. Konverter først strengene til flyttall med `float()`, bruk så `int()` til å konvertere dem til heltall. Be også brukeren om å skrive inn et heltall og bruk `float()` til å konvertere tallet til et desimaltall."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Eksempel på utskrift fra programmet hvis du får til det til å funke:\n",
+ "\n",
+ "\n",
+ "```python\n",
+ "Skriv inn et flyttall: 4.232443\n",
+ "Skriv inn enda et flyttall: 3.24324\n",
+ "Skriv inn et siste flyttall: 1.22342454\n",
+ "Konvertert til heltall blir det: 4 3 1\n",
+ "Skriv inn et heltall: 13\n",
+ "Konvertert til flyttall blir det: 13.0\n",
+ "```\n",
+ "\n",
+ "***Skriv koden din i blokka under:***"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2019-07-01T11:24:13.550825Z",
+ "start_time": "2019-07-01T11:24:13.542723Z"
+ }
+ },
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "heading_collapsed": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "#### Hint"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "hidden": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Hver gang du skal be brukeren om noe benyttes `input()`. Husk å ha det i en `int()` dersom det er et heltall du ber om og `float()` dersom det er et flyttall. En tekststreng som inneholder et flyttall, f.eks. `\"4.325\"`, kan ikke konverteres direkte til heltall. Dvs., `int(\"4.325\")` vil gi feilmelding. Hvis du får en slik streng og egentlig ønsker int, må du først konvertere fra streng til float, deretter fra float til int."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "## b)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Skriv et program som ber brukeren oppgi navn og alder, samt hvor gammel vedkommende var da han/hun begynte å programmere. Et eksempel på kjøring er vist nedenfor, hvor *Martin, 21*, *19* og *Ja* bakerst i linjene 1, 2, 3 og 5 skrives av brukeren mens resten skrives av maskinen. Lag programmet slik at det tilpasser seg dataene som skrives inn. (Særlig for denne deloppgaven lønner det seg å se på tutorial lenger oppe hvis du ikke får den til)\n",
+ "\n",
+ "Eksempel på kjøring:\n",
+ " \n",
+ "```\n",
+ "Skriv ditt navn: Martin\n",
+ "Hei, Martin, hvor gammel er du? 21\n",
+ "Hvor gammel var du da du begynte å programmere? 19\n",
+ "Da har du programmert i 2 år.\n",
+ "Syns du de 2 årene har vært givende? Ja\n",
+ "Takk for svar, Martin!\n",
+ "```\n",
+ "\n",
+ "***Skriv koden din i blokka under.***"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "heading_collapsed": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "## Tutorial del 2: int() vs. round()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "hidden": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Ofte har man flyttall, men trenger heltall, f.eks. hvis man skal bruke innebygde Python-funksjoner som krever heltall som argument, eller skal bruke tallet som indeks til en streng eller liste (som vi vil se senere i pensum). Flyttall kan konverteres til heltall med funksjoner som `int()` eller `round()`. Kodeblokka under viser litt forskjell på hvordan disse virker."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "hidden": true
+ },
+ "outputs": [],
+ "source": [
+ "print(\"int() bare kutter desimalene, uansett hvor stor eller liten desimaldelen er:\")\n",
+ "print(\"int(2.25) er\", int(2.25))\n",
+ "print(\"int(2.5) er\", int(2.5))\n",
+ "print(\"int(2.99) er\", int(2.99))\n",
+ "print(\"round() runder av til nærmeste heltall, f.eks.\")\n",
+ "print(\"round(2.25) er\", round(2.25))\n",
+ "print(\"round(2.51) er\", round(2.51))\n",
+ "print(\"Hva hvis tallet er midt mellom to heltall?\")\n",
+ "print(\"round(2.5) er\", round(2.5))\n",
+ "print(\"round(3.5) er\", round(3.5))\n",
+ "print(\"round() bruker en IEEE standard som velger partallet for midt-imellom-situasjoner.\")\n",
+ "print(\"Mens int() alltid gir heltall kan round() brukes for antall desimaler:\")\n",
+ "print(\"round(2.5488, 1) blir\", round(2.5488, 1))\n",
+ "print(\"round(2.5488, 3) blir\", round(2.5488, 3))\n",
+ "print(\"Med negativt antall desimaler kan vi få round() til å runde større enn heltall:\")\n",
+ "print(\"round(12345.67, -3) blir\", round(12345.67, -3)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "hidden": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Som du ser i eksemplet, blir 2.5 rundet av til 2 mens 3.5 blir rundet til 4. Dette kan virke litt uvant, i dagliglivet er man mest kjent med såkalt \"kjøpmannsavrunding\", hvor det alltid rundes opp hvis man er midt mellom (dvs., 2.5 skulle i så fall ha blitt rundet til 3). Konsekvent runding oppover når man er midt mellom har imidlertid en uheldig side, nemlig at man pådrar seg en systematisk feil hvis man har mange data som avrundes. Tenk f.eks. temperaturmålinger for lange perioder, hvor man deretter skal regne ut et snitt for hele perioden. Hvis alle temperaturer som er midt når det gjelder siste brukte siffer, rundes opp, vil snittet for perioden alltid bli litt for høyt. Hvis man i stedet går i partallsretning i alle slike midt mellom situasjoner, vil man runde opp cirka halvparten av gangene og ned cirka halvparten av gangene og dermed unngå slike systematiske feil. Men for kjøpmannen er systematisk runding oppover selvsagt bedre med tanke på å få inn mest mulig penger."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "## c)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Be brukeren om skrive inn et flyttall med minst 5 siffer både før og etter punktum. Ta vare på flyttallet i en variabel, konverter det deretter på diverse måter som antydet i eksempelutskriften under. Til slutt skal heltallet du fikk fra `int()` konverteres tilbake til et flyttall.\n",
+ "\n",
+ "Kjøring av kode:\n",
+ " \n",
+ "```python\n",
+ "Vennligst gi inn et flyttall med minst 5 siffer både før og etter .\n",
+ "Hva er tallet ditt? 123456.724353\n",
+ "Konvertert til heltall med int(): 123456\n",
+ "Avrundet til nærmeste heltall: 123457\n",
+ "Avrundet til to desimaler: 123456.72\n",
+ "Avrundet til fire desimaler: 123456.7244\n",
+ "Avrundet til nærmeste tusen: 123000\n",
+ "Heltall fra int() konvertert tilbake til flyttall: 123456.0\n",
+ "```\n",
+ "\n",
+ "***Skriv koden din i blokka under.***"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "## d)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Ta først inn et flyttall fra brukeren og spør deretter brukeren om hvor mange desimaler i det avrundede tallet som er ønskelig, og bruk `round()` med dette tallet.\n",
+ "\n",
+ "Eksempel på kjøring:\n",
+ " \n",
+ "```python\n",
+ "Skriv et flyttall: 3.14159263\n",
+ "Hvor mange desimaler er ønskelig? 2\n",
+ "Tallet du skrev er 3.14159263 og med 2 desimaler blir det til 3.14\n",
+ "```\n",
+ "***Skriv koden din i blokka under.***"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.7.4"
+ },
+ "toc": {
+ "base_numbering": 1,
+ "nav_menu": {},
+ "number_sections": false,
+ "sideBar": true,
+ "skip_h1_title": false,
+ "title_cell": "Table of Contents",
+ "title_sidebar": "Contents",
+ "toc_cell": false,
+ "toc_position": {},
+ "toc_section_display": true,
+ "toc_window_display": false
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/Ovinger/Oving01/Tetraeder.ipynb b/Ovinger/Oving01/Tetraeder.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..59b4060795c8391b8c461f338ad5362c8ade2896
--- /dev/null
+++ b/Ovinger/Oving01/Tetraeder.ipynb
@@ -0,0 +1,225 @@
+{
+ "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=\"_Oving1.ipynb\">Øving 1</a>\n",
+ " </div>\n",
+ " <ul class=\"nav navbar-nav\">\n",
+ " <li><a href=\"Intro%20til%20jupyter.ipynb\">Intro til Jupyter</a></li>\n",
+ " <li ><a href=\"Jeg%20elsker%20ITGK!.ipynb\">Jeg elsker ITGK!</a></li>\n",
+ " <li ><a href=\"Kalkulasjoner.ipynb\">Kalkulasjoner</a></li>\n",
+ " <li><a href=\"Input%20og%20variable.ipynb\">Input og variable</a></li>\n",
+ " <li><a href=\"Tallkonvertering.ipynb\">Tallkonvertering</a></li>\n",
+ " <li ><a href=\"Peppes%20Pizza.ipynb\">Peppes Pizza</a></li>\n",
+ " <li ><a href=\"Geometri.ipynb\">Geometri</a></li>\n",
+ " <li ><a href=\"Vitenskapelig%20notasjon.ipynb\">Vitenskapelig notasjon</a></li>\n",
+ " <li class=\"active\"><a href=\"Tetraeder.ipynb\">Tetraeder</a></li>\n",
+ " <li><a href=\"Bakekurs.ipynb\">Bakekurs</a></li>\n",
+ " <li ><a href=\"James%20Bond%20and%20Operation%20round().ipynb\">James Bond and Operation Round</a></li>\n",
+ " </ul>\n",
+ " </div>\n",
+ "</nav>\n",
+ "\n",
+ "# Tetraeder \n",
+ "\n",
+ "**Læringsmål:**\n",
+ "\n",
+ "* Input/output\n",
+ "* Formatere utskreven tekst\n",
+ "* Bruke innebygde funksjoner\n",
+ "\n",
+ "**Starting Out with Python:**\n",
+ "\n",
+ "* Kap. 2.8\n",
+ "\n",
+ "\n",
+ "\n",
+ "<br><br>I denne oppgaven skal du finne overflateareal og volum til regulære tetraedere (også kjent som trekantede pyramider). Et regulært tetraeder er et geometrisk objekt bestående av fire likesidede trekanter.\n",
+ "\n",
+ "* **Overflatearealet til et tetraeder er A=$\\sqrt{3}a^{2}$** \n",
+ "* **Volumet til et tetraeder er V=$\\frac{\\sqrt{2}a^{3}}{12}$ hvor a=$\\frac{3}{\\sqrt{6}}h$** "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "## a)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Lag et program som beregner og skriver ut på skjerm overflatearealet til et tetraeder. Test at programmet skriver ut 23.383 som resultat når høyden, h, er 3 (det gjør ikke noe om svaret får flere siffer).\n",
+ "\n",
+ "Eksempel på kjøring:\n",
+ " \n",
+ "```python\n",
+ "Et tetraeder med høyde 3 har areal 23.383\n",
+ "```\n",
+ "\n",
+ "***Skriv koden din i blokka under.***"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "heading_collapsed": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "#### Hint"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "hidden": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Kvadratrot kan regnes ut enten ved å opphøye et tall i 1/2, f.eks. `x ** 0.5`, eller ved `import math` og `math.sqrt` for å regne ut røttene. Det kan være lurt å lagre verdiene i variabler."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "## b)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Utvid programmet slik at det også skriver ut volumet til et tetraeder. Test at programmet skriver 5.846 når høyden (h) er 3 (det gjør ikke noe om svaret får flere siffer). Du kan skrive i samme kodeblokk som i oppgave a.\n",
+ "\n",
+ "Eksempel på kjøring:\n",
+ "\n",
+ " \n",
+ "```python\n",
+ "Et tetraeder med høyde 3 har volum 5.846\n",
+ "```"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "## c)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Utvid programmet så brukeren blir bedt om å skrive inn verdien på høyden (h) fra tastaturet, og får ut volum og areal. Eksempel på kjøring vist i boksen under. Du kan skrive i samme kodeblokk som i oppgave a.\n",
+ "\n",
+ "Eksempel på kjøring:\n",
+ "\n",
+ " \n",
+ "```python\n",
+ "Skriv inn en høyde: 3\n",
+ "Et tetraheder med høyde 3.0 har volum 5.85 og areal 23.38\n",
+ "```"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.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
+}
diff --git a/Ovinger/Oving01/Vitenskapelig notasjon.ipynb b/Ovinger/Oving01/Vitenskapelig notasjon.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..729503e2334749364eac315f2b2a404c1a51fdee
--- /dev/null
+++ b/Ovinger/Oving01/Vitenskapelig notasjon.ipynb
@@ -0,0 +1,286 @@
+{
+ "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=\"_Oving1.ipynb\">Øving 1</a>\n",
+ " </div>\n",
+ " <ul class=\"nav navbar-nav\">\n",
+ " <li><a href=\"Intro%20til%20jupyter.ipynb\">Intro til Jupyter</a></li>\n",
+ " <li ><a href=\"Jeg%20elsker%20ITGK!.ipynb\">Jeg elsker ITGK!</a></li>\n",
+ " <li ><a href=\"Kalkulasjoner.ipynb\">Kalkulasjoner</a></li>\n",
+ " <li><a href=\"Input%20og%20variable.ipynb\">Input og variable</a></li>\n",
+ " <li><a href=\"Tallkonvertering.ipynb\">Tallkonvertering</a></li>\n",
+ " <li ><a href=\"Peppes%20Pizza.ipynb\">Peppes Pizza</a></li>\n",
+ " <li ><a href=\"Geometri.ipynb\">Geometri</a></li>\n",
+ " <li class=\"active\"><a href=\"Vitenskapelig%20notasjon.ipynb\">Vitenskapelig notasjon</a></li>\n",
+ " <li><a href=\"Tetraeder.ipynb\">Tetraeder</a></li>\n",
+ " <li><a href=\"Bakekurs.ipynb\">Bakekurs</a></li>\n",
+ " <li ><a href=\"James%20Bond%20and%20Operation%20round().ipynb\">James Bond and Operation Round</a></li>\n",
+ " </ul>\n",
+ " </div>\n",
+ "</nav>\n",
+ "\n",
+ "# Vitenskapelig notasjon\n",
+ "\n",
+ "**Læringsmål:**\n",
+ "\n",
+ "* Vitenskapelig notasjon for spesielt små og spesielt store flyttall\n",
+ "\n",
+ "**Starting Out with Python:**\n",
+ "\n",
+ "* Kap. 2.8"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "### Nyttig info om formatering av store tall"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Når vi skriver flyttall i Python, er det enkleste ofte å skrive tallet rett frem, for eksempel 9.80665 eller 0.0002. Hvis tallet blir veldig stort (~$10^{6}$) eller lite (~$10^{-6}$), er det derimot tidkrevende å skrive tallet fullt ut, samtidig som at det lett dukker opp slurvefeil. Da vil resultatet av en beregning bli helt feil. Derfor er det vanlig å bruke vitenskapelig notasjon for store og små tall.\n",
+ "\n",
+ "I Python kan vi skrive tallene 3.0 × 10 $^{9}$ og 3.19 × 10$^{-10}$ ved bruk av multiplikasjon(`*`) og potensregning(`**`) slik: `3.0*10**9` og `3.19*10 **(-10)`. Det vil gi riktig resultat, men kaster bort tid og strøm på å gjøre helt unyttige beregninger, først en potensering, så en multiplikasjon, for å finne fram til et tall vi egentlig allerede vet hva er. Det er derfor bedre å bruke notasjonen `3.0e9` og `3.19e-10`, hvor tallet bak `e` viser tierpotensen for å uttrykke store og små tall. \n",
+ "\n",
+ "Notasjonen med `e` (som her ikke har noe med konstanten e å gjøre) lar oss legge tallet rett inn i variabelen uten noe regning. Eksemplet under viser bruk av denne notasjonen i linje 3.\n",
+ "\n",
+ "Eksempel på kode (**Prøv å kjør koden!**)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2019-07-01T12:28:51.461020Z",
+ "start_time": "2019-07-01T12:28:46.220125Z"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "tid = float(input(\"Hva er din pers på 60m? \"))\n",
+ "m_sek = 60/tid\n",
+ "lysfart = 3.0e8\n",
+ "x = lysfart / m_sek\n",
+ "print(\"Bra! Men for å nå igjen lyset...\")\n",
+ "print(\"...må du løpe\", x, \"ganger fortere\")\n",
+ "print(\"som også kan skrives\", format(x, '.1e'), \"ganger fortere.\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "`.1e` i format viser at det er ønskelig med én desimal i den vitenskapelige notasjonen. `.2e` ville gitt `4.25e+07`."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "## a) Fysikk / kjemi"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false
+ },
+ "source": [
+ "Avogadros konstant 6.022 × 10<sup>23</sup> sier hvor mange molekyler av et stoff som fins i ett mol av stoffet. Lag et program som ber brukeren navngi et stoff hun er i besittelse av, oppgi hvilken molvekt dette stoffet har, og hvor mye av stoffet hun har, og så skriver ut på skjermen hvor mange molekyler brukeren har av stoffet. Bruk gjerne `format()`-funksjonen for å unngå for mange desimaler i svaret. \n",
+ "\n",
+ "Eksempel på kjøring:\n",
+ "\n",
+ " \n",
+ "```python\n",
+ "Si et stoff du er i besittelse av: vann\n",
+ "Hva er molvekt i gram for vann? 18\n",
+ "Hvor mange gram vann har du? 500\n",
+ "Du har 1.7e+25 molekyler vann\n",
+ "```\n",
+ "\n",
+ "***Skriv koden din i blokka under.***"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "#### Hint"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Hint 1: `print(\"...må du løpe\", x, \"ganger fortere\")` tillater at en varibel som f.eks. `x` kan listes opp sammen med tekststrenger fordi `print()` kan ta flere argumenter. Funksjonen `input()` kan derimot bare ta ett argument, så hvis du ønsker navnet på stoffet med i promptet for de neste input-setningene, må det plusses med annen tekst heller enn å listes opp med komma.\n",
+ "\n",
+ "Hint 2: Regn først ut antall mol ved å ta hvor mye stoff hun har i antall gram og dele på molvekten. Deretter multipliserer du antall mol med avogadros tall."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "## b) Musikk"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Antall mulige melodilinjer på 10 toner (inkludert rytmevariasjoner) er anslått til å være 8.25 x 10<sup>19</sup>, jfr https://plus.maths.org/content/how-many-melodies-are-there. Lag et program i samme stil som 60m-programmet over som spør brukeren hvor mange ulike ti-toners melodilinjer hun selv tror hun har komponert og / eller hørt, og skriver ut som resultat hvor stor andel dette utgjør av antall mulige melodier (her vil dette sluttresultatet sannsynligvis bli et svært lite tall). \n",
+ "\n",
+ "Eksempel på kjøring:\n",
+ "\n",
+ " \n",
+ "```python\n",
+ "Antall ulike 10-toners melodilinjer du har hørt? 3288\n",
+ "Du har hørt 3.985454545454546e-15 prosent av melodier som er mulig.\n",
+ "```\n",
+ "\n",
+ "***Skriv koden din i blokka under.***"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "heading_collapsed": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "#### Hint"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "hidden": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Ta antall ulike ti-toners melodilinjer du har hørt og divider på antall mulige melodilinjer på 10 toner og regn deretter tallet om til prosent."
+ ]
+ }
+ ],
+ "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
+}
diff --git a/Ovinger/Oving01/_Oving1.ipynb b/Ovinger/Oving01/_Oving1.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..8fe41a98afcd7bf8b55818655de6447896212c29
--- /dev/null
+++ b/Ovinger/Oving01/_Oving1.ipynb
@@ -0,0 +1,92 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "# Øving 1\n",
+ "\n",
+ "## Læringsmål:\n",
+ "\n",
+ "* Kunne bruke vanlige regneoperatorer i Python: addisjon + , subtraksjon – , multiplikasjon * , divisjon / , heltallsdivisjon '// , modulo % og potens **\n",
+ "* Forstå forskjellen på de fire elementære datatypene: heltall (int), flyttall (float), tekststrenger (str) og sannhetsverdier (boolean)\n",
+ "* Skjønne hvordan regneoperatorene virker for de ulike datatypene\n",
+ "* Kunne bruke vitenskapelig notasjon for spesielt små og spesielt store flyttall\n",
+ "* Forstå at kode må være uten feil for å kjøre, og kunne rette enkle syntaksfeil\n",
+ "* Forstå hvorfor og hvordan vi bruker variable i programmering, og at variabeltilordning ikke er det samme som matematisk likhet\n",
+ "* Kunne skrive ut til skjerm og lese inn data fra brukeren via tastaturet med standardfunksjonene print() og input()\n",
+ "* Kunne utføre enkel konvertering mellom datatyper med standardfunksjoner som int() og float()\n",
+ "\n",
+ "## Starting Out with Python:\n",
+ "\n",
+ "* Kap. 2: Input, Processing, and Output\n",
+ "\n",
+ "\n",
+ " \n",
+ "\n",
+ "## Godkjenning:\n",
+ "\n",
+ "For å få godkjent øvingen må du gjøre Intro til Jupyter oppgaven og **4** av 10 andre 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",
+ "\n",
+ "Oppgave | Tema | Vanskelighetsgrad\n",
+ "--- | --- | ---\n",
+ "[Intro til Jupyter](Intro%20til%20jupyter.ipynb) | Jupyter notebooks | \n",
+ "[Jeg elsker ITGK!](Jeg%20elsker%20ITGK!.ipynb) | Output | \n",
+ "[Kalkulasjoner](Kalkulasjoner.ipynb)|Matteoperasjoner|\n",
+ "[Input og variable](Input%20og%20variable.ipynb)|Input/output og variabler|\n",
+ "[Tallkonvertering](Tallkonvertering.ipynb)|Konvertering|\n",
+ "[Peppes pizza](Peppes%20Pizza.ipynb)|Matteoperasjoner|\n",
+ "[Geometri](Geometri.ipynb)|Debugging\n",
+ "[Vitenskapelig notasjon](Vitenskapelig%20notasjon.ipynb)|konvertering|\n",
+ "[Tetraeder](Tetraeder.ipynb)|innebygde funksjoner|\n",
+ "[Bakekurs](Bakekurs.ipynb)|Formatering|\n",
+ "[James Bond and Operation round](James%20Bond%20and%20Operation%20round().ipynb)|Strenger, avrunding, heltallsdivisjon, modulo| "
+ ]
+ }
+ ],
+ "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
+}