diff --git a/Ovinger/Oving8/Eksamen 2012.ipynb b/Ovinger/Oving8/Eksamen 2012.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..6a0c84ea3e37b3c8b295b5e4c8e574f3a7e25959
--- /dev/null
+++ b/Ovinger/Oving8/Eksamen 2012.ipynb	
@@ -0,0 +1,826 @@
+{
+ "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=\"_Oving8.ipynb\">Øving 8</a>\n",
+    "    </div>\n",
+    "    <ul class=\"nav navbar-nav\">\n",
+    "    <li ><a href=\"Rekursjon.ipynb\">Rekursjon </a></li>\n",
+    "    <li class=\"active\"><a href=\"Eksamen%202012.ipynb\">Eksamen Python 2012</a></li>\n",
+    "    <li ><a href=\"Sudoku.ipynb\">Sudoku</a></li>\n",
+    "    <li ><a href=\"Sjakk.ipynb\">Sjakk</a></li>\n",
+    "    </ul>\n",
+    "  </div>\n",
+    "</nav>\n",
+    "\n",
+    "\n",
+    "# Eksamen 2012"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "deletable": false,
+    "editable": false,
+    "hide_input": true,
+    "run_control": {
+     "frozen": true
+    }
+   },
+   "source": [
+    "## Oppgave 1 - Teori (25%)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "deletable": false,
+    "editable": false,
+    "run_control": {
+     "frozen": true
+    }
+   },
+   "source": [
+    "Noen av flervalgsoppgavene som ikke var pensum er fjernet. For å få opp alle flervalgsoppgavene, `trykk på denne boksen, pil ned, og så ctrl + enter`. Merk at dersom du gjør dette igjen etter å startet en besvarelse vil besvarelsen din forsvinne. Dette gjelder kun flervalgsoppgaven. Trykk `Widgets->Save Notebook Widget State` for å lagre flervalgsoppgavene.  Du kan trykke `Cell->All Output->Toggle Scrolling` for å få alle oppgavene i et stort vindu."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "hide_input": true,
+    "scrolled": true
+   },
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "import sys\n",
+    "module_path = os.path.abspath(os.path.join('../..'))\n",
+    "if module_path not in sys.path:\n",
+    "    sys.path.append(module_path)\n",
+    "    \n",
+    "from Resources.mc_generator import *\n",
+    "\n",
+    "generate_multiple_no_answer('eksamen2012teori.txt')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "deletable": false,
+    "editable": false,
+    "run_control": {
+     "frozen": true
+    }
+   },
+   "source": [
+    "## Oppgave 2 -  Grunnleggende programmering (20%)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "deletable": false,
+    "editable": false,
+    "run_control": {
+     "frozen": true
+    }
+   },
+   "source": [
+    "***I denne versjonen har vi fjernet fjervalgsoppgavene som til vanlig teller 25% av eksamen. Topp prosentscore er da altså 75%.***\n",
+    "\n",
+    "Du kan anta at alle fuksjonene mottar gyldige input-verdier."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "deletable": false,
+    "editable": false,
+    "run_control": {
+     "frozen": true
+    }
+   },
+   "source": [
+    "### Oppgave 2 a) (5%)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "deletable": false,
+    "editable": false,
+    "run_control": {
+     "frozen": true
+    }
+   },
+   "source": [
+    "Lag funksjonen **summerOlympics** som har inn-parametere **firstYear** og **lastYear**. Funksjonen skal returnere variabelen **years**,som er ei liste med alle OL-årene fra og med **firstYear** til og med **lastYear** (inkludert framtidige planlagte år for sommer-OL). Fra og med OL i London i 1948,har sommer-OL vært arrangert hvert fjerde år. Du kan anta at **firstYear** ≥ 1948.\n",
+    "\n",
+    "Eksempel på kjøring av funksjonen og hva den returnerer:\n",
+    "\n",
+    "```python\n",
+    ">>>years = summerOlympics(1999,2012)\n",
+    ">>> years\n",
+    "[2000, 2004, 2008, 2012]\n",
+    ">>>\n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "scrolled": false
+   },
+   "outputs": [],
+   "source": [
+    "#skriv koden din her"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "deletable": false,
+    "editable": false,
+    "run_control": {
+     "frozen": true
+    }
+   },
+   "source": [
+    "### Oppgave 2b) (7.5%)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "deletable": false,
+    "editable": false,
+    "run_control": {
+     "frozen": true
+    }
+   },
+   "source": [
+    "Lag funksjonen **`findAge`** som har inn-parametere **bYear**, **bMonth**, **bDay** som er tre heltall som beskriver dato for en fødselsdag. Funksjonen skal returnere **age** som beskriver hvor gammel en person med oppgitt fødselsdag (**bYear**, **bMonth** og **bDay**) er i dag angitt i hele år.\n",
+    "\n",
+    "For å finne år, måned og dag for i dag ***skal du bruke*** en eksisterende funksjon som heter `current_date()`.Funksjonen returnerer tre heltall på formatet **(yyyy,mm,dd)**. \n",
+    "\n",
+    "Eksempel på bruk av funksjonen **current_date**:  \n",
+    "`(yyyy,mm,dd)= current_date()` gir i dag yyyy=2012,mm=12, dd=11.\n",
+    "\n",
+    "Eksempel på kjøring av funksjonen **`findAge`** og hva den returnerer:\n",
+    "\n",
+    "```python\n",
+    ">>> age = findAge(2000,12,15)\n",
+    ">>> age\n",
+    "11\n",
+    ">>>\n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2019-07-05T10:58:13.647340Z",
+     "start_time": "2019-07-05T10:58:13.641077Z"
+    },
+    "scrolled": false
+   },
+   "outputs": [],
+   "source": [
+    "from datetime import datetime\n",
+    "def current_date():\n",
+    "    yyyy = int(datetime.today().strftime('%Y'))\n",
+    "    mm = int(datetime.today().strftime('%m'))\n",
+    "    dd = int(datetime.today().strftime('%d'))\n",
+    "    return yyyy,mm,dd"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "scrolled": false
+   },
+   "outputs": [],
+   "source": [
+    "#skriv koden din her"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "deletable": false,
+    "editable": false,
+    "run_control": {
+     "frozen": true
+    }
+   },
+   "source": [
+    "### Oppgave 2c) (7.5 %)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "deletable": false,
+    "editable": false,
+    "run_control": {
+     "frozen": true
+    }
+   },
+   "source": [
+    "Lag en funksjon **`printAgeDiff`** som tar en parameter **table**,som er en to-dimensjonal tabell (liste av lister) der hver rekke beskriver personer med fornavn, etternavn, fødselsår, fødselsmåned og fødselsdato. Funksjonen skal bruke funksjonen **`findAge`** fra oppgave 2b til å sammenlikne alderen i hele år på etterfølgende personer i tabellen (rekke for rekke) og gjøre følgende:\n",
+    "\n",
+    "* Hvis person n og person n+1 har samme alder angitt i antall hele år, skal følgende skrives ut til skjerm:  \n",
+    "``<fornavnn> <etternavnn> is at the same age as <fornavnn+1> <etternavnn+1>``\n",
+    "* Hvis person n er eldre enn person n+1 angitt i antall hele år, skal følgende skrives ut til skjerm:  \n",
+    "``<fornavnn> <etternavnn> is older than <fornavnn+1> <etternavn n+1>``\n",
+    "* Hvis person n er yngre enn person n+1 angitt i antall hele år, skal følgende skrives ut til skjerm:  \n",
+    "``<fornavnn> <etternavnn> is younger than <fornavnn+1> <etternavnn+1>``\n",
+    "\n",
+    "Eksempel på en to-dimensjonal tabell som beskriver fire kjente personer:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "scrolled": false
+   },
+   "outputs": [],
+   "source": [
+    "table=[['Justin','Bieber',1994,3,1],\n",
+    "       ['Donald','Duck',1934,8,1],\n",
+    "       ['George','Clooney',1961,5,6],\n",
+    "       ['Eddie','Murphy',1961,4,3]]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "deletable": false,
+    "editable": false,
+    "run_control": {
+     "frozen": true
+    }
+   },
+   "source": [
+    "Eksempel på kjøring av funksjonen **`printAgeDiff`** med tabellen **table**, som inneholder listene for bieber, donald, george og eddie:\n",
+    "\n",
+    "```python\n",
+    ">>>printAgeDiff(table)\n",
+    "Justin Bieber is younger than Donald Duck\n",
+    "Donald Duck is older than George Clooney\n",
+    "George Clooney is at the same age as Eddie Murphy\n",
+    ">>>\n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "scrolled": false
+   },
+   "outputs": [],
+   "source": [
+    "#skriv koden din her"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "deletable": false,
+    "editable": false,
+    "run_control": {
+     "frozen": true
+    }
+   },
+   "source": [
+    "## Oppgave 3 - Kodeforståelse (15%)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "deletable": false,
+    "editable": false,
+    "run_control": {
+     "frozen": true
+    }
+   },
+   "source": [
+    "### Oppgave 3a) (5%)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "deletable": false,
+    "editable": false,
+    "run_control": {
+     "frozen": true
+    }
+   },
+   "source": [
+    "Hva returneres hvis funksjonen `fu1(1234)`med kode som vist under kjøres?\n",
+    "\n",
+    "```python\n",
+    "def fu1(a):\n",
+    "    r = 0\n",
+    "    while(a>0):\n",
+    "        s = a%10\n",
+    "        r = r + s\n",
+    "        a = (a-s)/10\n",
+    "return r\n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Svar: <dobbeltklikk for å svare>"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "deletable": false,
+    "editable": false,
+    "run_control": {
+     "frozen": true
+    }
+   },
+   "source": [
+    "### Oppgave 3b) (5%)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "deletable": false,
+    "editable": false,
+    "run_control": {
+     "frozen": true
+    }
+   },
+   "source": [
+    "Hva blir verdiene til a,b,c og d etter kallet  \n",
+    "`(a, b, c, d) = fu2(’Ut pa tur, aldri sur’)`  \n",
+    "med koden som vist under?\n",
+    "\n",
+    "```python\n",
+    "    def fu2(input):\n",
+    "        r = 0\n",
+    "        s = 0\n",
+    "        t = 0\n",
+    "        u = 0\n",
+    "        n = len(input)\n",
+    "        for c in input:\n",
+    "            if(c.isalpha()):\n",
+    "                r = r + 1\n",
+    "            elif(c.isdigit()):\n",
+    "                s = s + 1\n",
+    "            elif(c==' '):\n",
+    "                t = t + 1\n",
+    "            else:\n",
+    "                u = u + 1\n",
+    "        r = 100*r/n\n",
+    "        s = 100*s/n\n",
+    "        t = 100*t/n\n",
+    "        u = 100*u/n\n",
+    "        return(r,s,t,u)\n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Svar: <dobbeltklikk for å svare>"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "deletable": false,
+    "editable": false,
+    "run_control": {
+     "frozen": true
+    }
+   },
+   "source": [
+    "### Oppgave 3c) (5%)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "deletable": false,
+    "editable": false,
+    "run_control": {
+     "frozen": true
+    }
+   },
+   "source": [
+    "Hva returneres av kallet `fu3(100)`med koden som vist under?\n",
+    "```python\n",
+    "def fu3(a):\n",
+    "    if(a<=2):\n",
+    "        r = 1\n",
+    "    else:\n",
+    "        r = 1 + fu3(a/2)\n",
+    "    return r\n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Svar: <dobbeltklikk for å svare>"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "deletable": false,
+    "editable": false,
+    "run_control": {
+     "frozen": true
+    }
+   },
+   "source": [
+    "## Oppgave 4 - Programmering (40%)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "deletable": false,
+    "editable": false,
+    "run_control": {
+     "frozen": true
+    }
+   },
+   "source": [
+    "Denne oppgaven fokuserer på behandling av data fra fire vær sensorer som måler en verdi per døgn av følgende data:\n",
+    "\n",
+    "* Temperatur: Angis som heltall i Celsius fra -50C til + 50C\n",
+    "* Nedbør: Angis som heltall i mm nedbør per døgn fra 0 til 2000mm\n",
+    "* Luftfuktighet. Angis som heltall fra 0 til 100%\n",
+    "* Vindstyrke: Angis som heltall fra 0 til 50 meter per sekund\n",
+    "\n",
+    "Hvis ikke noe annet er oppgitt kan du anta korrekt input til funksjonene."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "deletable": false,
+    "editable": false,
+    "run_control": {
+     "frozen": true
+    }
+   },
+   "source": [
+    "### Oppgave 4a) (5%)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "deletable": false,
+    "editable": false,
+    "run_control": {
+     "frozen": true
+    }
+   },
+   "source": [
+    "Lag en funksjon **`cold_days`** som tar imot parameteren **templist**, som en liste av temperaturer, og returnerer variabelen **days**,som angir antall døgn der temperaturen var under 0 grader.\n",
+    "\n",
+    "Eksempel på kall av funksjonen og hva den returnerer:\n",
+    "```python\n",
+    ">>> days = cold_days([1,-5,3,0,-6,-3,15,0])\n",
+    ">>> days\n",
+    "3\n",
+    ">>>\n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "scrolled": false
+   },
+   "outputs": [],
+   "source": [
+    "#skriv koden din her"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "deletable": false,
+    "editable": false,
+    "run_control": {
+     "frozen": true
+    }
+   },
+   "source": [
+    "### Oppgave 4 b) (5 %)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "deletable": false,
+    "editable": false,
+    "run_control": {
+     "frozen": true
+    }
+   },
+   "source": [
+    "Lag en funksjon **`cap_data`** som har inn-parameterne **array** (liste med data), **min_value** (minimumsverdi) og **max_value** (maksimumsverdi). Funksjonen skal returnere ei ny liste **result** der alle elementer i lista **array** som har verdi mindre enn **min_value** skal settes lik **min_value** og alle elementer i lista **array** som har verdi høyere enn **max_value** skal settes lik **max_value**.\n",
+    "\n",
+    "Eksempel på kall av funksjonen og hva den returnerer:\n",
+    "```python\n",
+    ">>>A=[-70,30,0,90,23,-12,95,12]\n",
+    ">>>result = cap_data(A,-50,50)\n",
+    ">>>result\n",
+    "[-50,30,0,50,23,-12,50,12]\n",
+    ">>>\n",
+    "```\n",
+    "\n",
+    "Legg merke til hvilke verdier som endres."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "scrolled": false
+   },
+   "outputs": [],
+   "source": [
+    "#skriv koden din her"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "deletable": false,
+    "editable": false,
+    "run_control": {
+     "frozen": true
+    }
+   },
+   "source": [
+    "### Oppgave 4c) (10%)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "deletable": false,
+    "editable": false,
+    "run_control": {
+     "frozen": true
+    }
+   },
+   "source": [
+    "Lag en funksjon **`generate_testdata`** som har inn-parameterne **N**, **min_value** (minimumsverdi) og **max_value** (maksimumsverdi). Funksjonen skal returnere tabellen **result** som består av **N** unike *tall* (heltall) som blir trukket tilfeldig der {**min_value** ≤ *tall* ≤ **max_value**}. Unik betyr her at ingen elementer i tabellen **result** skal ha samme verdi. Du kan anta at antall mulige verdier i intervallet tallet blir trukket fra alltid vil være større enn **N**.\n",
+    "\n",
+    "Eksempel på kall av funksjonen og hva den returnerer:\n",
+    "```python\n",
+    ">>> result = generate_testdata(10,-5,10)\n",
+    ">>> result\n",
+    "[-5,3,7,9,-3,4,2,0,-1,5]\n",
+    ">>>```"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "scrolled": false
+   },
+   "outputs": [],
+   "source": [
+    "#skriv koden din her"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "deletable": false,
+    "editable": false,
+    "run_control": {
+     "frozen": true
+    }
+   },
+   "source": [
+    "### Oppgave 4d) (5%)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "deletable": false,
+    "editable": false,
+    "run_control": {
+     "frozen": true
+    }
+   },
+   "source": [
+    "Lag en funksjon **`create_db`** som har inn-parameterne **temp**, **rain**, **humidity** og **wind**, som er fire tabeller av samme størrelse (likt antall elementer) med data for temperatur, nedbør, luftfuktighet og vind.\n",
+    "\n",
+    "Funksjonen skal lage og returnere *dictionarien* **weather**, der nøkkelen er ett heltall som starter med verdien 1 og teller oppover (representerer dagen for måling). Hvert innslag i *dictionarien* skal være en liste av verdier for temperatur, nedbør, luftfuktighet og vind. Verdiene for **weather** med nøkkel 1 skal inneholde værdata for dag 1, **weather** med nøkkel2 skal inneholde værdata for dag 2 og så videre.\n",
+    "\n",
+    "Eksempel på kall av funksjonen og hva den returnerer:\n",
+    "```python\n",
+    ">>> temp = [1,5,3]\n",
+    ">>> rain = [0,30,120]\n",
+    ">>> humidity = [30,50,65]\n",
+    ">>> wind = [3,5,7]\n",
+    ">>> weather = create_db(temp,rain,humidity,wind)\n",
+    ">>> weather\n",
+    "{1: [1, 0, 30, 3], 2: [5, 30, 50, 5], 3: [3, 120, 65, 7]}\n",
+    ">>>\n",
+    "``` "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "scrolled": false
+   },
+   "outputs": [],
+   "source": [
+    "#skriv koden din her"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "deletable": false,
+    "editable": false,
+    "run_control": {
+     "frozen": true
+    }
+   },
+   "source": [
+    "### Oppgave 4e) (5%)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "deletable": false,
+    "editable": false,
+    "run_control": {
+     "frozen": true
+    }
+   },
+   "source": [
+    "Lag en funksjon **`print_db`** som har inn-parameteren **weather**, som er en dictionary som beskrevet i oppgave 4d. Funksjonen skal skrive ut innholdet i **weather** på skjerm etter følgende format og med overskrift som vist på utskriften nederst i deloppgaven:\n",
+    "* Day(dag) –høyrejustert med 4 tegn\n",
+    "* Temp (temperatur)–høyrejustert med 6 tegn\n",
+    "* Rain (nedbør)–høyrejustert med 6 tegn\n",
+    "* Humidity (luftfuktighet)–høyrejustert med 10 tegn\n",
+    "* Wind (vind)–høyrejustert med 6 tegn\n",
+    "\n",
+    "Eksempel på kall av funksjonen ved bruk av dictionarien fra oppgave 4d:\n",
+    "```p\n",
+    ">>> print_db(weather)\n",
+    "Day | Temp | rain | humidity | wind\n",
+    "====+======+======+==========+======\n",
+    "   1      1      0         30      5\n",
+    "   2      5     30         50      3\n",
+    "   3      3    120         65      7\n",
+    ">>>\n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "scrolled": false
+   },
+   "outputs": [],
+   "source": [
+    "#skriv koden din her"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "deletable": false,
+    "editable": false,
+    "run_control": {
+     "frozen": true
+    }
+   },
+   "source": [
+    "### Oppgave 4f) (10%)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "deletable": false,
+    "editable": false,
+    "run_control": {
+     "frozen": true
+    }
+   },
+   "source": [
+    "Lag funksjonen **`strange_weather`** som har inn-parameterne **temp** og **rain**,som er to tabeller med data for temperaturer og regn av lik størrelse (samme antall elementer). Funksjonen skal returnere **start** (startdag)og **stop** (sluttdag)for det lengste intervallet der det er minusgrader, samt at temperaturen faller samtidig som nedbørsmengden stiger i etterfølgende dager. Indekseringen av dager starter på 1. Hvis ingen etterfølgende dager har denne karakteristikken, returneres (0,0).\n",
+    "\n",
+    "Eksempel på kall av funksjonen(med intervall som oppfyller kravet uthevet):\n",
+    "```python\n",
+    ">>> temp=[1,3, 4,-5,-6,-7,-8,-9,3,0]\n",
+    ">>> rain=[0,20,30,0,10,30,50,0,5,2]\n",
+    ">>> (start, stop) = strange_weather(temp,rain)\n",
+    ">>> start\n",
+    "4\n",
+    ">>> stop\n",
+    "7\n",
+    ">>>\n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2019-07-05T12:00:04.448245Z",
+     "start_time": "2019-07-05T12:00:04.442468Z"
+    },
+    "scrolled": false
+   },
+   "outputs": [],
+   "source": [
+    "#skriv koden din her"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3.8.6rc1 64-bit",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.6"
+  },
+  "toc": {
+   "base_numbering": 1,
+   "nav_menu": {},
+   "number_sections": false,
+   "sideBar": true,
+   "skip_h1_title": false,
+   "title_cell": "Table of Contents",
+   "title_sidebar": "Contents",
+   "toc_cell": false,
+   "toc_position": {},
+   "toc_section_display": true,
+   "toc_window_display": false
+  },
+  "vscode": {
+   "interpreter": {
+    "hash": "a1d88f1d6af7274392319340ad589157e5034eb25853bd7ff5b502ff0dd39369"
+   }
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/Ovinger/Oving8/Rekursjon.ipynb b/Ovinger/Oving8/Rekursjon.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..307c73d147b243b6e73ab0751671c7ec88a1813d
--- /dev/null
+++ b/Ovinger/Oving8/Rekursjon.ipynb
@@ -0,0 +1,578 @@
+{
+ "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=\"_Oving8.ipynb\">Øving 8</a>\n",
+    "    </div>\n",
+    "    <ul class=\"nav navbar-nav\">\n",
+    "    <li ><a href=\"Rekursjon.ipynb\">Rekursjon </a></li>\n",
+    "    <li class=\"active\"><a href=\"Eksamen%202012.ipynb\">Eksamen Python 2012</a></li>\n",
+    "    <li ><a href=\"Sudoku.ipynb\">Sudoku</a></li>\n",
+    "    <li ><a href=\"Sjakk.ipynb\">Sjakk</a></li>\n",
+    "    </ul>\n",
+    "  </div>\n",
+    "</nav>\n",
+    "\n",
+    "\n",
+    "# Rekursjon\n",
+    "\n",
+    "**Læringsmål:**\n",
+    "\n",
+    "* Rekursjon\n",
+    "* Algoritmer\n",
+    "\n",
+    "**Starting Out with Python:**\n",
+    "\n",
+    "* Kap. 12: Recursion"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "deletable": false,
+    "editable": false,
+    "heading_collapsed": true,
+    "run_control": {
+     "frozen": true
+    }
+   },
+   "source": [
+    "### Rekursjon, hva er det?"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "deletable": false,
+    "editable": false,
+    "hidden": true,
+    "run_control": {
+     "frozen": true
+    }
+   },
+   "source": [
+    "Dersom en funksjon kaller på seg selv kaller vi dette for rekursjon. Rekursjon er et viktig konsept innenfor datateknologi, og det er en mye brukt teknikk for å løse problemer som kan deles opp i mindre tilsvarende subproblemer. For eksempel bygger en rekke søkealgoritmer på konseptet rekursjon.\n",
+    "\n",
+    "![img](./../../Resources/Images/fixing_problems.webp)\n",
+    "\n",
+    "La oss begynne å se på en veldig enkel funksjon som benytter seg av rekursjon, som nevnt betyr dette bare at funksjonen kaller seg selv.\n",
+    "\n",
+    "**Eksempel:**"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "hidden": true
+   },
+   "outputs": [],
+   "source": [
+    "def teller(nummer=0):\n",
+    "    print(\"Nå har vi kommet til: \", nummer)\n",
+    "    teller(nummer + 1)\n",
+    "    \n",
+    "teller()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "deletable": false,
+    "editable": false,
+    "hidden": true,
+    "run_control": {
+     "frozen": true
+    }
+   },
+   "source": [
+    "Her ser vi en teller implementert rekursivt. Funksjonen begynner å telle fra null, siden det er standardverdien vi har gitt, før den kaller seg selv på nytt, men denne gangen med økt verdi. Vi kan også lage en funksjon med samme funksjonalitet iterativt, ved hjelp av løkker. Funksjonen under vil gjøre akkurat det samme som vår rekursive teller."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "hidden": true
+   },
+   "outputs": [],
+   "source": [
+    "def teller2():\n",
+    "    nummer = 0\n",
+    "    while True:\n",
+    "        print(\"Nå har vi kommet til: \", nummer)\n",
+    "        nummer += 1\n",
+    "        \n",
+    "teller()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "deletable": false,
+    "editable": false,
+    "hidden": true,
+    "run_control": {
+     "frozen": true
+    }
+   },
+   "source": [
+    "Men, som du kanskje har lagt merke til, har vår rekursive funksjon en stor svakhet, den slutter aldri. Funksjonen vår vil fortsette å telle helt til vi får en RecursionError, hvor vi får beskjed om at maksimum rekursjons dybde er nådd. Vi kan se på det som at hver gang vi kaller en rekursiv funksjon graver vi oss lengre ned i et hull, og Python setter en grense for hvor langt ned vi kan grave, forhåpentligvis ønsker vi å komme oss opp igjen av hullet også, men det ser vi på litt senere. Først la oss fokusere på at funksjonen vår aldri avslutter.\n",
+    "\n",
+    "Rekursive funksjoner trenger det vi kaller vi et **grunntilfelle**, et sted hvor koden innser at det er på tide å slutte. La oss prøve å endre telleren slik at den slutter å telle når den kommer til 10."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2019-07-05T06:25:12.112924Z",
+     "start_time": "2019-07-05T06:25:12.100102Z"
+    },
+    "hidden": true
+   },
+   "outputs": [],
+   "source": [
+    "def teller(nummer=0):\n",
+    "    print(\"Nå har vi kommet til: \", nummer)\n",
+    "    if(nummer<10):\n",
+    "        teller(nummer + 1)\n",
+    "        \n",
+    "teller()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "deletable": false,
+    "editable": false,
+    "hidden": true,
+    "run_control": {
+     "frozen": true
+    }
+   },
+   "source": [
+    "Som du nå selv kan teste, vil funksjonen vår telle til 10, før den gir seg. Vi har et tilfelle hvor funksjonen finner ut at den skal stoppe, og vi slipper at Python skal gi oss en streng beskjed om at vi må slutte å kalle funksjonen vår. Tidligere nevnte vi også ambisjoner om å klatre opp igjen fra hullet vi har laget oss, så la oss først ta en kikk på en klassiskt bruksområde når det kommer til rekursjon, nemlig hvordan vi kan regne fakultet:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2019-07-05T06:31:27.611550Z",
+     "start_time": "2019-07-05T06:31:27.594077Z"
+    },
+    "hidden": true
+   },
+   "outputs": [],
+   "source": [
+    "def fakultet(tall):\n",
+    "    if tall==0:\n",
+    "        return 1\n",
+    "    else:\n",
+    "        return tall*fakultet(tall-1)\n",
+    "\n",
+    "fakultet(5)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "deletable": false,
+    "editable": false,
+    "hidden": true,
+    "run_control": {
+     "frozen": true
+    }
+   },
+   "source": [
+    "Her baserer vi oss på grunntilfellet hvor null fakultet er lik 1. Ellers vet vi at fakultet av et tall er lik tallet selv gange fakultet av tallet selv minus en. Altså f.eks. er 5! = 5 * 4!. Det kan vi enkelt løse rekursivt, som vi allerede har gjort. Det som er nytt for dette eksempelet er at vi faktisk benytter oss av resultatet av funksjonskallene våre. Når vi kaller funksjonen med tallet 3 vil følgende skje:\n",
+    "\n",
+    "> Vi prøver å regne ut 3! men siden vi trenger 2! kaller vi funksjonen på nytt.  \n",
+    "Vi prøver å regne ut 2! men siden vi trenger 1! kaller vi funksjonen på nytt.  \n",
+    "Vi prøver å regne ut 1! men siden vi trenger 0! kaller vi funksjonen på nytt.  \n",
+    "Vi prøver å regne ut 0!, det vet vi er 1.   \n",
+    "Vi benytter oss av resultatet over, finner ut at 1! er 1.  \n",
+    "Vi benytter oss av resultatet over, finner ut at 2! er 2.  \n",
+    "Vi benytter oss av resultatet over, finner ut at 3! er 6.  \n",
+    "\n",
+    "Hvis vi fortsetter å tenke på grave-eksempelet kan vi se at vi over har to faser, en hvor vi kaller funksjonen på nytt og graver oss ned, før vi omsider finner bunnen og klatrer opp igjen. Ved å trykke [her](http://pythontutor.com/visualize.html#code=def%20fakultet%28tall%29%3A%0A%20%20%20%20if%20tall%3D%3D0%3A%0A%20%20%20%20%20%20%20%20return%201%0A%20%20%20%20else%3A%0A%20%20%20%20%20%20%20%20return%20tall*fakultet%28tall-1%29%0A%0Afakultet%285%29&cumulative=false&curInstr=26&heapPrimitives=nevernest&mode=display&origin=opt-frontend.js&py=3&rawInputLstJSON=%5B%5D&textReferences=false) kan du få visualisert hvordan vi regner ut fakultet av fem steg for steg.\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "deletable": false,
+    "editable": false,
+    "hidden": true,
+    "run_control": {
+     "frozen": true
+    }
+   },
+   "source": [
+    "La oss ta en kikk på en nytt eksempel men denne gangen skal vi bruke en liste, hvor vi ønsker å summere alle elementene rekursivt. Som nevnt introduksjonsmessig er rekursivitet brukt mye i sorteringsalgoritmer, og selv om det ofte kan virke som om det vi gjør rekursivt alltid kan gjøres iterativt, er ikke det alltid tilfelle. Rekursjon er derfor viktig å forstå, selv om det også er vanskelig."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2019-07-05T06:55:48.783091Z",
+     "start_time": "2019-07-05T06:55:48.771923Z"
+    },
+    "hidden": true
+   },
+   "outputs": [],
+   "source": [
+    "def liste_sum(liste):\n",
+    "    if(len(liste)==1):\n",
+    "        return liste[0] #dersom listen kun har et element er summen vår bare det ene elementet\n",
+    "    else:\n",
+    "        return liste[0]+liste_sum(liste[1:]) #ellers tar vi det første elementet og legger til summen av resten av lista\n",
+    "    \n",
+    "liste_sum([1,2,3])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "deletable": false,
+    "editable": false,
+    "hidden": true,
+    "run_control": {
+     "frozen": true
+    }
+   },
+   "source": [
+    "Det er kanskje ikke så mye nytt her med unntak av at vi denne gangen fokuserer på en liste, men la oss også nå se steg for seg hva som skjer.\n",
+    "\n",
+    "> Vi vil ha summen av [1,2,3], vi vet dette er 1 + summen av [2,3], vi kaller funksjonen på nytt  \n",
+    "Vi vil ha summen av [2,3], vi vet dette er 2 + summen av [3], vi kaller funksjonen på nytt  \n",
+    "Vi vet at summen av [3] er 3, så vi gir verdien til funksjons-kallet over.  \n",
+    "Siden summen av [3] var 3, er summen [2,3] = 2 + 3 = 5  \n",
+    "Siden summen av [2,3] var 5, er summen av [1,2,3] = 1 + 5 = 6.   \n",
+    "\n",
+    "Det ligner mye på det vi gjorde når vi implementerte fakultet, vi jobber oss nedover, når bunnen, og går tilbake opp. Trykk [her](http://pythontutor.com/visualize.html#code=def%20liste_sum%28liste%29%3A%0A%20%20%20%20if%28len%28liste%29%3D%3D1%29%3A%0A%20%20%20%20%20%20%20%20return%20liste%5B0%5D%20%23dersom%20listen%20kun%20har%20et%20element%20er%20summen%20v%C3%A5r%20bare%20det%20ene%20elementet%0A%20%20%20%20else%3A%0A%20%20%20%20%20%20%20%20return%20liste%5B0%5D%2Bliste_sum%28liste%5B1%3A%5D%29%20%23ellers%20tar%20vi%20det%20f%C3%B8rste%20elementet%20og%20legger%20til%20summen%20av%20resten%20av%20lista%0A%20%20%20%20%0Aliste_sum%28%5B1,2,3%5D%29&cumulative=false&curInstr=0&heapPrimitives=nevernest&mode=display&origin=opt-frontend.js&py=3&rawInputLstJSON=%5B%5D&textReferences=false) for en visualisering.\n",
+    "\n",
+    "Nå har du fått en rask innføring i hvordan programmere rekursivt. Hvis du vil ha en litt annen innføring i temaet kan du sjekke ut [denne linken](https://realpython.com/python-thinking-recursively/). "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### a) Rekursiv sum"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "deletable": false,
+    "editable": false,
+    "run_control": {
+     "frozen": true
+    }
+   },
+   "source": [
+    "Skriv en funksjon `recursive_sum(n)` som tar inn et heltall n og regner summen av  1+2+...+n ved hjelp av rekursjon. \n",
+    "\n",
+    "**Eksempel på kjøring:**\n",
+    "```python\n",
+    ">>>print(recursive_sum(53))\n",
+    "1431\n",
+    "```"
+   ]
+  },
+  {
+   "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": [
+    "Se på eksempelet med fakultet i tutorialen."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "deletable": false,
+    "editable": false,
+    "run_control": {
+     "frozen": true
+    }
+   },
+   "source": [
+    "### b) Merge sum"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "deletable": false,
+    "editable": false,
+    "run_control": {
+     "frozen": true
+    }
+   },
+   "source": [
+    "Skriv en funksjon `merge_sum(liste)` som summerer alle elementene i en liste men på en litt annen måte enn i tutorialen. \n",
+    "\n",
+    "* Anta et partall antall elementer i lista.\n",
+    "* Når du skal summere elementene skal det gjøres ved å dele lista i to, og så addere summen av hver halvdel av listen. "
+   ]
+  },
+  {
+   "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": [
+    "Tenk på grunntilfellet og hva funksjonen skal returnere.  \n",
+    "Hvor skal vi dele lista?"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "deletable": false,
+    "editable": false,
+    "run_control": {
+     "frozen": true
+    }
+   },
+   "source": [
+    "### c) Minste element"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "deletable": false,
+    "editable": false,
+    "run_control": {
+     "frozen": true
+    }
+   },
+   "source": [
+    "Skriv en rekursiv funksjon `find_smallest_element(numbers)` som tar inn en liste numbers med heltall og finner det minste elementet i listen. \n",
+    "*Merk: Du kan ikke bruke innebygde funksjoner i Python som min(liste), for å løse denne oppgaven.*\n",
+    "\n",
+    "```python\n",
+    ">>>print(find_smallest_element([5,3,2,6]))\n",
+    "2\n",
+    "```"
+   ]
+  },
+  {
+   "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 en kikk på eksempelet med listesum i tutorialen. Her vil du kunne buke en lignende framgangsmåte, men med en litt annen logikk."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "deletable": false,
+    "editable": false,
+    "run_control": {
+     "frozen": true
+    }
+   },
+   "source": [
+    "### d) Binærsøk"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "deletable": false,
+    "editable": false,
+    "run_control": {
+     "frozen": true
+    }
+   },
+   "source": [
+    "Skriv en rekursiv funksjon `binary_search(numbers, element)` som tar inn en sortert liste **numbers** med heltall og et heltall **element** og returnerer posisjonen(indeksen) til elementet dersom det finnes i listen. Hvis det ikke finnes skal funksjonen returnere minus uendelig (`-float('inf')`). Dette skal du gjøre ved å benytte deg av [binærsøk-algoritmen](https://en.wikipedia.org/wiki/Binary_search_algorithm). \n",
+    "\n",
+    "Du kan også implementere funksjonen `binary_search(numbers, element, minimum, maximum)`, altså samme funksjon, med samme funksjonalitet, men med parameterene **minimum** og **maximum**, som vi kan bruke til å angi indeksene vi søker på i lista.\n",
+    "\n",
+    "*Merk: I denne oppgaven er det ikke lov til å bruke innebygde funksjoner i Python som liste.index(element).* \n",
+    "\n",
+    "**BONUS**: Hvis listen numbers inneholder n elementer, hvor mange funksjonskall vil binærsøk-algoritmen i worst case trenge for å finne posisjonen til elementet i listen? (eller at elementet ikke er i listen)"
+   ]
+  },
+  {
+   "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": {
+    "ExecuteTime": {
+     "end_time": "2019-07-05T07:40:52.433819Z",
+     "start_time": "2019-07-05T07:40:52.424489Z"
+    },
+    "deletable": false,
+    "editable": false,
+    "hidden": true,
+    "run_control": {
+     "frozen": true
+    }
+   },
+   "source": [
+    "Tenk på midterste element."
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3.8.6rc1 64-bit",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.8.6"
+  },
+  "toc": {
+   "base_numbering": 1,
+   "nav_menu": {},
+   "number_sections": false,
+   "sideBar": true,
+   "skip_h1_title": false,
+   "title_cell": "Table of Contents",
+   "title_sidebar": "Contents",
+   "toc_cell": false,
+   "toc_position": {},
+   "toc_section_display": true,
+   "toc_window_display": false
+  },
+  "vscode": {
+   "interpreter": {
+    "hash": "a1d88f1d6af7274392319340ad589157e5034eb25853bd7ff5b502ff0dd39369"
+   }
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/Ovinger/Oving8/Sjakk.ipynb b/Ovinger/Oving8/Sjakk.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..0eae2db83c1667d89ea4bb2a31b13022a09d284e
--- /dev/null
+++ b/Ovinger/Oving8/Sjakk.ipynb
@@ -0,0 +1,105 @@
+{
+ "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=\"_Oving8.ipynb\">Øving 8</a>\n",
+    "    </div>\n",
+    "    <ul class=\"nav navbar-nav\">\n",
+    "    <li ><a href=\"Rekursjon.ipynb\">Rekursjon </a></li>\n",
+    "    <li class=\"active\"><a href=\"Eksamen%202012.ipynb\">Eksamen Python 2012</a></li>\n",
+    "    <li ><a href=\"Sudoku.ipynb\">Sudoku</a></li>\n",
+    "    <li ><a href=\"Sjakk.ipynb\">Sjakk</a></li>\n",
+    "    </ul>\n",
+    "  </div>\n",
+    "</nav>\n",
+    "\n",
+    "\n",
+    "# Sjakk\n",
+    "\n",
+    "**Læringsmål:**\n",
+    "\n",
+    "* Store problemstillinger\n",
+    "\n",
+    "**I denne oppgaven skal du skrive et større program. For denne typen oppgaver kan det være mer praktisk å laste ned python og eventuelt en IDE (Et område man programmerer i på sin egen maskin) som VS Code. Det er fortsatt mulig å gjøre oppgaven i Jupyter dersom du ikke ønsker å jobbe lokalt, selv om det ikke er anbefalt.**\n",
+    "\n",
+    "I denne øvingen skal du implementere sjakk. Begynn med den så fort som mulig, og jobb med den kontinuerlig (les: denne oppgaven krever mye arbeid).\n",
+    "\n",
+    "Bruk læringsassistent på sal når du har muligheten.\n",
+    "\n",
+    "Under er forslag til fremgangsmåte, men du kan gjøre det som du vil. Det som kreves av programmet er:\n",
+    "\n",
+    "1. Programmet må kunne ta inn trekk fra spillerne (tekstbasert).\n",
+    "2. Programmet skal hindre spillerne i å gjøre ulovlige trekk.*\n",
+    "3. Programmet skal oppdage og si ifra når en spiller er i sjakk.\n",
+    "4. Programmet skal oppdage og si ifra når det er sjakkmatt.\n",
+    "5. Hvis en bonde når andre siden av brettet skal den bli forfremmet til en offiser (dronning, løper, springer eller tårn).\n",
+    "\n",
+    "**Du trenger IKKE ta hensyn til patt, remis, en passant, rokering eller tidskontroll.**\n",
+    "\n",
+    "Regler for sjakk og hvordan brikkene kan bevege seg finnes her: http://no.wikipedia.org/wiki/Sjakk\n",
+    "\n",
+    "## Forslag til framgangsmåte:\n",
+    "\n",
+    "Her finner du et forslag til fremgangsmåte, den er veiledende, men kan være til hjelp hvis du ikke helt vet hvor du skal begynne.\n",
+    "\n",
+    "1. Velg en måte å representere et sjakkbrett. Vi anbefaler en todimensjonal liste. Velg også hvordan du skal representere en tom rute og at en rute er opptatt av en bestemt brikke.\n",
+    "2.  Initialiser brettet med alle brikkene i sin korrekte startposisjon.\n",
+    "3. Gjør det mulig å se brikkene på skjermen. Med andre ord skriv en funksjon som printer ut brettet fint til skjermen. For et penere design, kopier og lim inn disse symbolene i koden din: ♖, ♜, ♗, ♝, ♘, ♞, ♕, ♛, ♔, ♚, ♙, ♟\n",
+    "4. Gjør det mulig for en spiller å flytte på en brikke. Hvordan kan du implementere at en brikke tar en annen?\n",
+    "5. Legg til funksjonalitet som sjekker om trekket er lovlig. Gjør dette i flere omganger:\n",
+    "    * Er trekket av en gyldig form? (’L’ fasong for springer, diagonalt for løper etc.)\n",
+    "    * Er trekket blokkert av en annen brikke?\n",
+    "    * Pass på at det ikke er mulig å ta en brikke av din egen farge.\n",
+    "7. Skriv funksjonalitet som tester om kongen er i sjakk. Husk også at det er et ulovlig trekk å sette sin egen konge i sjakk, utvid testene over slik at dette også blir et ugyldig trekk.\n",
+    "8. Skriv funksjonalitet for å sjekke om kongen er i sjakk-matt. (Her kan du gjenbruke kode fra sjakk-testen)\n",
+    "9. Skriv funksjonalitet som oppdager at en bonde er flyttet til andre siden av brettet og la spilleren forfremme bonden til en dronning/tårn/løper/springer."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#skriv koden din her om du velger å kode i jupyter, vi anbefaler å kode denne oppgaven i idle eller pycharm"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3.8.6rc1 64-bit",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.8.6"
+  },
+  "vscode": {
+   "interpreter": {
+    "hash": "a1d88f1d6af7274392319340ad589157e5034eb25853bd7ff5b502ff0dd39369"
+   }
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/Ovinger/Oving8/Sudoku.ipynb b/Ovinger/Oving8/Sudoku.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..1f8c33607bae818586f3e6162c039e7a6e031b0a
--- /dev/null
+++ b/Ovinger/Oving8/Sudoku.ipynb
@@ -0,0 +1,104 @@
+{
+ "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=\"_Oving8.ipynb\">Øving 8</a>\n",
+    "    </div>\n",
+    "    <ul class=\"nav navbar-nav\">\n",
+    "    <li ><a href=\"Rekursjon.ipynb\">Rekursjon </a></li>\n",
+    "    <li class=\"active\"><a href=\"Eksamen%202012.ipynb\">Eksamen Python 2012</a></li>\n",
+    "    <li ><a href=\"Sudoku.ipynb\">Sudoku</a></li>\n",
+    "    <li ><a href=\"Sjakk.ipynb\">Sjakk</a></li>\n",
+    "    </ul>\n",
+    "  </div>\n",
+    "</nav>\n",
+    "\n",
+    "\n",
+    "# Sudoku\n",
+    "\n",
+    "**Læringsmål.**\n",
+    "\n",
+    "* Store problemstillinger\n",
+    "\n",
+    "**I denne oppgaven skal du skrive et større program. For denne typen oppgaver kan det være mer praktisk å laste ned python og eventuelt en IDE (Et område man programmerer i på sin egen maskin) som VS Code. Det er fortsatt mulig å gjøre oppgaven i Jupyter dersom du ikke ønsker å jobbe lokalt, selv om det ikke er anbefalt.**\n",
+    " \n",
+    "I denne oppgaven skal vi først lage et sudoku-spill (før vi lager en sudoku-løser om noen år). Om du ikke kjenner reglene til sudoku kan du lese deg opp på de selv [her](https://no.wikipedia.org/wiki/Sudoku). Del 1 tar seg av å lage et spillbart sudoku-brett.\n",
+    "\n",
+    "Du står fritt til å bygge opp brettet slik som du vil, men brettet skal oppfylle følgende krav:\n",
+    "\n",
+    "* Brukeren skal kunne skrive inn et tall i en valgfri celle. Dersom tallet ikke er gyldig, dvs. ikke mellom 1 og 9, skal en feilmelding skrives ut.\n",
+    "* Brukeren skal ikke kunne fylle inn et tall som allerede finnes i den samme raden, kolonnen eller kvadratet.\n",
+    "* Brukeren skal kunne slette et tall fra en celle.\n",
+    "* Hver gang brukeren fyller inn eller sletter et tall skal det nye brettet skrives ut på en fin måte. Et eksempel kan være som vist under (tallene over og ved siden av brettet angir her henholdsvis kolonne- og radnummer).\n",
+    "* Brukeren skal kunne laste inn et brett fra en tekstfil.\n",
+    "* Et halvutfylt brett skal kunne lagres til fil, slik at man kan fullføre det senere.\n",
+    "* Spillet skal skrive ut en hyggelig gratulasjonsmelding dersom man har klart brettet.\n",
+    "* Alt skal utføres gjennom et brukervennlig grensesnitt. Det vil si at brukeren ikke skal trenge å kalle på funksjonene selv, men at alt gjøres via input eller ved å lese fra/skrive til fil.\n",
+    "\n",
+    "Eksempel på brett:\n",
+    "```python\n",
+    "    0 1 2   3 4 5   6 7 8 \n",
+    "  +-------+-------+-------+\n",
+    "0 | 0 0 6 | 9 0 5 | 0 1 0 |\n",
+    "1 | 9 7 0 | 0 1 2 | 3 0 5 |\n",
+    "2 | 0 2 0 | 0 0 4 | 8 6 0 |\n",
+    "  +-------+-------+-------+\n",
+    "3 | 5 0 3 | 8 0 0 | 0 2 0 |\n",
+    "4 | 0 0 0 | 0 0 0 | 0 0 0 |\n",
+    "5 | 0 8 0 | 0 0 1 | 9 0 7 |\n",
+    "  +-------+-------+-------+\n",
+    "6 | 0 5 4 | 1 0 0 | 0 7 0 |\n",
+    "7 | 2 0 7 | 4 5 0 | 0 9 3 |\n",
+    "8 | 0 6 0 | 7 0 3 | 1 0 0 |\n",
+    "  +-------+-------+-------+\n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#skriv koden din her"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3.8.6rc1 64-bit",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.8.6"
+  },
+  "vscode": {
+   "interpreter": {
+    "hash": "a1d88f1d6af7274392319340ad589157e5034eb25853bd7ff5b502ff0dd39369"
+   }
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/Ovinger/Oving8/_Oving8.ipynb b/Ovinger/Oving8/_Oving8.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..e5d638706e059983542c9bb2ffc58fb6d51d4cd8
--- /dev/null
+++ b/Ovinger/Oving8/_Oving8.ipynb
@@ -0,0 +1,75 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "deletable": false,
+    "editable": false,
+    "run_control": {
+     "frozen": true
+    }
+   },
+   "source": [
+    "# Øving 8\n",
+    "\n",
+    "**Læringsmål:**\n",
+    "\n",
+    "- Rekursjon\n",
+    "- Sammensatte programmer\n",
+    "\n",
+    "**Starting Out with Python:**\n",
+    "\n",
+    "- Kap. 12: Recursion\n",
+    "\n",
+    "**Theory book**\n",
+    "\n",
+    "- Kap 5 - Algorithms\n",
+    " \n",
+    "\n",
+    "## Godkjenning (LES DETTE NØYE):\n",
+    "\n",
+    " Oppgaven \"Rekursjon\" er obligatorisk for å få godkjent øvingen. I tillegg må man gjøre minst én av disse tre: \"Eksamen Python 2012\", \"Sudoku\" eller \"Sjakk\". Hvis man gjør mer enn én, vil dette tilsvare to øvinger godkjent. Sjakk-oppgaven teller som to øvinger.\n",
+    "\n",
+    "Man kan maksimalt få to godkjente øvinger ved å gjøre øving 8. \n",
+    "\n",
+    "Vanskelige oppgaver er markert med stjerne og ekstra vanskelige oppgaver 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",
+    "[Rekursjon](Rekursjon.ipynb)| Rekursjon, Algoritmer| \n",
+    "[Eksamen Python 2012](Eksamen%202012.ipynb)|Repetisjon|\n",
+    "[Sudoku](Sudoku.ipynb)|Repetisjon, Sammensatte problemer|\n",
+    "[Sjakk](Sjakk.ipynb)|Repetisjon, Sammensatte problemer|![img](./../../Resources/Images/star_yellow.svg) ![img](./../../Resources/Images/star_yellow.svg)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3.8.6rc1 64-bit",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.8.6"
+  },
+  "vscode": {
+   "interpreter": {
+    "hash": "a1d88f1d6af7274392319340ad589157e5034eb25853bd7ff5b502ff0dd39369"
+   }
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/Ovinger/Oving8/eksamen2012teori.txt b/Ovinger/Oving8/eksamen2012teori.txt
new file mode 100644
index 0000000000000000000000000000000000000000..1e599b0894ee6911d97613f47fbf03df7f0843b0
--- /dev/null
+++ b/Ovinger/Oving8/eksamen2012teori.txt
@@ -0,0 +1,18 @@
+1)Hva kjennetegner komprimeringsalgoritmer som er tapsløs (lossless)?£a)Den opprinnelige datamengden kan gjenskapes nøyaktig.£b)Den komprimerte datamengden er like stor som utgangspunktet.£c)Egner seg spesielt godt for multimediedata som bilder, lyd og video.£d)Fjerner bare informasjonsinnhold som ikke er viktig for menneskers oppfatning av informasjonsmengden, for eksempel i et bilde.
+2)Hva sier Nyquist-regelen om samplingsfrekvensen?£a)Samplingsfrekvensen må være minst halvparten av den høyeste lydfrekvensen.£b)Samplingsfrekvensen må være minst den samme som den høyeste lydfrekvensen.£c)Samplingsfrekvensenmå være minst dobbelt så rask som den høyeste lydfrekvensen.£d)Samplingsfrekvensen må alltid være 20KHz.
+3)Hva er oppgaven til en programteller (program counter):£a)Den holder rede på antall kodelinjer i et program.£b)Den inneholder adressen til neste instruksjon.£c)Den styrer antall iterasjoner i en FOR-løkke.£d)Ingen av svarene er riktige.
+4)Hvor mange symboler kan kodes med 10 bit?£a)10.£b)512.£c)1024.£d)Ingen.
+6)Hvorfor digitalisere nettverk?£a)Ønske om å kombinere tjenester.£b)Enklere å utnytte kapasitet bedre med felles nettverk.£c)Digital koding kan gi bedre feilsjekk og korrigering av feil.£d)Alle alternativene a-c er riktige.
+7)Hva er et Denial of Service–angrep?£a)Å sende så mange forespørsler til en tjener (server) at den ikke klarer å utføre oppgavene sine.£b)Å bryte seg inn på en tjener (server) og sørge for at den nekter å utføre tjenestene sine.£c)Å nekte å motta meldinger fra en tjener (server) som da blir opptatt med å sende forespørslene på nytt og på nytt.£d)Å sende en falsk e-post om problemer med en tjeneste, som for eksempel en nettbank, og lure brukeren til å avsløre påloggingsinformasjon for å få løst problemet.
+8)Hva vil det si at vi at vi har “random access” (tilfeldig tilgang) til minnet?£a)Alldatai minnet kan hentes direkteuansett hvor det befinner seg.£b)Det er tilfeldig hva som hentes ut av minnet.£c)Vi må hente ut data sekvensielt (byte for byte) for å finne det vi leter etter.£d)Ingen av svarene er riktige.
+9)Hva vil det si at en datamaskin er deterministisk?£a)Den har en pessimistisk livsanskuelse som avviser fri vilje.£b)Når den skal velge hvilken instruksjon den skal behandle neste gang har den ikke noe valg, men baserer valget på programmet og dataene den gis.£c)At den har en intuisjon på hva som er lurt å gjøre.£d)Ingen av svarene er riktige.
+10)Hvilke av alternativene under er mulige tolkninger av PandA-mønstre?£a)True og False.£b)Ja og Nei.£c)+ og –.£d)Alle alternativene a-c er riktige.
+11)Når vi studerer algoritmers effektivitet, ser vi på hvordan kjøretiden utvikler seg i forhold til mengden av input.  Vi gjør analyser av bestefall, verstefall og gjennomsnittstilfellet.  Hvorfor er det spesielt interessant å analysere en algoritmes kjøretid i verste fall?£a)Det setter en øvre grense for hvor lang tid det tar å kjøre algoritmen.£b)Programmerere er pessimister.£c)Det er mer interessant med høye tall.£d)Det forteller hvor lang tid algoritmen ca. bruker på å kjøre.
+12)Vi deler inn algoritmer i klasser basert på de funksjoner som beskriver deres utvikling i kjøretid best. Hvilken algoritme er i klassen Θ(log(n)):£a)Innstikksortering (Insertion sort).£b)Binærsøk (binary search).£c)Sekvensielt søk (sequential search).£d)Ingen av svarene er riktige.
+13)Hva er et datagram?£a)Et telegram som er skrevet på data.£b)Vekten på en dataenhet.£c)En pakke som sendes over internett som følger IP-protokollen.£d)Ingen av svarene er riktige.
+14)Fargene som vises på en dataskjerm representeres oftemed 24 bits RGB-koding. Fargen blå vil da representeres som:£a)0000 0000 0000 0000 0000 0000.£b)1111 1111 0000 0000 0000 0000.£c)0000 0000 1111 1111 0000 0000.£d)0000 0000 0000 0000 1111 1111.
+15)Når vi overfører data over internett oppstår det ofte feil på grunn av forstyrrelser på linjene. For å oppdage slike feil brukes ofte £a)NIC (Network Interface Card).£b)ISP (Internet Service Provider).£c)CRC (Cyclic Redundancy Check).£d)Ingen av svarene er riktige.
+16)En mikroprosessor utfører de samme femoppgavene om og om igjen. Hvilken rekkefølge av stegeneunder beskriver korrektrekkefølge på dette F/E-kretsløpet (F/E cycle)?£a)Information Fetch –Data Fetch –Instruction Decode –Instruction Execution –Results Return.£b)Results Return –Instruction Execution –Information Fetch –Data Fetch –Instruction Decode.£c)Information Fetch –Instruction Decode –Data Fetch –Instruction Execution –Results Return.£d)Instruction Decode –Instruction Execution –Information Fetch –Data Fetch –Results Return.
+18)Hva er DAC?£a)Et program som hjelper med beregninger (data-assisted computing).£b)En enhet som oversetter analoge signaler til digitale signaler.£c)En enhet som oversetter digitale signaler til analoge signaler.£d)Et program som oversetter datakode til programmeringsspråket C (evt. C++).
+19)Rekursjon betyr at £a)En funksjon kaller seg selv.£b)Kjøretiden til programmet minsker.£c)Programmet går i evig løkke.£d)Ingen av svarene er riktige.
+20)Ranger effektivitetsklassene Θ(n3), Θ(n), Θ(log(n))og Θ(n2) etter effektivitet, der minst effektiv først og deretter mer og mer effektiv £a)Θ(n3), Θ(n2), Θ(n), Θ(log(n)).£b)Θ(n3), Θ(n), Θ(n2), Θ(log(n)).£c)Θ(log(n)),Θ(n3), Θ(n2), Θ(n).£d)Θ(n), Θ(log(n)),Θ(n3),Θ(n2).
\ No newline at end of file
diff --git a/README.md b/README.md
index 608e1c43dd6ccf0cfbaee2b1e8b0a26c067e0e95..6dc53e6c4a0b23776152ca33bcb7661b6ce736f6 100644
--- a/README.md
+++ b/README.md
@@ -9,7 +9,7 @@
 -   [Øving 5](./Ovinger/Oving5/_Oving5.ipynb)
 -   [Øving 6](./Ovinger/Oving6/_Oving6.ipynb)
 -   [Øving 7](./Ovinger/Oving7/_Oving7.ipynb)
--   Øving 8 (kommer senere)
+-   [Øving 8](./Ovinger/Oving8/_Oving8.ipynb)
 
 ### Løsningsforslag