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",
+ ""
+ ]
+ },
+ {
+ "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
+}