diff --git a/Ovingsforelesninger/OF7/solutions.ipynb b/Ovingsforelesninger/OF7/solutions.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..a7322d18bc4a05eb66552cd0779346522b297622
--- /dev/null
+++ b/Ovingsforelesninger/OF7/solutions.ipynb
@@ -0,0 +1,858 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Øvingsforelesning 7 - TDT4110\n",
+    "\n",
+    "Øving 5 - Lister, tupler, arrays"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Nyttige funksjoner fra forrige ØF;"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Skriv inn et gyldig tall!\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "2"
+      ]
+     },
+     "execution_count": 12,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "def input_int(prompt = \"Skriv inn et tall: \"):\n",
+    "    while True:\n",
+    "        given = input(prompt)\n",
+    "\n",
+    "        if given.isnumeric():\n",
+    "            return int(given)\n",
+    "        \n",
+    "        print(\"Skriv inn et gyldig tall!\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Oppgave 1 (1/3)\n",
+    "\n",
+    "Vi skal lage et enkelt terningspill. I spillet trenger vi mulighet til å trille en terning\n",
+    "\n",
+    "Lag en funksjon som triller en terning, dvs. returnerer et tall fra og med 1 til og med 6\n",
+    "\n",
+    "Hint: \n",
+    "```python\n",
+    "import random\n",
+    "\n",
+    "x = random.randint(1, 6) \n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "4\n",
+      "2\n",
+      "4\n",
+      "2\n",
+      "1\n",
+      "5\n",
+      "6\n",
+      "6\n",
+      "1\n",
+      "2\n"
+     ]
+    }
+   ],
+   "source": [
+    "import random\n",
+    "\n",
+    "def roll_dice():\n",
+    "    return random.randint(1, 6)\n",
+    "\n",
+    "for i in range(10):\n",
+    "    print(roll_dice())"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Oppgave 1 (2/3)\n",
+    "\n",
+    "En runde i spillet består av at spilleren gjetter hvor mye hen til sammen kommer til å trille, før 6 terninger trilles. Hvis hen gjettet riktig, får hen 3 poeng. Hvis hen var innenfor 5 fra riktig verdi, får hen 1 poeng. \n",
+    "\n",
+    "Lag en funksjon for å beregne poeng gitt spilleren, basert på spillerens gjett og verdien til de trillede terningene. \n",
+    "\n",
+    "Lag så en funksjon for en runde, som spør spilleren om å gjette, triller terninger, og returnerer poengsummen for den runden. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Skriv inn et gyldig tall!\n",
+      "Trillet 6\n",
+      "Trillet 2\n",
+      "Trillet 1\n",
+      "Trillet 3\n",
+      "Trillet 5\n",
+      "Trillet 6\n",
+      "Du trillet totalt 23! Det gir en score på 1 poeng\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "1"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "def get_score(guess, actual):\n",
+    "    if guess == actual:\n",
+    "        return 3\n",
+    "    elif abs(guess - actual) <= 5:\n",
+    "        return 1\n",
+    "    else:\n",
+    "        return 0\n",
+    "\n",
+    "def play_round():\n",
+    "    guess = input_int(\"Skriv inn ditt gjett: \")\n",
+    "\n",
+    "    actual = 0\n",
+    "    for i in range(6):\n",
+    "        roll = roll_dice()\n",
+    "        print(f\"Trillet {roll}\")\n",
+    "        actual += roll\n",
+    "    \n",
+    "    score = get_score(guess, actual)\n",
+    "    print(f\"Du trillet totalt {actual}! Det gir en score på {score} poeng\")\n",
+    "    return score\n",
+    "\n",
+    "#print(get_score(20, 20))\n",
+    "#print(get_score(20, 25))\n",
+    "#print(get_score(20, 15))\n",
+    "#print(get_score(20, 30))\n",
+    "\n",
+    "play_round()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Oppgave 1 (3/3)\n",
+    "\n",
+    "Til slutt vil vi ha mulighet til aÌŠ spille hele spillet\n",
+    "\n",
+    "Husk: main() kaller de andre funksjonene og står for kommunikasjon med bruker\n",
+    "\n",
+    "Spør spilleren først hvor mange runder hen vil spille, og kjør så gjennom <antall> mange runder. Hold kontroll på poengsummen til brukeren, og skriv den ut til slutt. \n",
+    "\n",
+    "Ekstraoppgave:\n",
+    "Utvid spillet til å være for to spillere"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " ===== Runde 1/3 =====\n",
+      "Trillet 5\n",
+      "Trillet 2\n",
+      "Trillet 2\n",
+      "Trillet 4\n",
+      "Trillet 6\n",
+      "Trillet 6\n",
+      "Du trillet totalt 25! Det gir en score på 1 poeng\n",
+      " ===== Runde 2/3 =====\n",
+      "Trillet 3\n",
+      "Trillet 3\n",
+      "Trillet 6\n",
+      "Trillet 6\n",
+      "Trillet 2\n",
+      "Trillet 2\n",
+      "Du trillet totalt 22! Det gir en score på 3 poeng\n",
+      " ===== Runde 3/3 =====\n",
+      "Trillet 6\n",
+      "Trillet 6\n",
+      "Trillet 4\n",
+      "Trillet 1\n",
+      "Trillet 4\n",
+      "Trillet 2\n",
+      "Du trillet totalt 23! Det gir en score på 1 poeng\n",
+      "Din totale score er 5 poeng\n"
+     ]
+    }
+   ],
+   "source": [
+    "def main():\n",
+    "    rounds = input_int(\"Hvor mange runder ønsker du å spille? \")\n",
+    "\n",
+    "    total_score = 0\n",
+    "\n",
+    "    for round in range(1, rounds + 1):\n",
+    "        print(f\" ===== Runde {round}/{rounds} =====\")\n",
+    "        total_score += play_round()\n",
+    "\n",
+    "    print(f\"Din totale score er {total_score} poeng\")\n",
+    "\n",
+    "main()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Forklaring av lister\n",
+    "**Lister** er en datatype som inneholder *elementer* som kan ha ulike datatyper. Det er altså en måte å samle flere ting i samme variabel. En liste lages ved å legge elementer inn i et par med firkantparanteser `[]`. Dette kan også tilegnes en variabel. For eksempel kan jeg opprette en liste `min_liste` med partall mellom 2 og 10:   \n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [],
+   "source": [
+    "min_liste = [2,4,6,8,10]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "For å aksessere elementene i listen under kan vi benytte indeksering. Indeksen forteller hvilken \"plass\" vi er på i listen. Den første indeksen i listen er 0 og den siste er *antall elementer - 1*. Det vil si at det første elementet i `min_liste`, 2,  kan hentes ut slik:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "min_liste[0]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "og det siste elementet i listen kan hentes ut slik:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "min_liste[4] # Hvor 4 er lengden til listen minus 1 "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Man kan legge elementer til i en liste med `append()` slik som dette:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "min_liste.append(12) # Legger til 12 på slutten av listen\n",
+    "print(min_liste)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Test deg frem med lister selv\n",
+    "Kodeblokken under er lagt til for at du skal kunne leke deg litt frem med lister selv. Gjerne kombiner det med konsepter du har lært tidligere som if-setninger, løkker og funksjoner. Hvis du trenger litt hjelp til å begynne kan du titte i tabellene under som viser hvordan vi kan jobbe med lister i Python."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "handle_liste = [\"Brød\", \"Melk\", \"Smør\", \"Brus\"]\n",
+    "print(handle_liste)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Innebygde liste-funksjoner: Nice to know\n",
+    "\n",
+    "![Innebygde liste-funksjoner](../../Resources/Images/liste-funksjoner.jpg)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Oppgave 2\n",
+    "\n",
+    "a) Opprett en liste med tall fra 0 til 5\n",
+    "\n",
+    "b) Opprett en liste med karakterene i ordet “Jeg bor på Gløshaugen”\n",
+    "\n",
+    "c) Opprett en liste med annethvert tall fra 0 til 50\n",
+    "\n",
+    "d) Opprett en liste med annenhver ```True``` og ```False``` med lengde 20\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[0, 1, 2, 3, 4, 5]\n",
+      "['J', 'e', 'g', ' ', 'b', 'o', 'r', ' ', 'p', 'å', ' ', 'G', 'l', 'ø', 's', 'h', 'a', 'u', 'g', 'e', 'n']\n",
+      "Jeg bor på Gløshaugen\n",
+      "[0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50]\n",
+      "[True, False, True, False, True, False, True, False, True, False, True, False, True, False, True, False, True, False, True, False]\n"
+     ]
+    }
+   ],
+   "source": [
+    "liste1 = [0, 1, 2, 3, 4, 5]\n",
+    "print(liste1)\n",
+    "\n",
+    "liste2 = list(\"Jeg bor på Gløshaugen\")\n",
+    "print(liste2)\n",
+    "print(\"\".join(liste2))\n",
+    "\n",
+    "liste3 = list(range(0, 51, 2))\n",
+    "print(liste3)\n",
+    "\n",
+    "liste4 = [True, False] * 10\n",
+    "print(liste4)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Oppgave 3\n",
+    "\n",
+    "### Velg en en av listene du lagde i oppgave 1 og bruk den i denne oppgaven:\n",
+    "\n",
+    "**a)** Hent ut elementet på indeks 4 og skriv det til bruker med print().\n",
+    "\n",
+    "**b)** Endre det siste elementet i listen til 0.\n",
+    "\n",
+    "**c)** Lag en funksjon ```print_number_in_list(i, lst)``` som tar inn et heltall ```i``` og en liste ```lst```. Funksjonen skal printe element på indeks ```i``` fra ```lst``` på formatet under:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "4\n",
+      "[0, 1, 2, 3, 4, 0]\n",
+      "Elementet på indeks 2 er 2\n",
+      "Elementet på indeks 4 er b\n",
+      "Elementet på indeks 6 er 12\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(liste1[4])\n",
+    "liste1[5] = 0\n",
+    "print(liste1)\n",
+    "\n",
+    "def print_number_in_list(i, lst):\n",
+    "    element = lst[i]\n",
+    "    print(f\"Elementet på indeks {i} er {element}\")\n",
+    "\n",
+    "print_number_in_list(2, liste1)\n",
+    "print_number_in_list(4, liste2)\n",
+    "print_number_in_list(6, liste3)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Oppgave 4\n",
+    "\n",
+    "**a)** Lag en funksjon som tar inn en liste og returnerer første halvdelen av listen\n",
+    "\n",
+    "**b)** Lag en funksjon som tar inn en liste og som kopierer alt utenom det første og siste elementet i en ny liste, og returnerer den nye listen.\n",
+    "\n",
+    "**Tips:**\n",
+    "- Bruk slicing!\n",
+    "- Her må vi vite hvor lang listen er - ```len()``` fungerer også på lister, og returnerer antall elementer i liste"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 36,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[0, 1, 2, 3, 4, 5]\n",
+      "[0, 1, 2]\n",
+      "[1, 2, 3, 4]\n",
+      "[0, 1, 2, 3, 4, 5]\n"
+     ]
+    }
+   ],
+   "source": [
+    "def get_first_half(lst):\n",
+    "    end_index = len(lst) // 2\n",
+    "    return lst[:end_index]\n",
+    "\n",
+    "def copy_without_first_and_last(lst):\n",
+    "    #end_index = len(lst) - 1\n",
+    "    #return lst[1:end_index]\n",
+    "    return lst[1:-1]\n",
+    "\n",
+    "liste1 = [0, 1, 2, 3, 4, 5]\n",
+    "print(liste1)\n",
+    "print(get_first_half(liste1))\n",
+    "print(copy_without_first_and_last(liste1))\n",
+    "print(liste1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 31,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[0, 1, 2, 3, 4, 5]\n",
+      "[0, 1, 2]\n",
+      "[0, 1, 'hei', 3, 4, 5]\n",
+      "[0, 1, 'hei', 3, 4, 5]\n",
+      "[0, 1, 2]\n",
+      "[0, 1, 'hei', 3, 4, 5]\n",
+      "[0, 1, 'hei', 3, 4, 5]\n",
+      "['test', 1, 2]\n"
+     ]
+    }
+   ],
+   "source": [
+    "liste1 = [0, 1, 2, 3, 4, 5]\n",
+    "kopi = liste1 # liste1[:] #list(liste1)\n",
+    "sliced = liste1[0:3]\n",
+    "print(kopi)\n",
+    "print(sliced)\n",
+    "\n",
+    "kopi[2] = \"hei\"\n",
+    "print(kopi)\n",
+    "print(liste1)\n",
+    "print(sliced)\n",
+    "\n",
+    "sliced[0] = \"test\"\n",
+    "print(kopi)\n",
+    "print(liste1)\n",
+    "print(sliced)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Skriv kode her"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Oppgave 5\n",
+    "\n",
+    "I denne oppgaven skal vi lage en forenklet versjon av yatzy"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "*Først trenger vi en funksjon som triller 5 terninger for oss.*\n",
+    "\n",
+    "**a)** Lag en funksjon, `roll_die(n)`,  som lager en liste som inneholder `n`` elementer der hvert element har en tilfeldig tall-verdi mellom 1 og 6."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 41,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[2, 4, 5, 3, 1]\n"
+     ]
+    }
+   ],
+   "source": [
+    "def roll_die(n=5):\n",
+    "    lst = []\n",
+    "\n",
+    "    for i in range(n):\n",
+    "        lst.append(roll_dice())\n",
+    "\n",
+    "    return lst\n",
+    "\n",
+    "print(roll_die())"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "*Videre trenger vi en funksjon for å telle antall forekomster av en gitt verdi, f.eks. enere og toere*\n",
+    "\n",
+    "**b)** Lag en funksjon som tar inn listen med tall og et heltall mellom 1 og 6, og returnerer antallet terninger som har den heltallsverdien "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 42,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2\n",
+      "3\n"
+     ]
+    }
+   ],
+   "source": [
+    "def count_values(lst, value):\n",
+    "    count = 0\n",
+    "\n",
+    "    for element in lst:\n",
+    "        if element == value:\n",
+    "            count += 1\n",
+    "    \n",
+    "    return count\n",
+    "\n",
+    "test = [1, 1, 2, 2, 2, 3, 4, 5]\n",
+    "print(count_values(test, 1))\n",
+    "print(count_values(test, 2))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**c)** Til slutt vil vi kunne spille hele den første delen av et Yatzy-spill\n",
+    "\n",
+    "Lag en funksjon som kaster terningene seks ganger, og gir poeng for antall enere i det første kastet, toere i det andre, osv. \n",
+    "- Print poeng for hvert kast\n",
+    "- Returner summen"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 43,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Du trillet [3, 6, 6, 3, 6]! Det gir deg 0 poeng\n",
+      "Du trillet [5, 1, 6, 2, 6]! Det gir deg 2 poeng\n",
+      "Du trillet [2, 1, 3, 3, 1]! Det gir deg 6 poeng\n",
+      "Du trillet [2, 2, 2, 1, 4]! Det gir deg 4 poeng\n",
+      "Du trillet [3, 2, 4, 1, 2]! Det gir deg 0 poeng\n",
+      "Du trillet [4, 5, 3, 1, 2]! Det gir deg 0 poeng\n",
+      "Totale poeng: 12\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "12"
+      ]
+     },
+     "execution_count": 43,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "def play_yatzy():\n",
+    "    points = 0\n",
+    "\n",
+    "    for i in range(1, 7):\n",
+    "        roll = roll_die()\n",
+    "        count = count_values(roll, i)\n",
+    "        score = count * i\n",
+    "        print(f\"Du trillet {roll}! Det gir deg {score} poeng\")\n",
+    "        points += score\n",
+    "\n",
+    "    print(f\"Totale poeng: {points}\")\n",
+    "    return points\n",
+    "\n",
+    "play_yatzy()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Oppgave 6"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### a) \n",
+    "Lag en funksjon ```create_zero_matrix(dim)``` som tar inn et heltall ```dim``` og som oppretter en kvadratisk tabell (2D-liste) med antall rader og kolonner lik ```dim```. \n",
+    "\n",
+    "Tabellen skal kun inneholde 0 i alle elementer, og funksjonen skal returnere tabellen."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Skriv kode her"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### b)\n",
+    "Lag en funksjon ```create_identity_matrix(dim)``` som, slik som i **a)**, skal returnere en kvadratisk tabell med dimensjon ```dim``` der alle elementer er 0, bortsett fra at elementer på diagonalen skal være 1. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Skriv kode her"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Numpy arrays\n",
+    "Her kommer en liten samling eksempler som dekker det meste av vanlig numpy-bruk"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "\n",
+    "numpy_liste = np.array([0, 1, 2, 3])\n",
+    "vanlig_liste = [0, 1, 2, 3]\n",
+    "\n",
+    "\n",
+    "print(numpy_liste + 2)\n",
+    "# print(vanlig_liste + 2) # Denne gir feilmelding\n",
+    "print(numpy_liste * 2)\n",
+    "print(vanlig_liste * 2)\n",
+    "print(numpy_liste / 2)\n",
+    "# print(vanlig_liste / 2) # Denne gir feilmelding\n",
+    "print(numpy_liste - 2)\n",
+    "# print(vanlig_liste - 2) # Denne gir feilmelding"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Noen eksempler på arange, reshape og transpose"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "a = np.arange(9)\n",
+    "print(\"Original:\\n\", a)\n",
+    "\n",
+    "b = a.reshape(\n",
+    "    3, 3\n",
+    ")  # Lager en ny array b som konverterer fra 1x9 til 3x3 (dimensjonene må \"gå opp\" for at dette skal fungere)\n",
+    "print(\"Reshaped:\\n\", b)\n",
+    "\n",
+    "c = b.T  # Forkortelse for b.transpose()\n",
+    "print(\"Transposed:\\n\", c)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Slicing for å hente ut rader og kolonner fra 2D-arrays (kan også gjøres i N dimensjoner)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "first_column = b[:, 0]  # Henter ut første kolonne i b\n",
+    "print(\"First column:\\n\", first_column)\n",
+    "\n",
+    "first_row = b[0, :]  # Henter ut første rad i b\n",
+    "print(\"First row:\\n\", first_row)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Matrisemultiplikasjon i Numpy"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "a = np.ones((3, 3))  # Lager en 3x3 matrise med 1-ere\n",
+    "\n",
+    "b = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])  # Lager en 3x3 matrise\n",
+    "\n",
+    "c = a * b  # Multipliserer a med b\n",
+    "\n",
+    "d = a @ b  # Matrisemultipliserer a med b\n",
+    "print(a)\n",
+    "print(c)\n",
+    "print(d)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Typecasting"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "a = np.identity(3)  # Lager en 3x3 identitetsmatrise\n",
+    "print(a)\n",
+    "print(a.dtype)\n",
+    "\n",
+    "b = a.astype(\n",
+    "    bool\n",
+    ")  # Konverterer a til en boolsk matrise, lagrer i variabel b (a blir ikke forandret)\n",
+    "print(b)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3.9.7 ('tdt4195')",
+   "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.5"
+  },
+  "vscode": {
+   "interpreter": {
+    "hash": "63b89d9bfc14eb4486c27c9b239bf0a08c4c63a21c176f83036370f0e204c130"
+   }
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}