diff --git a/Ovinger/Oving6/Akkorder og toner.ipynb b/Ovinger/Oving6/Akkorder og toner.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..4691db49bf9de7b848d7236a7f2753d0cedeb62e
--- /dev/null
+++ b/Ovinger/Oving6/Akkorder og toner.ipynb
@@ -0,0 +1,454 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": 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=\"_Oving6.ipynb\">Øving 6</a>\n",
+ " </div>\n",
+ " <ul class=\"nav navbar-nav\">\n",
+ " <li ><a href=\"Aksessering.ipynb\">Aksessering av karakter</a></li>\n",
+ " <li ><a href=\"Strenger%20og%20konkatinering.ipynb\">Konkatinering</a></li>\n",
+ " <li ><a href=\"Slicing.ipynb\">Slicing</a></li>\n",
+ " <li ><a href=\"Tekstbehandling.ipynb\">Tekstbehandling</a></li>\n",
+ " <li ><a href=\"Strenghandtering.ipynb\">Strenghåndtering</a></li>\n",
+ " <li ><a href=\"Innebygde%20funksjoner.ipynb\">Innebygde funksjoner og lister</a></li>\n",
+ " <li ><a href=\"Fjesboka.ipynb\">Fjesboka</a></li>\n",
+ " <li class=\"active\"><a href=\"Akkorder%20og%20toner.ipynb\">Akkorder og toner</a></li>\n",
+ " <li ><a href=\"Ideel%20gasslov.ipynb\">Ideel Gasslov</a></li>\n",
+ " <li><a href=\"Sammenhengende%20tallrekke.ipynb\">Sammenhengende Tallrekke</a></li>\n",
+ " <li ><a href=\"Sortering.ipynb\">Sortering</a></li>\n",
+ " <li ><a href=\"Strengmanipulasjon.ipynb\">Strengmanipulasjon</a></li>\n",
+ " <li ><a href=\"Kryptering.ipynb\">Kryptering</a></li>\n",
+ " <li ><a href=\"Litt%20sjakk.ipynb\">Litt Sjakk</a></li>\n",
+ " <li ><a href=\"Lister%20og%20tupler.ipynb\">Lister og tupler</a></li>\n",
+ " </ul>\n",
+ " </div>\n",
+ "</nav>\n",
+ "\n",
+ "# Akkorder og toner\n",
+ "\n",
+ "**Læringsmål:**\n",
+ "\n",
+ "* Løkker\n",
+ "* Lister\n",
+ "\n",
+ " \n",
+ "\n",
+ "I denne oppgaven skal du lage en funksjon som tar inn en akkord som et argument, og returnerer en liste med alle akkordtonene."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "heading_collapsed": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "## Lynkurs i musikkteori"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "hidden": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "I denne oppgaven ser vi i hovedsak kun på akkorder bestående av tre toner. Akkorder består av en grunntone, en ters (den mellomste tonene) og en kvint (den øverste tonen). I akkorden 'C', er grunntonen 'C', tersen er 'E' og kvinten er 'G'.\n",
+ "\n",
+ "For at det skal bli enklere å skjønne hvordan akkorder er satt sammen generelt, bør man dele opp tonene i halvtoner. Dette ser man enkelt på et piano. Der er det alltid en halv tone mellom tangentene som er ved siden av hverandre (når man går til nærmeste tone (svart eller hvit) som ligger opp eller ned).\n",
+ "\n",
+ "En durakkord er bygd opp med at man først starter med grunntonen nederst, så går man en 4 halve toner opp. Da har man den midterste tonen. For å komme til den øverste går man igjen 3 halve toner opp fra den midterste tonen.\n",
+ "\n",
+ "En mollakkord er bygd opp ved å starte på grunntonen, så går man 3 halve toner opp, så 4 halve toner opp derfra.\n",
+ "\n",
+ "Dim (diminished) akkorder er bygd opp av en grunntone, 3 halvtoner, så 3 halvtoner. Til slutt er aug (augmented) bygd opp av grunntone, 4 havltoner, så 4 halvtoner.\n",
+ "\n",
+ "Dette kan man f.eks. lagre i variabler på denne måten:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "hidden": true
+ },
+ "outputs": [],
+ "source": [
+ "major = (4, 3)\n",
+ "minor = (3, 4)\n",
+ "dim = (3, 3)\n",
+ "aug = (4, 4)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "heading_collapsed": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "## Krav til besvarelsen"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "hidden": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Du må støtte alle akkorder fra C til F# i høyre del av kvintsirkelen (C, G, D, A, E, B, F#), og alle akkorder fra F til Gb i venstre del av kvintsirkelen (F, Bb, Eb, Ab, Db, Gb). Altså ned til 6 kryss og 6 b-er. Se illustrasjon av kvintsirkelen under. Her anbefales det å bruker 'B' i stedet for 'H'. For hver akkord skal du støtte både dur, moll, dim og aug.\n",
+ "\n",
+ "Når du finner tonene til en akkord er det også viktig at du finner tonene som hører til tonearten. Når man gir inn akkorden B, skal man derfor helst få\n",
+ "```python\n",
+ ">>> chord_notes('B')\n",
+ "['B', 'D#', 'F#']\n",
+ "```\n",
+ "Og ikke \n",
+ "```python\n",
+ ">>> chord_notes('B')\n",
+ "['B', 'Eb', 'Gb']\n",
+ "```\n",
+ ""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "heading_collapsed": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "## Forslag til notasjon"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "hidden": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Dur noteres uten noe ekstra, f.eks. C, Eb, F#. \n",
+ "Moll noteres med 'm', f.eks. Cm, Ebm, F#m. \n",
+ "Aug noteres med 'aug', f.eks. Caug, Ebaug, F#aug. \n",
+ "Dim noteres med 'dim', f.eks. Cdim, Ebdim, F#dim."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "## a)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Lag funksjonen `get_undertone(chord)` som tar inn en akkord som en streng, og finner grunntonen til akkorden. Funksjonen skal returnere en tuppel der første element er grunntonen, mens det andre element er resten av akkorden.\n",
+ "\n",
+ "**Eksempel på kjøring:**\n",
+ "```python\n",
+ ">>>> get_undertone(\"C\")\n",
+ "('C', '')\n",
+ ">>>> get_undertone(\"Ebdim\")\n",
+ "('Eb', 'dim')\n",
+ "```\n",
+ "\n",
+ "***Skriv koden din i kodeblokken under:***"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2019-07-04T07:15:28.369547Z",
+ "start_time": "2019-07-04T07:15:28.361356Z"
+ }
+ },
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "For å teste koden din kan du kjøre kodeblokken under og se om du får samme output som på eksempelet lenger opp:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "print(get_undertone(\"C\"))\n",
+ "print(get_undertone(\"Ebdim\"))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "## b)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Lag funksjonen `get_tone_list(chord)` som tar inn en akkord og finner hvilken halvdel av kvintsirkelen akkorden hører til. Funksjonen skal returnere en liste med alle halvtonene som finnes i skalaen som hører til denne akkorden. Hvis man tenker seg et piano, skal funksjonen returnere tonenavn med # hvis man gir en akkord der grunntonen er en krysstoneart. Funksjonen returnerer tonenavn med b-er for de svarte tangentene hvis man gir som argument en akkord der grunntonen er en b-toneart. Merk hva som skjer hvis man gir inn en mollakkord: \n",
+ "\n",
+ "**Eksempel på kjøring:**\n",
+ "```python\n",
+ ">>> get_tone_list(\"G\")\n",
+ "['C', 'C#', 'D', 'D#', 'E', 'F', 'F#', 'G', 'G#', 'A', 'A#', 'B']\n",
+ ">>> get_tone_list(\"Cm\")\n",
+ "['C', 'Db', 'D', 'Eb', 'E', 'F', 'Gb', 'G', 'Ab', 'A', 'Bb', 'B']\n",
+ ">>> get_tone_list(\"Ebdim\")\n",
+ "['C', 'Db', 'D', 'Eb', 'E', 'F', 'Gb', 'G', 'Ab', 'A', 'Bb', 'B']\n",
+ "```\n",
+ "\n",
+ "***Skriv koden din i kodeblokken under:***"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "For å teste koden din kan du kjøre kodeblokken under og se om du får samme output som på eksempelet tidligere i oppgaven:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "print(get_tone_list(\"G\"))\n",
+ "print(get_tone_list(\"Cm\"))\n",
+ "print(get_tone_list(\"Ebdim\"))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "## c)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "NÃ¥ skal du lage funksjonen `chord_notes(chord)`, som tar inn en akkord og returnerer en liste med alle akkordtonene\n",
+ "**Eksempel på kjøring:**\n",
+ "```python\n",
+ ">>> chord_notes(\"G\")\n",
+ "['G', 'B', 'D']\n",
+ ">>> chord_notes(\"Cm\")\n",
+ "['C', 'Eb', 'G']\n",
+ ">>> chord_notes(\"Ebdim\")\n",
+ "['Eb', 'Gb', 'A']\n",
+ ">>> chord_notes(\"F#aug\")\n",
+ "['F#', 'A#', 'D']\n",
+ "```\n",
+ "\n",
+ "***Skriv koden din i kodeblokken under:***"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "For å teste at funksjonen din gjør som den skal kan du teste med koden under. Denne er den samme som i eksempelet over og burde gi samme output."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "print(chord_notes(\"G\"))\n",
+ "print(chord_notes(\"Cm\"))\n",
+ "print(chord_notes(\"Ebdim\"))\n",
+ "print(chord_notes(\"F#aug\"))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "## d) Ekstraoppgave (frivillig)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Utvid funksjonen din til å støtte metningstoner, som 6, 7, maj7, sus4 osv. Her kan du f.eks. kreve en notasjon hvor disse tonene kommer etter grunnakkorden separert med komma: f.eks. 'Cm,sus4,7' og 'Eb,7,#9,11'. Det er stor variasjon på hva som brukes i akkordnotasjon så det står du fritt til å velge.\n",
+ "\n",
+ "***Skriv koden din i kodeblokken under og sjekk at den fungerer:***"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ }
+ ],
+ "metadata": {
+ "celltoolbar": "Edit Metadata",
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.7.4"
+ },
+ "toc": {
+ "base_numbering": 1,
+ "nav_menu": {},
+ "number_sections": false,
+ "sideBar": true,
+ "skip_h1_title": false,
+ "title_cell": "Table of Contents",
+ "title_sidebar": "Contents",
+ "toc_cell": false,
+ "toc_position": {},
+ "toc_section_display": true,
+ "toc_window_display": false
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/Ovinger/Oving6/Aksessering.ipynb b/Ovinger/Oving6/Aksessering.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..a5a6c499182e42c25cfb78d12a41fed64e8e7ba0
--- /dev/null
+++ b/Ovinger/Oving6/Aksessering.ipynb
@@ -0,0 +1,357 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": 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=\"_Oving6.ipynb\">Øving 6</a>\n",
+ " </div>\n",
+ " <ul class=\"nav navbar-nav\">\n",
+ " <li class=\"active\"><a href=\"Aksessering.ipynb\">Aksessering av karakter</a></li>\n",
+ " <li ><a href=\"Strenger%20og%20konkatinering.ipynb\">Konkatinering</a></li>\n",
+ " <li ><a href=\"Slicing.ipynb\">Slicing</a></li>\n",
+ " <li ><a href=\"Tekstbehandling.ipynb\">Tekstbehandling</a></li>\n",
+ " <li ><a href=\"Strenghandtering.ipynb\">Strenghåndtering</a></li>\n",
+ " <li ><a href=\"Innebygde%20funksjoner.ipynb\">Innebygde funksjoner og lister</a></li>\n",
+ " <li><a href=\"Fjesboka.ipynb\">Fjesboka</a></li>\n",
+ " <li ><a href=\"Akkorder%20og%20toner.ipynb\">Akkorder og toner</a></li>\n",
+ " <li ><a href=\"Ideel%20gasslov.ipynb\">Ideel Gasslov</a></li>\n",
+ " <li><a href=\"Sammenhengende%20tallrekke.ipynb\">Sammenhengende Tallrekke</a></li>\n",
+ " <li ><a href=\"Sortering.ipynb\">Sortering</a></li>\n",
+ " <li ><a href=\"Strengmanipulasjon.ipynb\">Strengmanipulasjon</a></li>\n",
+ " <li ><a href=\"Kryptering.ipynb\">Kryptering</a></li>\n",
+ " <li ><a href=\"Litt%20sjakk.ipynb\">Litt Sjakk</a></li>\n",
+ " <li ><a href=\"Lister%20og%20tupler.ipynb\">Lister og tupler</a></li>\n",
+ " </ul>\n",
+ " </div>\n",
+ "</nav>\n",
+ "\n",
+ "# Aksessering av karakterer i en streng\n",
+ "\n",
+ "**Læringsmål:**\n",
+ "\n",
+ "* Strenger\n",
+ "* Funksjoner\n",
+ "\n",
+ "Denne oppgaven handler om hvordan man får tak i og returnerer karakterer i en streng."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "heading_collapsed": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "### Generelt om aksessering"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "hidden": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "**Ã… iterere over strenger:**\n",
+ "\n",
+ "Man kan lett iterere over en streng ved hjelp av en for-løkke. Den generelle formen for dette er:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "hidden": true
+ },
+ "outputs": [],
+ "source": [
+ "for character in string:\n",
+ " # do something"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "hidden": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "For hver iterasjon vil character-variabelen referere til en karakter i string, og den vil starte med å referere til den første karakteren. Vi sier at løkken itererer over strengen. Prøv å kjør koden under."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "hidden": true
+ },
+ "outputs": [],
+ "source": [
+ "name = \"Bob Bernt\"\n",
+ "for ch in name:\n",
+ " print(ch)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "hidden": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "**Indeks:**\n",
+ "\n",
+ "Å iterere over en streng med for-løkke er en måte å aksessere hver enkelt karakter i en streng. En annen måte for å aksessere karakterene i en streng på er å bruke indeks. Alle karakterene i en streng har hver sin indeks knyttet til deres plassering i strengen:\n",
+ "\n",
+ "\n",
+ "\n",
+ "Som man kan se på bildet, starter indekseringen med 0, akkurat som for lister. For å få tak i en av karakterene og tilordne den til en variabel, skriver man\n",
+ "ch = my_string[3],\n",
+ "dette vil tilordne ch til 'e'.\n",
+ "\n",
+ "Hver karakter i strengen kan aksesseres vha. to tall: et positivt og et negativt. Om man skal ha tak i siste karakter i strengen kan man enten bruke 12 eller -1 som indeks, dvs. både \n",
+ "'ch = my_string [12]' og 'ch = my_string[-1]' vil tilordne ch til 'd'. Tilsvarende vil 1 og -12 begge være indekser for 'o' i my_string."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "hidden": true
+ },
+ "outputs": [],
+ "source": [
+ "#prøv å kjøre koden\n",
+ "my_string = 'Roses are red'\n",
+ " \n",
+ "for i in range(5):\n",
+ " print(my_string[i])\n",
+ " \n",
+ "for j in range(-7,0,1):\n",
+ " print(my_string[j])"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "### a)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Skriv en funksjon som tar inn en streng, itererer over denne, og skriver ut hver enkelt karakter til skjerm.\n",
+ "\n",
+ "**Eksempel på kjøring**:\n",
+ "\n",
+ "```python\n",
+ "#Argumentet er `Nilfgaard`\n",
+ "N\n",
+ "i\n",
+ "l\n",
+ "f\n",
+ "g\n",
+ "a\n",
+ "a\n",
+ "r\n",
+ "d\n",
+ "```\n",
+ "\n",
+ "***Skriv inn koden din i kodeblokken under:***"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "### b)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Skriv en funksjon `third_letter(string)` som tar inn en streng og returnerer den tredje bokstaven i strengen. Om lengden til strengen ikke er stor nok, skal funksjonen returnere 'q'.\n",
+ "\n",
+ "***Skriv inn koden din i kodeblokken under:***"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Dersom du har implementert funksjonen rett, sjekk om koden under gir forventet resultat:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2019-07-03T11:55:51.890746Z",
+ "start_time": "2019-07-03T11:55:51.579310Z"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "print(third_letter(\"Temeria\")) #skal gi \"m\"\n",
+ "print(third_letter(\"IT\")) #skal printe ut \"q\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "### c)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Skriv en funksjon som tar inn en streng og returnerer største gyldige indeks, dvs. den største indeksen som ikke gir IndexError.\n",
+ "\n",
+ "**Eksempel på kjøring:**\n",
+ "```python\n",
+ "#Argumentet er \"The White Wolf\"\n",
+ "13\n",
+ " \n",
+ "#Argumentet er \"Redania\"\n",
+ "6\n",
+ "```\n",
+ "\n",
+ "***Skriv koden i kodeblokken under:***"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2019-07-03T12:03:11.713595Z",
+ "start_time": "2019-07-03T12:03:11.706770Z"
+ }
+ },
+ "outputs": [],
+ "source": []
+ }
+ ],
+ "metadata": {
+ "celltoolbar": "Edit Metadata",
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.7.4"
+ },
+ "toc": {
+ "base_numbering": 1,
+ "nav_menu": {},
+ "number_sections": false,
+ "sideBar": true,
+ "skip_h1_title": false,
+ "title_cell": "Table of Contents",
+ "title_sidebar": "Contents",
+ "toc_cell": false,
+ "toc_position": {},
+ "toc_section_display": true,
+ "toc_window_display": false
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/Ovinger/Oving6/Fjesboka.ipynb b/Ovinger/Oving6/Fjesboka.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..c34dc99835f05fb7b7f821326aa0bb74e6b5a33e
--- /dev/null
+++ b/Ovinger/Oving6/Fjesboka.ipynb
@@ -0,0 +1,319 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": 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=\"_Oving6.ipynb\">Øving 6</a>\n",
+ " </div>\n",
+ " <ul class=\"nav navbar-nav\">\n",
+ " <li ><a href=\"Aksessering.ipynb\">Aksessering av karakter</a></li>\n",
+ " <li ><a href=\"Strenger%20og%20konkatinering.ipynb\">Konkatinering</a></li>\n",
+ " <li ><a href=\"Slicing.ipynb\">Slicing</a></li>\n",
+ " <li ><a href=\"Tekstbehandling.ipynb\">Tekstbehandling</a></li>\n",
+ " <li ><a href=\"Strenghandtering.ipynb\">Strenghåndtering</a></li>\n",
+ " <li ><a href=\"Innebygde%20funksjoner.ipynb\">Innebygde funksjoner og lister</a></li>\n",
+ " <li class=\"active\"><a href=\"Fjesboka.ipynb\">Fjesboka</a></li>\n",
+ " <li ><a href=\"Akkorder%20og%20toner.ipynb\">Akkorder og toner</a></li>\n",
+ " <li ><a href=\"Ideel%20gasslov.ipynb\">Ideel Gasslov</a></li>\n",
+ " <li><a href=\"Sammenhengende%20tallrekke.ipynb\">Sammenhengende Tallrekke</a></li>\n",
+ " <li ><a href=\"Sortering.ipynb\">Sortering</a></li>\n",
+ " <li ><a href=\"Strengmanipulasjon.ipynb\">Strengmanipulasjon</a></li>\n",
+ " <li ><a href=\"Kryptering.ipynb\">Kryptering</a></li>\n",
+ " <li ><a href=\"Litt%20sjakk.ipynb\">Litt Sjakk</a></li>\n",
+ " <li ><a href=\"Lister%20og%20tupler.ipynb\">Lister og tupler</a></li>\n",
+ " </ul>\n",
+ " </div>\n",
+ "</nav>\n",
+ "\n",
+ "# Fjesboka\n",
+ "\n",
+ "**Læringsmål:**\n",
+ "\n",
+ "* Lister\n",
+ "* Input\n",
+ "* Strenger\n",
+ "\n",
+ " \n",
+ "I denne oppgaven skal du ta inn informasjon fra brukere på et gitt format, lagre dataen i lister og gjøre det mulig for brukeren å hente ut denne informasjonen igjen. "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "## a)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Skriv en funksjon `add_data(user)` som skal ta inn en streng `user` på formatet: \"given_name surname age gender relationship_status\" og returnere dette i en liste.\n",
+ "\n",
+ "Merk at alder skal lagres som en int, mens resten lagres som strenger. (Alder vil alltid ha indeks 2 i listen.)\n",
+ "\n",
+ "**Eksempel på kjøring av kode**\n",
+ "\n",
+ "```python\n",
+ "print(add_data(\"Mark Zuckerberg 32 Male Married\"))\n",
+ "skrives ut -> [\"Mark\", \"Zuckerberg\", 32, \"Male\", \"Married\"]\n",
+ "```\n",
+ "\n",
+ "***Skriv koden din i kodeblokken under:***"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2019-07-04T06:43:54.994924Z",
+ "start_time": "2019-07-04T06:43:54.907411Z"
+ }
+ },
+ "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": [
+ "Den innebygde funksjonen `.split()` returnerer en liste bestående av ordene i en streng."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## b)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Skriv en funksjon `get_person(given_name, facebook)` som tar inn et fornavn \"given_name\" og en liste \"facebook\" bestående av mange lister på formatet definert av `add_data(user)` og returnerer en liste bestående av alle personer med fornavnet **given_name.** \n",
+ "\n",
+ "```python\n",
+ "facebook = [[\"Mark\", \"Zuckerberg\", 32, \"Male\", \"Married\"], \n",
+ " [\"Therese\", \"Johaug\", 28, \"Female\", \"Complicated\"],\n",
+ " [\"Mark\", \"Wahlberg\", 45, \"Male\", \"Married\"],\n",
+ " [\"Siv\", \"Jensen\", 47, \"Female\", \"Single\"]]\n",
+ "print(get_person(\"Mark\", facebook))\n",
+ "skrives ut -> [[\"Mark\", \"Zuckerberg\", 32, \"Male\", \"Married\"], [\"Mark\", \"Wahlberg\", 45, \"Male\", \"Married\"]]\n",
+ "```\n",
+ "\n",
+ "***Skriv koden din i kodeblokken under:***"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Du kan teste ut funksjonen din med kodeblokken under, (men husk å kjøre kodeblokken din over som inneholder funksjonen først)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "facebook = [[\"Mark\", \"Zuckerberg\", 32, \"Male\", \"Married\"], \n",
+ " [\"Therese\", \"Johaug\", 28, \"Female\", \"Complicated\"],\n",
+ " [\"Mark\", \"Wahlberg\", 45, \"Male\", \"Married\"],\n",
+ " [\"Siv\", \"Jensen\", 47, \"Female\", \"Single\"]]\n",
+ "print(get_person(\"Mark\", facebook))"
+ ]
+ },
+ {
+ "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-04T06:55:59.727092Z",
+ "start_time": "2019-07-04T06:55:59.716757Z"
+ },
+ "deletable": false,
+ "editable": false,
+ "hidden": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Fornavnet (indeks = 0) på den første personen (indeks = 0) i listen `facebook` kan finnes ved å skrive `facebook[0][0]`.\n",
+ "Det er mulig å iterere gjennom listen `facebook` i stedet for å bruke `facebook[m][n]`, der `m` og `n` er heltall."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "## c)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Skriv funksjonen **main()** som lar brukeren legge til flere personer i en liste.\n",
+ "\n",
+ "Dette gjøres ved å be brukeren om å legge til en **user** på formen \"given_name surname age gender relationship_status\" så lenge svaret ikke er \"done\".\n",
+ "\n",
+ "Disse skal legges inn i en liste **facebook** ved hjelp av funksjonen `add_data(user)`.\n",
+ "\n",
+ "Hvis svaret er \"done\" blir brukeren sendt videre til neste steg. \n",
+ "\n",
+ "Deretter skal brukeren kunne printe ut informasjon om brukerene fra listen basert på fornavn ved hjelp av funksjonen `get_person(given_name)`. \n",
+ "\n",
+ "Hvis svaret er \"done\" er programmet ferdig.\n",
+ "\n",
+ "(Du kan velge om du vil printe ut listene eller skrive en melding til brukeren som vist i eksempelet under)\n",
+ "\n",
+ "Test programmet ved å kjøre **main()**. \n",
+ "\n",
+ "**Eksempel på kjøring av kode:**\n",
+ "\n",
+ "```\n",
+ "Hello, welcome to Facebook. Add a new user by writing \"given_name surname age gender relationship_status\".\n",
+ "Add a new user: Therese Johaug 29 Female Complicated\n",
+ "Add a new user: Mark Zuckerberg 33 Male Married\n",
+ "Add a new user: done\n",
+ "Ok\n",
+ "Search for a user: Therese\n",
+ "Therese Johaug is 29 years old, her relationship status is Complicated.\n",
+ "Search for a user: Alf\n",
+ "[]\n",
+ "Search for a user: Mark\n",
+ "Mark Zuckerberg is 33 years old, his relationship status is Married.\n",
+ "Search for a user: done\n",
+ "```\n",
+ "\n",
+ "***Skriv koden din i kodeblokken under:***"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ }
+ ],
+ "metadata": {
+ "celltoolbar": "Edit Metadata",
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.7.4"
+ },
+ "toc": {
+ "base_numbering": 1,
+ "nav_menu": {},
+ "number_sections": false,
+ "sideBar": true,
+ "skip_h1_title": false,
+ "title_cell": "Table of Contents",
+ "title_sidebar": "Contents",
+ "toc_cell": false,
+ "toc_position": {},
+ "toc_section_display": true,
+ "toc_window_display": false
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/Ovinger/Oving6/Ideel gasslov.ipynb b/Ovinger/Oving6/Ideel gasslov.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..88a87551d4491c4475df39c921e4da97d47db400
--- /dev/null
+++ b/Ovinger/Oving6/Ideel gasslov.ipynb
@@ -0,0 +1,354 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": 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=\"_Oving6.ipynb\">Øving 6</a>\n",
+ " </div>\n",
+ " <ul class=\"nav navbar-nav\">\n",
+ " <li ><a href=\"Aksessering.ipynb\">Aksessering av karakter</a></li>\n",
+ " <li ><a href=\"Strenger%20og%20konkatinering.ipynb\">Konkatinering</a></li>\n",
+ " <li ><a href=\"Slicing.ipynb\">Slicing</a></li>\n",
+ " <li ><a href=\"Tekstbehandling.ipynb\">Tekstbehandling</a></li>\n",
+ " <li ><a href=\"Strenghandtering.ipynb\">Strenghåndtering</a></li>\n",
+ " <li ><a href=\"Innebygde%20funksjoner.ipynb\">Innebygde funksjoner og lister</a></li>\n",
+ " <li ><a href=\"Fjesboka.ipynb\">Fjesboka</a></li>\n",
+ " <li ><a href=\"Akkorder%20og%20toner.ipynb\">Akkorder og toner</a></li>\n",
+ " <li class=\"active\"><a href=\"Ideel%20gasslov.ipynb\">Ideel Gasslov</a></li>\n",
+ " <li><a href=\"Sammenhengende%20tallrekke.ipynb\">Sammenhengende Tallrekke</a></li>\n",
+ " <li ><a href=\"Sortering.ipynb\">Sortering</a></li>\n",
+ " <li ><a href=\"Strengmanipulasjon.ipynb\">Strengmanipulasjon</a></li>\n",
+ " <li ><a href=\"Kryptering.ipynb\">Kryptering</a></li>\n",
+ " <li ><a href=\"Litt%20sjakk.ipynb\">Litt Sjakk</a></li>\n",
+ " <li ><a href=\"Lister%20og%20tupler.ipynb\">Lister og tupler</a></li>\n",
+ " </ul>\n",
+ " </div>\n",
+ "</nav>\n",
+ "\n",
+ "# Ideel gasslov\n",
+ "\n",
+ "**Læringsmål:**\n",
+ "\n",
+ "* Lister\n",
+ "* Strenger\n",
+ "* Løkker\n",
+ "* Funksjoner\n",
+ "* Numpy\n",
+ "* Plotting\n",
+ "\n",
+ " \n",
+ "\n",
+ "I gasser kan man ikke endre på trykk (p), temperatur (T) og volum (V) uavhengig av hverandre. I ideelle gasser kan man uttrykke sammenhengen mellom disse størrelsene ved uttrykket\n",
+ "\n",
+ "**$pV=nRT$**\n",
+ "\n",
+ "Her er p trykk i Pa, V er volum i $m^{3}$, n er antall mol, R er 8.31452 J/Kmol, og T er absolutt temperatur i K.\n",
+ "\n",
+ "I denne oppgaven skal vi lage et program som regner ut trykket (p) ved forskjellige volum og temperaturer, og setter opp dette i en fin tabell."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "## a)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Lag funksjonen `p_ig(t, v, n, rgas=8.31452)` som tar inn argumentene t (temperatur), v (volum), n (antall mol) og konstanten rgas (R). Funksjonen skal returnere trykket (p).\n",
+ "\n",
+ "**Eksempel på kjøring:**\n",
+ "```python\n",
+ "# Legg merke til at man IKKE trenger å sende inn en konstant for rgas (men man kan om man ønsker),\n",
+ "# siden denne blir satt til 8.31452 om det ikke blir gitt et argument\n",
+ "print(p_ig(373.15,2.4,100))\n",
+ "utskrift -> 129273.46408333334\n",
+ "print(p_ig(293,24*10**(-3),1))\n",
+ "utskrift -> 101506.43166666667\n",
+ "```\n",
+ "\n",
+ "***Skriv koden din i kodeblokken under:***"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "For å teste funksjonen din kan du kjøre testkoden under. (etter du har kjørt kodeblokken med funksjonen din). Koden under er den samme som eksempelet i starten av oppgaven og burde gi samme output."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "print(p_ig(373.15,2.4,100))\n",
+ "print(p_ig(293,24*10**(-3),1))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "## b)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Lag funksjonen `p_ig_pptable` som tar inn en numpy-array med forskjellige volum, en numpy-array med temperaturer, og en konstant for antall mol. Funksjonen skal returnere en tabell (2D-numpy-array) der volumet inngår i den første kolonnen og trykkene i de neste kolonnene.\n",
+ "\n",
+ "**Eksempel på kjøring**\n",
+ "```python\n",
+ "nv = 10 # number of volumes (rows)\n",
+ "nt = 3 # number of temperatures (columns)\n",
+ "n = 10 # [mol]\n",
+ "t = np.array([100 + float(j)*200 for j in range(nt)]) # [K]\n",
+ "v = np.array([10**(-float(i)/nv) for i in range(1, nv+1)])\n",
+ "```\n",
+ "```python\n",
+ "table = p_ig_pptable(v,t,n)\n",
+ "print(table)\n",
+ "```\n",
+ "Skal gi utskriften ->\n",
+ "```python\n",
+ "[[0.7943282347242815, 10467.36051487084, 31402.08154461252, 52336.802574354195], [0.6309573444801932, 13177.626146581779, 39532.878439745335, 65888.13073290889], [0.5011872336272722, 16589.648423055052, 49768.94526916515, 82948.24211527525], [0.3981071705534972, 20885.12997251504, 62655.389917545115, 104425.64986257518], [0.31622776601683794, 26292.820851023193, 78878.46255306958, 131464.10425511596], [0.251188643150958, 33100.70031710464, 99302.10095131393, 165503.5015855232], [0.19952623149688797, 41671.31277738628, 125013.93833215884, 208356.56388693137], [0.15848931924611134, 52461.074598274565, 157383.22379482372, 262305.37299137283], [0.12589254117941673, 66044.57994179733, 198133.739825392, 330222.89970898663], [0.1, 83145.2, 249435.6, 415725.99999999994]]\n",
+ "```\n",
+ "\n",
+ "***Skriv funksjonen din på markert plass under og sjekk at du får samme svar som i eksempelet:***"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import numpy as np\n",
+ "\n",
+ "# SKRIV FUNKSJONEN DIN HER\n",
+ "\n",
+ "nv = 10 # number of volumes (rows)\n",
+ "nt = 3 # number of temperatures (columns)\n",
+ "n = 10 # [mol]\n",
+ "t = np.array([100 + float(j)*200 for j in range(nt)]) # [K]\n",
+ "v = np.array([10**(-float(i)/nv) for i in range(1, nv+1)])\n",
+ "\n",
+ "table = p_ig_pptable(v,t,n)\n",
+ "print(table) "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "## c)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Utskriften fra oppgave b) er ikke særlig fin. Du skal derfor nå skrive ferdig koden i Kodesnutt, slik at det blir skrevet ut en fin tabell lignende den i eksempelet nedenfor.\n",
+ "\n",
+ "**Eksempel på kjøring:**\n",
+ "```python\n",
+ "| Volum (m^3) | Temp. = 100.0K | Temp. = 300.0K | Temp. = 500.0K |\n",
+ "-----------------------------------------------------------------------------------------\n",
+ "| 0.7943282347242815 | 10467.36051487084 | 31402.08154461252 | 52336.802574354195 |\n",
+ "\n",
+ "| 0.6309573444801932 | 13177.626146581779 | 39532.878439745335 | 65888.13073290889 |\n",
+ "\n",
+ "| 0.5011872336272722 | 16589.648423055052 | 49768.94526916515 | 82948.24211527525 |\n",
+ "\n",
+ "| 0.3981071705534972 | 20885.12997251504 | 62655.389917545115 | 104425.64986257518 |\n",
+ " \n",
+ "| 0.31622776601683794 | 26292.820851023193 | 78878.46255306958 | 131464.10425511596 |\n",
+ " \n",
+ "| 0.251188643150958 | 33100.70031710464 | 99302.10095131393 | 165503.5015855232 |\n",
+ " \n",
+ "| 0.19952623149688797 | 41671.31277738628 | 125013.93833215884 | 208356.56388693137 |\n",
+ " \n",
+ "| 0.15848931924611134 | 52461.074598274565 | 157383.22379482372 | 262305.37299137283 |\n",
+ " \n",
+ "| 0.12589254117941673 | 66044.57994179733 | 198133.739825392 | 330222.89970898663 |\n",
+ " \n",
+ "| 0.1 | 83145.2 | 249435.6 | 415725.99999999994 |\n",
+ "```\n",
+ "\n",
+ "***Skriv koden din på angitt plass i kodeblokken under:***"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "nv = 10 # number of volumes (rows) [-]\n",
+ "nt = 3 # number of temperatures (columns) [-]\n",
+ " \n",
+ "# Variables.\n",
+ "n = 10 # [mol]\n",
+ "t = [100 + float(j)*200 for j in range(nt)] # [K]\n",
+ "v = [10**(-float(i)/nv) for i in range(1, nv+1)]\n",
+ " \n",
+ "table = p_ig_pptable(v,t,n)\n",
+ " \n",
+ "print(\"| Volum (m^3)\".ljust(21),\"|\",(\"Temp. = \"+str(t[0])+\"K\").ljust(19),\"|\",(\"Temp. = \"+str(t[1])+\"K\").ljust(19),\"|\",(\"Temp. = \"+str(t[2])+\"K\").ljust(19),\"|\")\n",
+ "print(\"-\"*89)\n",
+ " \n",
+ "#SKRIV DIN KODE HER"
+ ]
+ },
+ {
+ "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": [
+ "Bruk dobbel for-løkke, str.ljust og end=' '"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## d)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "For å forstå sammenhengen mellom temperatur, volum og trykk, så kan det være en fordel å plotte den. Lag et plot med verdiene fra \"table\" der du har volum på x-aksen, trykk på y-aksen. Plottet skal bestå av tre grafer for hver av de tre temperaturene. Man skal også i plottet enkelt se hva som er langs x- og y-aksene, samt hvilken temperatur de tre grafene tilhører. Husk å importere matplotlib.pyplot."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# SKRIV DIN KODE HER"
+ ]
+ }
+ ],
+ "metadata": {
+ "celltoolbar": "Edit Metadata",
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.7.4"
+ },
+ "toc": {
+ "base_numbering": 1,
+ "nav_menu": {},
+ "number_sections": false,
+ "sideBar": true,
+ "skip_h1_title": false,
+ "title_cell": "Table of Contents",
+ "title_sidebar": "Contents",
+ "toc_cell": false,
+ "toc_position": {},
+ "toc_section_display": true,
+ "toc_window_display": false
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/Ovinger/Oving6/Innebygde funksjoner.ipynb b/Ovinger/Oving6/Innebygde funksjoner.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..1446f08b779cf660fcca3165ac3dd6fa7021b301
--- /dev/null
+++ b/Ovinger/Oving6/Innebygde funksjoner.ipynb
@@ -0,0 +1,337 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": 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=\"_Oving6.ipynb\">Øving 6</a>\n",
+ " </div>\n",
+ " <ul class=\"nav navbar-nav\">\n",
+ " <li ><a href=\"Aksessering.ipynb\">Aksessering av karakter</a></li>\n",
+ " <li ><a href=\"Strenger%20og%20konkatinering.ipynb\">Konkatinering</a></li>\n",
+ " <li ><a href=\"Slicing.ipynb\">Slicing</a></li>\n",
+ " <li ><a href=\"Tekstbehandling.ipynb\">Tekstbehandling</a></li>\n",
+ " <li ><a href=\"Strenghandtering.ipynb\">Strenghåndtering</a></li>\n",
+ " <li class=\"active\"><a href=\"Innebygde%20funksjoner.ipynb\">Innebygde funksjoner og lister</a></li>\n",
+ " <li><a href=\"Fjesboka.ipynb\">Fjesboka</a></li>\n",
+ " <li ><a href=\"Akkorder%20og%20toner.ipynb\">Akkorder og toner</a></li>\n",
+ " <li ><a href=\"Ideel%20gasslov.ipynb\">Ideel Gasslov</a></li>\n",
+ " <li><a href=\"Sammenhengende%20tallrekke.ipynb\">Sammenhengende Tallrekke</a></li>\n",
+ " <li ><a href=\"Sortering.ipynb\">Sortering</a></li>\n",
+ " <li ><a href=\"Strengmanipulasjon.ipynb\">Strengmanipulasjon</a></li>\n",
+ " <li ><a href=\"Kryptering.ipynb\">Kryptering</a></li>\n",
+ " <li ><a href=\"Litt%20sjakk.ipynb\">Litt Sjakk</a></li>\n",
+ " <li ><a href=\"Lister%20og%20tupler.ipynb\">Lister og tupler</a></li>\n",
+ " </ul>\n",
+ " </div>\n",
+ "</nav>\n",
+ "\n",
+ "# Innebygde funksjoner og lister\n",
+ "\n",
+ "**Læringsmål:**\n",
+ "\n",
+ "* Lister\n",
+ "* Innebygde funksjoner\n",
+ "\n",
+ " \n",
+ "\n",
+ "I denne oppgaven skal vi bruke innebygde funksjoner i Python til å behandle lister. \n",
+ "\n",
+ "Du finner informasjon og nyttige metoder [her](https://docs.python.org/3/tutorial/datastructures.html). (bruk disse!)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "### a)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Opprett en liste random_numbers bestående av 100 tilfeldige heltall fra 1 til og med 10.\n",
+ "\n",
+ "**Eksempel på slik liste:**\n",
+ "```python\n",
+ "[9, 7, 4, 3, 2, 3, 9, 4, 4, 1, 1, 3, 4, 9, 5, 5, 3, 4, 7, 8, 9, 4, 6, 6, 1, 6, 5, 7, 2, 5, 7, 1, 9, 4, 9, 6, 1, 1, 1, 5, 6, 5, 9, 10, 5, 7, 4, 4, 10, 4, 4, 8, 1, 5, 4, 9, 5, 5, 2, 8, 10, 8, 1, 5, 10, 8, 3, 3, 7, 7, 6, 3, 3, 3, 4, 9, 4, 8, 4, 6, 1, 10, 3, 6, 5, 7, 10, 9, 9, 1, 10, 3, 2, 3, 6, 9, 8, 3, 2, 5]\n",
+ "```\n",
+ "\n",
+ "***Skriv koden din i kodeblokken under:***"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2019-07-04T06:23:49.753780Z",
+ "start_time": "2019-07-04T06:23:49.747792Z"
+ }
+ },
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "### b)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Skriv kode for å finne antall forekomster av tallet **2** i listen.\n",
+ "\n",
+ "**Eksempel på kjøring for listen i a):**\n",
+ "\n",
+ "```python\n",
+ "Number of 2s: 5\n",
+ "```\n",
+ "\n",
+ "***Skriv koden din i kodeblokken under:***"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "### c)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Skriv ut summen av alle tallene i listen.\n",
+ "\n",
+ "**Eksempel på kjøring for listen i a):**\n",
+ "```python\n",
+ "Sum of numbers: 529\n",
+ "```\n",
+ "\n",
+ "***Skriv koden din i kodeblokken under:***"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "### d)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2019-07-04T06:31:17.550677Z",
+ "start_time": "2019-07-04T06:31:17.541661Z"
+ },
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Sorter listen i stigende rekkefølge.\n",
+ "\n",
+ "**Eksempel på kjøring for listen i a):**\n",
+ "```python\n",
+ "Numbers sorted: [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 10, 10, 10, 10, 10, 10, 10]\n",
+ "```\n",
+ "\n",
+ "***Skriv koden din i kodeblokken under:***"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "### e)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Skriv ut typetallet. (Det tallet det er flest forekomster av i listen)\n",
+ "\n",
+ "**Eksempel på kjøring for listen i a):**\n",
+ "```python\n",
+ "There are most of number: 4\n",
+ "```\n",
+ "\n",
+ "***Skriv koden din i kodeblokken under:***"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "### f)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Skriv ut listen baklengs.\n",
+ "\n",
+ "**Eksempel på kjøring for listen i a):**\n",
+ "```python\n",
+ "Numbers reversed: [10, 10, 10, 10, 10, 10, 10, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 8, 8, 8, 8, 8, 8, 8, 7, 7, 7, 7, 7, 7, 7, 7, 6, 6, 6, 6, 6, 6, 6, 6, 6, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]\n",
+ "```\n",
+ "\n",
+ "***Skriv koden din i kodeblokken under:***"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ }
+ ],
+ "metadata": {
+ "celltoolbar": "Edit Metadata",
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.7.4"
+ },
+ "toc": {
+ "base_numbering": 1,
+ "nav_menu": {},
+ "number_sections": false,
+ "sideBar": true,
+ "skip_h1_title": false,
+ "title_cell": "Table of Contents",
+ "title_sidebar": "Contents",
+ "toc_cell": false,
+ "toc_position": {},
+ "toc_section_display": true,
+ "toc_window_display": false
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/Ovinger/Oving6/Kryptering.ipynb b/Ovinger/Oving6/Kryptering.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..f81b39f3140520d6d4abb558b52ec38ac1ddaca3
--- /dev/null
+++ b/Ovinger/Oving6/Kryptering.ipynb
@@ -0,0 +1,338 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": 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=\"_Oving6.ipynb\">Øving 6</a>\n",
+ " </div>\n",
+ " <ul class=\"nav navbar-nav\">\n",
+ " <li ><a href=\"Aksessering.ipynb\">Aksessering av karakter</a></li>\n",
+ " <li ><a href=\"Strenger%20og%20konkatinering.ipynb\">Konkatinering</a></li>\n",
+ " <li ><a href=\"Slicing.ipynb\">Slicing</a></li>\n",
+ " <li ><a href=\"Tekstbehandling.ipynb\">Tekstbehandling</a></li>\n",
+ " <li ><a href=\"Strenghandtering.ipynb\">Strenghåndtering</a></li>\n",
+ " <li ><a href=\"Innebygde%20funksjoner.ipynb\">Innebygde funksjoner og lister</a></li>\n",
+ " <li ><a href=\"Fjesboka.ipynb\">Fjesboka</a></li>\n",
+ " <li ><a href=\"Akkorder%20og%20toner.ipynb\">Akkorder og toner</a></li>\n",
+ " <li><a href=\"Ideel%20gasslov.ipynb\">Ideel Gasslov</a></li>\n",
+ " <li><a href=\"Sammenhengende%20tallrekke.ipynb\">Sammenhengende Tallrekke</a></li>\n",
+ " <li ><a href=\"Sortering.ipynb\">Sortering</a></li>\n",
+ " <li ><a href=\"Strengmanipulasjon.ipynb\">Strengmanipulasjon</a></li>\n",
+ " <li class=\"active\"><a href=\"Kryptering.ipynb\">Kryptering</a></li>\n",
+ " <li ><a href=\"Litt%20sjakk.ipynb\">Litt Sjakk</a></li>\n",
+ " <li ><a href=\"Lister%20og%20tupler.ipynb\">Lister og tupler</a></li>\n",
+ " </ul>\n",
+ " </div>\n",
+ "</nav>\n",
+ "\n",
+ "# Kryptering\n",
+ "\n",
+ "**Læringsmål:**\n",
+ "\n",
+ "* Lister\n",
+ "* Tekstbehandling\n",
+ "* Nettverkssikkerhet \n",
+ "\n",
+ "\n",
+ "James Bond er på et topphemmelig oppdrag i Langtvekkistan for MI6. Han ønsker å kunne kommunisere med oppdragsgiveren sin via internett, men myndighetene i Langtvekkistan overvåker alt som sendes over nett i landet. Derfor må Bond og MI6 bruke noe som heter [kryptering](https://www.datatilsynet.no/regelverk-og-skjema/behandle-personopplysninger/kryptering/) (datatilsynet) når de kommuniserer, slik at de vet at ingen andre kan lese meldingene de sender seg i mellom. Oppdraget ditt er nå å lage denne krypteringen og for å gjøre det bruker vi en metode kalt \"[One-time pad](https://en.wikipedia.org/wiki/One-time_pad)\". Den fungerer slik: \n",
+ "\n",
+ "Krypteringen foregår ved at man har en melding M og en nøkkel K, og regner ut C definert under: \n",
+ "\n",
+ "* m = bokstav i ordet M\n",
+ "* k = hemmelig bokstav fra ordet K\n",
+ "* c = m [XOR](https://en.wikipedia.org/wiki/Exclusive_or) k (den krypterte bokstaven i C)\n",
+ "(dvs. 1101 XOR 1011 = 0110)\n",
+ "\n",
+ "For å dekryptere meldingen kan vi ved hjelp av passordet gjøre den motsatte operasjonen i og med at:\n",
+ "\n",
+ "* m = c XOR k\n",
+ "\n",
+ "Du kan fritt bruke disse hjelpefunksjoner i oppgaven:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2019-07-04T08:47:20.839175Z",
+ "start_time": "2019-07-04T08:47:20.824023Z"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "import binascii\n",
+ " \n",
+ "def toHex(word):\n",
+ " return int(str(binascii.hexlify(word), 'ascii'), 16)\n",
+ " \n",
+ "def toString(word):\n",
+ " return str(binascii.unhexlify(hex(word)[2:]), 'ascii')"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "`toHex` tar ikke inn en normal streng, men tar inn en binær streng. Koden nedenfor viser hvordan du konverterer en vanlig streng til binærstreng:\n",
+ "\n",
+ "```python\n",
+ "string = bytes(string, encoding = 'ascii')\n",
+ "```"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "### a)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Lag en funksjon `encrypt(message, key)` som tar inn en streng `message` og en nøkkel `key` (som er like lang som message, dvs. len(key)=len(message)) og returnerer det krypterte ordet ved å bruke XOR-operasjonen. \n",
+ "\n",
+ "Du må først gjøre om strengene `message` og `key` til heksadesimal v.h.a. funksjonen `toHex(word)` definert over. \n",
+ "\n",
+ "Funksjonen skal returnere heltallet `code` som er gitt ved M XOR K.\n",
+ "\n",
+ "Hint: XOR i python implementeres med `^`-operatoren.\n",
+ "\n",
+ "**Eksempel på kjøring:**\n",
+ "```python\n",
+ "print(encrypt('hei','abc')) #msg='hei', key='abc'\n",
+ "-> 591626\n",
+ "```\n",
+ "\n",
+ "***Skriv koden din i kodeblokken under og test at den fungerer:***"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2019-07-04T08:56:37.033656Z",
+ "start_time": "2019-07-04T08:56:37.027416Z"
+ }
+ },
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "### b)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Lag en funksjon `decrypt(code, key)` som tar inn en kode generert fra encrypt og nøkkelen **key**, og returnerer meldingen. \n",
+ "\n",
+ "Husk at M = C XOR K.\n",
+ "\n",
+ "**Eksempel på kjøring:**\n",
+ "```python\n",
+ "print(decrypt(591626,'abc')) #key = 'abc', code = 591626\n",
+ "-> hei\n",
+ "```\n",
+ "\n",
+ "***Skriv koden din under og test at den fungerer:***"
+ ]
+ },
+ {
+ "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": [
+ "Her må du bruke både toHex og toString."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "### c)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ " Lag en funksjon `main()` som tar inn en setning fra bruker, genererer en tilfeldig nøkkel, skriver ut den krypterte setningen og så den dekrypterte setningen.\n",
+ " \n",
+ " **Eksempel på kjøring.**\n",
+ " ```python\n",
+ "Hva er meldingen? God dag, Bob Bernt\n",
+ "Krypto: 8976018785527472660004435694777950941489408\n",
+ "Melding: God dag, Bob Bernt\n",
+ "```\n",
+ "\n",
+ "***Skriv koden din under og test at den fungerer:***"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2019-07-04T09:04:56.317142Z",
+ "start_time": "2019-07-04T09:04:56.310545Z"
+ }
+ },
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "### d) (frivillig)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Dersom samme nøkkel blir brukt til å kryptere to forskjellige ord kan man bruke resultatet og en \"ordbok\" til å finne tilbake til de opprinnelige ordene, og derfor også nøkkelen. Forklar hvordan dette kan gjøres."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Svar:** <dobbeltklikk for å svare\\>"
+ ]
+ }
+ ],
+ "metadata": {
+ "celltoolbar": "Edit Metadata",
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.7.4"
+ },
+ "toc": {
+ "base_numbering": 1,
+ "nav_menu": {},
+ "number_sections": false,
+ "sideBar": true,
+ "skip_h1_title": false,
+ "title_cell": "Table of Contents",
+ "title_sidebar": "Contents",
+ "toc_cell": false,
+ "toc_position": {},
+ "toc_section_display": true,
+ "toc_window_display": false
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/Ovinger/Oving6/Lister og tupler.ipynb b/Ovinger/Oving6/Lister og tupler.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..ab0b907901f272885fdac0a69d44d69baaef5e93
--- /dev/null
+++ b/Ovinger/Oving6/Lister og tupler.ipynb
@@ -0,0 +1,168 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "<nav class=\"navbar navbar-default\">\n",
+ " <div class=\"container-fluid\">\n",
+ " <div class=\"navbar-header\">\n",
+ " <a class=\"navbar-brand\" href=\"_Oving6.ipynb\">Øving 6</a>\n",
+ " </div>\n",
+ " <ul class=\"nav navbar-nav\">\n",
+ " <li ><a href=\"Aksessering.ipynb\">Aksessering av karakter</a></li>\n",
+ " <li ><a href=\"Strenger%20og%20konkatinering.ipynb\">Konkatinering</a></li>\n",
+ " <li ><a href=\"Slicing.ipynb\">Slicing</a></li>\n",
+ " <li ><a href=\"Tekstbehandling.ipynb\">Tekstbehandling</a></li>\n",
+ " <li ><a href=\"Strenghandtering.ipynb\">Strenghåndtering</a></li>\n",
+ " <li ><a href=\"Innebygde%20funksjoner.ipynb\">Innebygde funksjoner og lister</a></li>\n",
+ " <li ><a href=\"Fjesboka.ipynb\">Fjesboka</a></li>\n",
+ " <li ><a href=\"Akkorder%20og%20toner.ipynb\">Akkorder og toner</a></li>\n",
+ " <li ><a href=\"Ideel%20gasslov.ipynb\">Ideel Gasslov</a></li>\n",
+ " <li ><a href=\"Sammenhengende%20tallrekke.ipynb\">Sammenhengende Tallrekke</a></li>\n",
+ " <li ><a href=\"Sortering.ipynb\">Sortering</a></li>\n",
+ " <li ><a href=\"Strengmanipulasjon.ipynb\">Strengmanipulasjon</a></li>\n",
+ " <li ><a href=\"Kryptering.ipynb\">Kryptering</a></li>\n",
+ " <li ><a href=\"Litt%20sjakk.ipynb\">Litt Sjakk</a></li>\n",
+ " <li class=\"active\"><a href=\"Lister%20og%20tupler.ipynb\">Lister og tupler</a></li>\n",
+ " </ul>\n",
+ " </div>\n",
+ "</nav>\n",
+ "\n",
+ "# Lister og tupler\n",
+ "\n",
+ "**Læringsmål:**\n",
+ "\n",
+ "* Lister\n",
+ "* Tupler\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Denne oppgaven handler om *muterende* endringer av lister, samt forskjellen mellom tupler og lister. Hovedpoenget med muterende endringer er at dette er endringer, f.eks i en funksjon som skal være permanente *etter* at funksjonen avsluttes. Eksempelet under illustrerer en vanlig fallgruve knyttet til dette:\n",
+ "\n",
+ "```python\n",
+ "lis1 = [1,2,3]\n",
+ "lis2 = lis1\n",
+ "lis3 = lis1[:]\n",
+ "lis1[0] = 2\n",
+ "print(lis2)\n",
+ "print(lis3)\n",
+ " \n",
+ "Out: [2, 2, 3]\n",
+ " [1, 2, 3]\n",
+ "```\n",
+ "Her peker lis1 og lis2 til *samme* referanse i minnet, og begge vil endres hvis et av objektene endres. lis3 derimot er en (shallow) kopi av originalliste og endres derfor ikke. Hvis vi bruker funksjonen id(), så ser vi at lis1 og lis2 har samme id, men at lis3 har ulik id. \n",
+ "\n",
+ "\n",
+ "Dette er overførbart til et annet type problem. Eksempelvis, hvis man skal fjerne serieduplikater i en liste (tall som kommer rett etter hverandre), kan man skrive følgende kode:\n",
+ "\n",
+ "```python\n",
+ "def fjern_dup(liste):\n",
+ " ny_liste = [liste[0]] # Oppretter en ny liste hvor første element er det samme som i input\n",
+ " for tall in liste: # GÃ¥r gjennom tallene i input-listen\n",
+ " if tall != ny_liste[-1]: # Hvis tallet ikke er lik det siste elementet i ny_liste\n",
+ " ny_liste.append(tall) #legg tallet bakerst i den nye listen\n",
+ " liste[:] = ny_liste # setter liste lik en ny versjon av ny_liste\n",
+ "\n",
+ "```\n",
+ "Merk spesielt tilordningen liste[:]. Dette gjør at liste-variabelen peker til samme sted i minnet *etter* tilordningen, og variabelen blir dermed endret. Hvis vi derimot hadde skrevet \n",
+ "```python\n",
+ "liste = ny_liste \n",
+ "```\n",
+ "så hadde referansen (id-en) endret seg, altså blitt lagret et nytt sted og hvis vi hadde kalt på liste etter funksjonen hadde kjørt hadde vi ikke sett noen endring i printout. \n",
+ "\n",
+ "Dette er nokså intrikat, men hovedbudskapet er å passe på og sette riktig tilordning. Dette kan dere teste i de følgende oppgavene."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### a)\n",
+ "\n",
+ "Lag en funksjon som tar inn en liste og fjerner elementene som er høyere enn gjennomsnittet. Merk at dette skal gjelde duplikater også. Eksempelvis skal list = [1,2,3,4,5,5,6,7] remove_larger_than_average(list) gjøre at listen etter funksjonskallet ser slik ut: [1, 2, 3, 4]. Merk at funksjonen ikke skal returnere noe.\n",
+ "\n",
+ "***Skriv koden din i kodeblokken under:***"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 105,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### b) \n",
+ "\n",
+ "\n",
+ "Lag en funksjon som tar inn en liste endrer listen slik at elementet ved siden av det opprinnelige elementet er kvadratet (tallet ^2). F.eks skal input [1,2,3,4] resultere i at listen ser slik ut etter kallet: [1,1,2,4,3,9,4,16]. Merk at funksjonen ikke skal returnere noe.\n",
+ "\n",
+ "***Skriv koden din i kodeblokken under:***"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Videre er det viktig å være obs på forskjellen mellom lister og tupler. Hovedforskjellen er at tupler er ikke-muterbare, altså at de ikke kan endres når de er opprettet. Du skal nå skrive om funksjonen larger_than_average(liste) slik at denne fungerer *både* for lister og tupler. Du kan nå returnere resultatet, i stedet for å endre inputargumentet slik som i a). I denne oppgaven er det *ikke* lov å konvertere input-argumentet til en liste hvis det er en tuppel."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Hint**: Du kan bruke funksjonen isinstance(argument,type) for å sjekke om et argument er av typen type. Husk også at hvis du skal initialisere en tuppel med ett element, så må du ha komma bak elemenetet, (1,) f.eks "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.8.10"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/Ovinger/Oving6/Litt sjakk.ipynb b/Ovinger/Oving6/Litt sjakk.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..37649f0c26545f103dcebd3d1e80f1defddf1b8b
--- /dev/null
+++ b/Ovinger/Oving6/Litt sjakk.ipynb
@@ -0,0 +1,248 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": 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=\"_Oving6.ipynb\">Øving 6</a>\n",
+ " </div>\n",
+ " <ul class=\"nav navbar-nav\">\n",
+ " <li ><a href=\"Aksessering.ipynb\">Aksessering av karakter</a></li>\n",
+ " <li ><a href=\"Strenger%20og%20konkatinering.ipynb\">Konkatinering</a></li>\n",
+ " <li ><a href=\"Slicing.ipynb\">Slicing</a></li>\n",
+ " <li ><a href=\"Tekstbehandling.ipynb\">Tekstbehandling</a></li>\n",
+ " <li ><a href=\"Strenghandtering.ipynb\">Strenghåndtering</a></li>\n",
+ " <li ><a href=\"Innebygde%20funksjoner.ipynb\">Innebygde funksjoner og lister</a></li>\n",
+ " <li ><a href=\"Fjesboka.ipynb\">Fjesboka</a></li>\n",
+ " <li ><a href=\"Akkorder%20og%20toner.ipynb\">Akkorder og toner</a></li>\n",
+ " <li><a href=\"Ideel%20gasslov.ipynb\">Ideel Gasslov</a></li>\n",
+ " <li><a href=\"Sammenhengende%20tallrekke.ipynb\">Sammenhengende Tallrekke</a></li>\n",
+ " <li ><a href=\"Sortering.ipynb\">Sortering</a></li>\n",
+ " <li ><a href=\"Strengmanipulasjon.ipynb\">Strengmanipulasjon</a></li>\n",
+ " <li ><a href=\"Kryptering.ipynb\">Kryptering</a></li>\n",
+ " <li class=\"active\"><a href=\"Litt%20sjakk.ipynb\">Litt Sjakk</a></li>\n",
+ " <li ><a href=\"Lister%20og%20tupler.ipynb\">Lister og tupler</a></li>\n",
+ " </ul>\n",
+ " </div>\n",
+ "</nav>\n",
+ "\n",
+ "# Litt sjakk\n",
+ "\n",
+ "**Læringsmål:**\n",
+ "\n",
+ "* 2d-lister\n",
+ "\n",
+ "I denne oppgaven skal det lages brettrepresentasjon og små deler av logikk til sjakk. Det vises kun en eksempelstilling, men husk at koden du lager skal fungere for alle mulige stillinger."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "### a)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Først trengs det en måte å representere brettet med brikkene i programmet. Dette skal gjøres vha 2d-lister, det vil si en liste som inneholder flere lister. Lag en funksjon `make_board(board_string)`, som tar inn en string-representasjon av brettet, og returnerer en 2d-liste. Inni denne listen skal det være *None* hvis det ikke er en brikke i ruten det er snakk om, og en enkel bokstav (string) for ulike brikker. Hvite brikker skal ha stor bokstav (blokkbokstav) og svarte skal ha små bokstaver. Brikke-bokstav-kombinasjoner er: (konge: k, dronning: q, tårn: r, løper: b, hest: n, og bonde: p).\n",
+ "\n",
+ "board_string vil være én lang string, og har et punktum for tomme ruter, og ellers samme bokstav-koding for brikkene som breskrevet over (konge: k (svart), K (hvit), osv...). Legg merke til at de første fem tegnene i stringen skal være i den øverste raden på brettet, og de siste fem skal være i den nederste raden.\n",
+ "\n",
+ "I dag skal vi leke med et litt mindre sjakkbrett, som kun er 5x5 ruter stort.\n",
+ "\n",
+ "**Eksempel på kjøring:**\n",
+ "```python\n",
+ "board_string_1 = 'rkn.r.p.....P..PP.PPB.K..'\n",
+ "board = make_board(board_string_1)\n",
+ "```\n",
+ "```python\n",
+ "board -> [['r', 'k', 'n', None, 'r'], [None, 'p', None, None, None], [None, None, 'P', None, None], \n",
+ "['P', 'P', None, 'P', 'P'], ['B', None, 'K', None, None]]\n",
+ "```\n",
+ "\n",
+ "Her er et bilde av brettet dette eksempelet skal representere:\n",
+ "\n",
+ "\n",
+ "\n",
+ "***Skriv koden i kodeblokken under og test at den fungerer som den skal***"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "### b)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Lag en funksjon `get_piece(board, x, y)` som returnerer brikken i ruten x, y, fra 2d-listen **board**, hvor x er kolonne og y er rad. Dersom det ikke er en brikke i ruten, skal funksjonen returnere *None*. Ellers skal den returnere strengen som representerer brikken (dvs. det som befinner seg i board).\n",
+ "\n",
+ "Radene og kolonnene skal være 1-indekserte, det vil si rader og kolonner går fra 1 til 5. Nederste rad skal være rad 1, og venstre kolonne skal være kolonne 1. \n",
+ "Altså skal `get_piece(board, 1, 1)` returnere innholdet i nederste venstre hjørne, og `get_piece(board, 5, 5)` skal returnere innholdet i øverste høyre hjørne.\n",
+ "\n",
+ "**Eksempel på kjøring: (samme brett og stilling som eksempelet i oppgave a)**\n",
+ "```python\n",
+ "board_string_1 = 'rkn.r.p.....P..PP.PPB.K..'\n",
+ "board = make_board(board_string_1)\n",
+ "```\n",
+ "```python\n",
+ "get_piece(board, 2, 1)\n",
+ "-> None\n",
+ " ```\n",
+ " ```python\n",
+ "get_piece(board, 5, 2)\n",
+ "-> 'P'\n",
+ " ```\n",
+ " \n",
+ "***Skriv koden i kodeblokken under og test at den fungerer som den skal***"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "### c)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Nå skal det lages logikk for å sjekke hvilke trekk som kan gjøres av visse brikker. **I denne oppgaven ser vi kun på bonden**. For å få illustrert faktiske sjakk-regler anbefales et raskt Google-søk.\n",
+ "\n",
+ "Reglene du skal implementere er:\n",
+ "\n",
+ "* Bonden kan alltid gå ett skritt framover, med mindre det står noe i veien (på ruten foran).\n",
+ "* Hvis det står en motstanders brikke i en av de to rutene skrått fremover, kan bonden slå disse.\n",
+ "* Hvis bonden står i sin start-posisjon (med vårt brett, rad 2 for hvit og rad 4 for svart), kan den gå to skritt framover.\n",
+ "* *Du trenger ikke å implementere \"forvandling\" som skjer når bonden har gått helt over til andre siden.*\n",
+ "* *Du trenger heller ikke implementere \"en passant\". Hvis du ikke vet hva dette er, kan du ignorere dette.*\n",
+ "\n",
+ "Lag en funksjon `get_legal_moves(board, x, y)` som returnerer en liste med (x, y)-tupler som er gyldige trekk. Hvis funksjonen kalles med parametre som er en tom rute eller ruten inneholder noe annet enn en bonde, skal en tom liste returneres. board er en 2D-liste, og x og y er heltall. Her er det lurt å bruke `get_piece`-funksjonen du har laget underveis.\n",
+ "\n",
+ "Her må det tas hensyn til om brikken er hvit eller svart, da de går i motsatte retninger (hint: funksjonen ord(c) kan brukes til å få tak i ASCII-verdien til bokstaven c. Dette kan brukes til å enkelt skille mellom svarte og hvite brikker)\n",
+ "\n",
+ "**Eksempel på kjøring: (samme brett og stilling som eksempelet i oppgave a)**\n",
+ "```python\n",
+ "board_string_1 = 'rkn.r.p.....P..PP.PPB.K..'\n",
+ "board = make_board(board_string_1)\n",
+ "```\n",
+ "``` python\n",
+ "get_legal_moves(board, 4, 2)\n",
+ " -> [(4, 3), (4, 4)]\n",
+ " ```\n",
+ " ```python\n",
+ "get_legal_moves(board, 2, 4)\n",
+ " -> [(2, 3), (3, 3)] \n",
+ " ```\n",
+ " \n",
+ "***Skriv koden i kodeblokken under og test at den fungerer som den skal***"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ }
+ ],
+ "metadata": {
+ "celltoolbar": "Edit Metadata",
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.7.4"
+ },
+ "toc": {
+ "base_numbering": 1,
+ "nav_menu": {},
+ "number_sections": false,
+ "sideBar": true,
+ "skip_h1_title": false,
+ "title_cell": "Table of Contents",
+ "title_sidebar": "Contents",
+ "toc_cell": false,
+ "toc_position": {},
+ "toc_section_display": true,
+ "toc_window_display": false
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/Ovinger/Oving6/Sammenhengende tallrekke.ipynb b/Ovinger/Oving6/Sammenhengende tallrekke.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..ece3b189e6063a949e8a30e6700f0fcd6deccf12
--- /dev/null
+++ b/Ovinger/Oving6/Sammenhengende tallrekke.ipynb
@@ -0,0 +1,231 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": 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=\"_Oving6.ipynb\">Øving 6</a>\n",
+ " </div>\n",
+ " <ul class=\"nav navbar-nav\">\n",
+ " <li ><a href=\"Aksessering.ipynb\">Aksessering av karakter</a></li>\n",
+ " <li ><a href=\"Strenger%20og%20konkatinering.ipynb\">Konkatinering</a></li>\n",
+ " <li ><a href=\"Slicing.ipynb\">Slicing</a></li>\n",
+ " <li ><a href=\"Tekstbehandling.ipynb\">Tekstbehandling</a></li>\n",
+ " <li ><a href=\"Strenghandtering.ipynb\">Strenghåndtering</a></li>\n",
+ " <li ><a href=\"Innebygde%20funksjoner.ipynb\">Innebygde funksjoner og lister</a></li>\n",
+ " <li ><a href=\"Fjesboka.ipynb\">Fjesboka</a></li>\n",
+ " <li ><a href=\"Akkorder%20og%20toner.ipynb\">Akkorder og toner</a></li>\n",
+ " <li ><a href=\"Ideel%20gasslov.ipynb\">Ideel Gasslov</a></li>\n",
+ " <li class=\"active\"><a href=\"Sammenhengende%20tallrekke.ipynb\">Sammenhengende Tallrekke</a></li>\n",
+ " <li ><a href=\"Sortering.ipynb\">Sortering</a></li>\n",
+ " <li ><a href=\"Strengmanipulasjon.ipynb\">Strengmanipulasjon</a></li>\n",
+ " <li ><a href=\"Kryptering.ipynb\">Kryptering</a></li>\n",
+ " <li ><a href=\"Litt%20sjakk.ipynb\">Litt Sjakk</a></li>\n",
+ " <li ><a href=\"Lister%20og%20tupler.ipynb\">Lister og tupler</a></li>\n",
+ " </ul>\n",
+ " </div>\n",
+ "</nav>\n",
+ "\n",
+ "# Sammenhengende tallrekke\n",
+ "\n",
+ "**Læringsmål:**\n",
+ "\n",
+ "* Lister\n",
+ "\n",
+ "\n",
+ "I denne oppgaven skal du sammenligne lister med tall. (Eksempel på kjøring av hver deloppgave er samlet i kodeblokk nederst på siden.)\n",
+ "\n",
+ " "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "**a)** Lag en funksjon `randList(size, lower_bound, upper_bpund)` som tar inn tre heltall, `size`, `lower_bound` og `upper_bound`. Denne skal returnere en liste med tilfeldige tall i intervallet mellom `lower_bound` og `upper_bound`. Hvor mange tall listen skal inneholde er angitt av `size`.\n",
+ "\n",
+ "***Skriv funksjonen din i kodeblokken under og test at den fungerer***"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "**b)** Skriv en funksjon `compareLists(list1, list2)` som sammenligner 2 lister og returnerer en liste med alle tall som var med i begge listene. Kopier skal ikke taes med. Ikke bruk innebygde funksjoner.\n",
+ "\n",
+ "***Skriv funksjonen din i kodeblokken under og test at den fungerer***"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "**c)** Skriv en ny funksjon `multiCompList(lists)` som kan sammenligne et vilkårlig antall lister. \n",
+ "Hint: `lists` er en liste av lister. Ikke bruk innebygde funksjoner, men ta gjerne i bruk funksjoner du har laget tidligere i oppgaven.\n",
+ "\n",
+ "***Skriv funksjonen din i kodeblokken under og test at den fungerer***"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2019-07-04T08:04:06.694102Z",
+ "start_time": "2019-07-04T08:04:06.681908Z"
+ }
+ },
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "**d)** Skriv en funksjon `longestEven(list)` som finner lengste sammenhengende rekke med partall i en liste. Metoden skal returnere indeksen til det første partallet i rekken og antallet partall i rekken.\n",
+ "\n",
+ "***Skriv funksjonen din i kodeblokken under***"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "**Test av alle funksjonene:**"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def main():\n",
+ " print(randList(10,2,7))\n",
+ " a = [1,2,3]\n",
+ " b = [4,3,1]\n",
+ " print(compareLists(a,b))\n",
+ " c = [7,2,1]\n",
+ " d = [a,b,c]\n",
+ " print(multiCompList(d))\n",
+ " liste = [4,3,3,6,2,6,8,3,4,3,3]\n",
+ " print(longestEven(liste))\n",
+ " \n",
+ "main()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "**Eksempel på riktig utskrift:**\n",
+ "```python\n",
+ "[5, 6, 7, 4, 7, 3, 2, 4, 3, 2] # Merk at denne vil variere!\n",
+ "[1, 3]\n",
+ "[1]\n",
+ "(3, 4)\n",
+ "```"
+ ]
+ }
+ ],
+ "metadata": {
+ "celltoolbar": "Edit Metadata",
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.7.4"
+ },
+ "toc": {
+ "base_numbering": 1,
+ "nav_menu": {},
+ "number_sections": false,
+ "sideBar": true,
+ "skip_h1_title": false,
+ "title_cell": "Table of Contents",
+ "title_sidebar": "Contents",
+ "toc_cell": false,
+ "toc_position": {},
+ "toc_section_display": true,
+ "toc_window_display": false
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/Ovinger/Oving6/Slicing.ipynb b/Ovinger/Oving6/Slicing.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..995ce780dda66da49df86c51f2ba41a98201e225
--- /dev/null
+++ b/Ovinger/Oving6/Slicing.ipynb
@@ -0,0 +1,278 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": 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=\"_Oving6.ipynb\">Øving 6</a>\n",
+ " </div>\n",
+ " <ul class=\"nav navbar-nav\">\n",
+ " <li ><a href=\"Aksessering.ipynb\">Aksessering av karakter</a></li>\n",
+ " <li ><a href=\"Strenger%20og%20konkatinering.ipynb\">Konkatinering</a></li>\n",
+ " <li class=\"active\"><a href=\"Slicing.ipynb\">Slicing</a></li>\n",
+ " <li ><a href=\"Tekstbehandling.ipynb\">Tekstbehandling</a></li>\n",
+ " <li ><a href=\"Strenghandtering.ipynb\">Strenghåndtering</a></li>\n",
+ " <li ><a href=\"Innebygde%20funksjoner.ipynb\">Innebygde funksjoner og lister</a></li>\n",
+ " <li><a href=\"Fjesboka.ipynb\">Fjesboka</a></li>\n",
+ " <li ><a href=\"Akkorder%20og%20toner.ipynb\">Akkorder og toner</a></li>\n",
+ " <li ><a href=\"Ideel%20gasslov.ipynb\">Ideel Gasslov</a></li>\n",
+ " <li><a href=\"Sammenhengende%20tallrekke.ipynb\">Sammenhengende Tallrekke</a></li>\n",
+ " <li ><a href=\"Sortering.ipynb\">Sortering</a></li>\n",
+ " <li ><a href=\"Strengmanipulasjon.ipynb\">Strengmanipulasjon</a></li>\n",
+ " <li ><a href=\"Kryptering.ipynb\">Kryptering</a></li>\n",
+ " <li ><a href=\"Litt%20sjakk.ipynb\">Litt Sjakk</a></li>\n",
+ " <li ><a href=\"Lister%20og%20tupler.ipynb\">Lister og tupler</a></li>\n",
+ " </ul>\n",
+ " </div>\n",
+ "</nav>\n",
+ "\n",
+ "# Slicing av strenger\n",
+ "\n",
+ "**Læringsmål:**\n",
+ "\n",
+ "* Strenger\n",
+ "* Funksjoner\n",
+ "* Lister\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "### Kort om slicing"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Slicing kan brukes til å velge ut en del av en streng. Formatet for dette er: \n",
+ "string[start : slutt : steg]\n",
+ "\n",
+ "* Den nye strengen vil starte på karakteren start-indeksen tilsvarer, fortsette med karakteren indikert av indeksen (start+steg), så ta neste karakter indikert av indeksen (start+steg+steg), osv., helt til, men ikke med, karakteren end-indeksen tilsvarer. (Se eksempeler på kjøring)\n",
+ "* Om start ikke er spesifisert, antas indeks 0\n",
+ "' Om slutt ikke er spesifisert, antas indeks len(string)\n",
+ "* Om steg ikke er spesifisert antas steg = 1\n",
+ "\n",
+ "**Eksempel:**"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "streng = \"One ring to rule them all\"\n",
+ "print(streng[:3]) #Samme som streng[0:3]\n",
+ "print(streng[12:16]) \n",
+ "print(streng[12:]) #Samme som streng[12:len(streng)] og streng[12:25]\n",
+ "print(streng[1::9]) "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "### a)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2019-07-03T12:34:41.521574Z",
+ "start_time": "2019-07-03T12:34:41.512410Z"
+ },
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Skriv en funksjon som tar inn en streng som argument, og returnerer en ny streng bestående av hver fjerde karakter i argumentet.\n",
+ "\n",
+ "**Eksempel:**\n",
+ "\n",
+ "```python\n",
+ "#streng = \"I Was Told There’d Be Cake\"\n",
+ "-> Islh’ek\n",
+ "```\n",
+ "\n",
+ "***Skriv koden din i kodeblokken under***"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "### b)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Skriv en funksjon som tar inn en liste med strenger, itererer gjennom denne, og returnerer en ny streng bestående av de to siste karakterene i strengene i listen.\n",
+ "\n",
+ "**Eksempel:**\n",
+ "```python\n",
+ "#liste = [\"banan\",\"propan\",\"Westerosi\"]\n",
+ "-> anansi\n",
+ "```\n",
+ "\n",
+ "***Skriv koden din i kodeblokken under***"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "### c)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Under følger tre kodesnutter, der to inneholder en feil hver, og den siste er rett. Hvilken kode er korrekt? Finn feilen i de to andre."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "#Kodesnutt 1\n",
+ "streng = \"I Want Cake\"\n",
+ "streng[7:] = \"Cupcake\"\n",
+ "print(streng)\n",
+ " \n",
+ "#Kodesnutt 2\n",
+ "streng = \"I Want Cake\"\n",
+ "streng = streng[-4:100:]\n",
+ "print(streng)\n",
+ " \n",
+ "#Kodesnutt 3\n",
+ "streng = \"I Want Cake\"\n",
+ "streng = streng[]\n",
+ "print(streng)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Dobbeltklikk på teksten under og skriv svaret ditt i boksen."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Ditt svar:** <dobbeltklikk her for å skrive\\>"
+ ]
+ }
+ ],
+ "metadata": {
+ "celltoolbar": "Edit Metadata",
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.7.4"
+ },
+ "toc": {
+ "base_numbering": 1,
+ "nav_menu": {},
+ "number_sections": false,
+ "sideBar": true,
+ "skip_h1_title": false,
+ "title_cell": "Table of Contents",
+ "title_sidebar": "Contents",
+ "toc_cell": false,
+ "toc_position": {},
+ "toc_section_display": true,
+ "toc_window_display": false
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/Ovinger/Oving6/Sortering.ipynb b/Ovinger/Oving6/Sortering.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..6e0db8ce51a1617f8c2e7e63389e16b7cd11abf5
--- /dev/null
+++ b/Ovinger/Oving6/Sortering.ipynb
@@ -0,0 +1,265 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": 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=\"_Oving6.ipynb\">Øving 6</a>\n",
+ " </div>\n",
+ " <ul class=\"nav navbar-nav\">\n",
+ " <li ><a href=\"Aksessering.ipynb\">Aksessering av karakter</a></li>\n",
+ " <li ><a href=\"Strenger%20og%20konkatinering.ipynb\">Konkatinering</a></li>\n",
+ " <li ><a href=\"Slicing.ipynb\">Slicing</a></li>\n",
+ " <li ><a href=\"Tekstbehandling.ipynb\">Tekstbehandling</a></li>\n",
+ " <li ><a href=\"Strenghandtering.ipynb\">Strenghåndtering</a></li>\n",
+ " <li ><a href=\"Innebygde%20funksjoner.ipynb\">Innebygde funksjoner og lister</a></li>\n",
+ " <li ><a href=\"Fjesboka.ipynb\">Fjesboka</a></li>\n",
+ " <li ><a href=\"Akkorder%20og%20toner.ipynb\">Akkorder og toner</a></li>\n",
+ " <li ><a href=\"Ideel%20gasslov.ipynb\">Ideel Gasslov</a></li>\n",
+ " <li><a href=\"Sammenhengende%20tallrekke.ipynb\">Sammenhengende Tallrekke</a></li>\n",
+ " <li class=\"active\"><a href=\"Sortering.ipynb\">Sortering</a></li>\n",
+ " <li ><a href=\"Strengmanipulasjon.ipynb\">Strengmanipulasjon</a></li>\n",
+ " <li ><a href=\"Kryptering.ipynb\">Kryptering</a></li>\n",
+ " <li ><a href=\"Litt%20sjakk.ipynb\">Litt Sjakk</a></li>\n",
+ " <li ><a href=\"Lister%20og%20tupler.ipynb\">Lister og tupler</a></li>\n",
+ " </ul>\n",
+ " </div>\n",
+ "</nav>\n",
+ "\n",
+ "# Sortering\n",
+ "\n",
+ "**Læringsmål:**\n",
+ "\n",
+ "* Lister\n",
+ "* Sortering\n",
+ "\n",
+ "Sortering av tall er en vanlig aktivitet i dataverden. Det er derfor utviklet mange mer eller mindre avanserte algoritmer for å gjøre dette effektivt (få antall beregninger). \n",
+ "\n",
+ "I denne oppgaven skal vi implementere to enkle sorteringsalgoritmer: [Bubble Sort](https://en.wikipedia.org/wiki/Bubble_sort) og [Selection Sort](https://en.wikipedia.org/wiki/Selection_sort). "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "### a)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Skriv funksjonen bubble_sort(list), forklart under.\n",
+ "\n",
+ "* SÃ¥ lenge listen er usortert:\n",
+ " * GÃ¥ gjennom hele listen\n",
+ " * Hvis elementet på plass i er større enn elementet på plass i+1\n",
+ " * Bytt plass på de to elementene\n",
+ " \n",
+ "Funksjonen skal returnere den sorterte listen.\n",
+ "\n",
+ "**Eksempel på kjøring:**\n",
+ "```python\n",
+ "liste = [9,1,34,7,2,3,45,6,78,56,36,65,33,21,23,34,45,6]\n",
+ "print(bubble_sort(liste))\n",
+ "# Output blir:\n",
+ "# [1, 2, 3, 6, 6, 7, 9, 21, 23, 33, 34, 34, 36, 45, 45, 56, 65, 78]\n",
+ "```\n",
+ "\n",
+ "***Skriv koden din i kodeblokken under:***"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "**Testkode**"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "liste = [9,1,34,7,2,3,45,6,78,56,36,65,33,21,23,34,45,6]\n",
+ "print(bubble_sort(liste))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "### b)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Skriv funksjonen `selection_sort(list)`, forklart under.\n",
+ "\n",
+ "* Lag en ny liste \n",
+ "* GÃ¥ gjennom hele den usorterte listen\n",
+ " * Finn det største tallet i den usorterte listen\n",
+ " * Legg dette inn fremst i den nye listen\n",
+ " * Fjern elementet fra den usorterte listen\n",
+ " \n",
+ "Funksjonen skal returnere den sorterte listen.\n",
+ "\n",
+ "**Eksempel på kjøring:**\n",
+ "```python\n",
+ "liste = [9,1,34,7,2,3,45,6,78,56,36,65,33,21,23,34,45,6]\n",
+ "print(selection_sort(liste))\n",
+ "# Output blir:\n",
+ "# [1, 2, 3, 6, 6, 7, 9, 21, 23, 33, 34, 34, 36, 45, 45, 56, 65, 78]\n",
+ "```\n",
+ "\n",
+ "**Skriv koden din i kodeblokken under:**"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "**Testkode**"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "liste = [9,1,34,7,2,3,45,6,78,56,36,65,33,21,23,34,45,6]\n",
+ "print(selection_sort(liste))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "### c) (Frivillig)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Hvilken av de to algoritmene er \"best\"/raskest til å sortere? Her kan det være lurt å lese seg opp på \"store O\"."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Svar:** <dobbeltklikk for å svare\\>"
+ ]
+ }
+ ],
+ "metadata": {
+ "celltoolbar": "Edit Metadata",
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.7.4"
+ },
+ "toc": {
+ "base_numbering": 1,
+ "nav_menu": {},
+ "number_sections": false,
+ "sideBar": true,
+ "skip_h1_title": false,
+ "title_cell": "Table of Contents",
+ "title_sidebar": "Contents",
+ "toc_cell": false,
+ "toc_position": {},
+ "toc_section_display": true,
+ "toc_window_display": false
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/Ovinger/Oving6/Strenger og konkatinering.ipynb b/Ovinger/Oving6/Strenger og konkatinering.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..a5810cceab86c3812974e1bfaaabf952dc7163f3
--- /dev/null
+++ b/Ovinger/Oving6/Strenger og konkatinering.ipynb
@@ -0,0 +1,471 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": 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=\"_Oving6.ipynb\">Øving 6</a>\n",
+ " </div>\n",
+ " <ul class=\"nav navbar-nav\">\n",
+ " <li ><a href=\"Aksessering.ipynb\">Aksessering av karakter</a></li>\n",
+ " <li class=\"active\"><a href=\"Strenger%20og%20konkatinering.ipynb\">Konkatinering</a></li>\n",
+ " <li ><a href=\"Slicing.ipynb\">Slicing</a></li>\n",
+ " <li ><a href=\"Tekstbehandling.ipynb\">Tekstbehandling</a></li>\n",
+ " <li ><a href=\"Strenghandtering.ipynb\">Strenghåndtering</a></li>\n",
+ " <li ><a href=\"Innebygde%20funksjoner.ipynb\">Innebygde funksjoner og lister</a></li>\n",
+ " <li><a href=\"Fjesboka.ipynb\">Fjesboka</a></li>\n",
+ " <li ><a href=\"Akkorder%20og%20toner.ipynb\">Akkorder og toner</a></li>\n",
+ " <li ><a href=\"Ideel%20gasslov.ipynb\">Ideel Gasslov</a></li>\n",
+ " <li><a href=\"Sammenhengende%20tallrekke.ipynb\">Sammenhengende Tallrekke</a></li>\n",
+ " <li ><a href=\"Sortering.ipynb\">Sortering</a></li>\n",
+ " <li ><a href=\"Strengmanipulasjon.ipynb\">Strengmanipulasjon</a></li>\n",
+ " <li ><a href=\"Kryptering.ipynb\">Kryptering</a></li>\n",
+ " <li ><a href=\"Litt%20sjakk.ipynb\">Litt Sjakk</a></li>\n",
+ " <li ><a href=\"Lister%20og%20tupler.ipynb\">Lister og tupler</a></li>\n",
+ " </ul>\n",
+ " </div>\n",
+ "</nav>\n",
+ "\n",
+ "# Strenger og konkatinering\n",
+ "\n",
+ "**Læringsmål:**\n",
+ "\n",
+ "* Strenger\n",
+ "* Løkker\n",
+ "* Funksjoner\n",
+ "* Lister\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "heading_collapsed": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "### Kort om konkatinering"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "hidden": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Konkatinering er å tilføye en streng ved slutten av en annen streng. Dette gjøres enten vha. + eller +=. For å bruke += må variabelen på venstre side av += være en allerede eksisterende variabel. Kjør eksemplene under og se om du skjønner hvordan de virker. Du må gjerne endre eksemplene og kjøre de igjen."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2019-07-03T12:09:10.412280Z",
+ "start_time": "2019-07-03T12:09:10.013418Z"
+ },
+ "hidden": true
+ },
+ "outputs": [],
+ "source": [
+ "# eksempel 1\n",
+ "# Bruk av +\n",
+ "melding = \"Hei \" + \"der\"\n",
+ "print(melding)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2019-07-03T12:09:10.412280Z",
+ "start_time": "2019-07-03T12:09:10.013418Z"
+ },
+ "hidden": true
+ },
+ "outputs": [],
+ "source": [
+ "# eksempel 2\n",
+ "s1 = \"Hei\"\n",
+ "s2 = \"der\"\n",
+ "melding1 = s1 + \" \" + s2\n",
+ "print(melding1)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2019-07-03T12:09:10.412280Z",
+ "start_time": "2019-07-03T12:09:10.013418Z"
+ },
+ "hidden": true
+ },
+ "outputs": [],
+ "source": [
+ "# eksempel 3\n",
+ "# Bruk av +=\n",
+ "navn = \"Bob\"\n",
+ "navn += \" \" + \"Bernt\"\n",
+ "print(navn)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2019-07-03T12:09:10.412280Z",
+ "start_time": "2019-07-03T12:09:10.013418Z"
+ },
+ "hidden": true
+ },
+ "outputs": [],
+ "source": [
+ "# eksempel 4\n",
+ "liste = [\"Geralt\",\"of\",\"Rivia\"]\n",
+ "navn2 = \"\"\n",
+ "for streng in liste:\n",
+ " navn2 += streng + \" \"\n",
+ "print(navn2)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2019-07-03T12:09:10.412280Z",
+ "start_time": "2019-07-03T12:09:10.013418Z"
+ },
+ "hidden": true
+ },
+ "outputs": [],
+ "source": [
+ "# eksempel 5\n",
+ "# Vil utløse et unntak (exception) siden variabelen navnet ikke eksisterer fra før.\n",
+ "# Unntaket som utløses vil være NameError\n",
+ "navnet += \"Bob\" "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "### a)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Skriv en funksjon som tar inn to strenger (s1 og s2), og returnerer én streng bestående av disse med et mellomrom mellom.\n",
+ "\n",
+ "**Eksempel**:\n",
+ "```python\n",
+ "#s1 = \"James\", s2 = \"Bond\"\n",
+ "-> James Bond\n",
+ "```\n",
+ "\n",
+ "***Skriv koden din i kodeblokken under:***"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "### b)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2019-07-03T12:18:08.171134Z",
+ "start_time": "2019-07-03T12:18:08.159623Z"
+ },
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Skriv en funksjon som tar inn en liste av strenger, og returnerer én streng bestående av disse uten mellomrom mellom dem.\n",
+ "\n",
+ "**Eksempel på kjøring:**\n",
+ "```python\n",
+ "#list = [\"abc\",\"defg\",\"hijklm\",\"nop\"]\n",
+ "-> abcdefghijklmnop\n",
+ "```\n",
+ "\n",
+ "***Skriv koden din i kodeblokken under:***"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "heading_collapsed": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "### Ikke-muterbarhet"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "hidden": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Strenger er ikke-muterbare, som vil si at man ikke kan endre på deler av strengen uten å lage en ny streng. Konkatinering kan gi inntrykket av å endre på en streng, mens det egentlig opprettes en ny en."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "hidden": true
+ },
+ "outputs": [],
+ "source": [
+ "navn = \"Bob\" # tilordner strengen \"Bob\" til variabelen navn\n",
+ "navn += \" Bernt\" # tilordner en NY streng \"Bob Bernt\" til variabelen navn"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "hidden": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Siden strenger er ikke-muterbare, betyr det at man ikke kan endre på enkelte karakterer i strengen. Altså kan man ikke skrive string[index] = \"c\"."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "hidden": true
+ },
+ "outputs": [],
+ "source": [
+ "navn = \"Bob Bernt\"\n",
+ "navn[0] = \"H\" # IKKE MULIG!! Vil få utløst et unntak (prøv selv)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "hidden": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Om man ønsker å beholde store deler av en streng, men endre på enkelte deler av den, kan man bruke slicing til å opprette en ny streng med de ønskede endringene. Mer om slicing i neste oppgave."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "### c)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Skriv en funksjon som tar inn en liste med strenger og skriver ut den første karakteren i hver av dem.\n",
+ "\n",
+ "**Eksempel:**\n",
+ "```python\n",
+ "#list = [\"UKA\",\"lever\",\"videre\"]\n",
+ "U\n",
+ "l\n",
+ "v\n",
+ "```\n",
+ "\n",
+ "***Skriv koden din i kodeblokken under:***"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "### d)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Hva vil kodesnutten under skrive ut til skjerm?\n",
+ "\n",
+ "```python\n",
+ "def func1(liste):\n",
+ " streng = \"\"\n",
+ " for s in liste:\n",
+ " if len(s)>3:\n",
+ " streng += s[3]\n",
+ " return streng\n",
+ "```\n",
+ "```python \n",
+ "def func2(streng):\n",
+ " streng += streng\n",
+ " return streng\n",
+ "```\n",
+ "```python\n",
+ "print(func2(func1([\"Klabert\",\"Oslo\",\"Tur\",\"stubbe\"])))\n",
+ "```\n",
+ "\n",
+ "Dobbeltklikk på teksten under for å svare."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2019-07-03T12:26:09.541554Z",
+ "start_time": "2019-07-03T12:26:09.530256Z"
+ }
+ },
+ "source": [
+ "**Svar:** <dobbelklikk her for å skrive\\>"
+ ]
+ }
+ ],
+ "metadata": {
+ "celltoolbar": "Edit Metadata",
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.7.4"
+ },
+ "toc": {
+ "base_numbering": 1,
+ "nav_menu": {},
+ "number_sections": false,
+ "sideBar": true,
+ "skip_h1_title": false,
+ "title_cell": "Table of Contents",
+ "title_sidebar": "Contents",
+ "toc_cell": false,
+ "toc_position": {},
+ "toc_section_display": true,
+ "toc_window_display": false
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/Ovinger/Oving6/Strenghandtering.ipynb b/Ovinger/Oving6/Strenghandtering.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..b4663f99dee040d6ee776c4b852a3257477ccdf3
--- /dev/null
+++ b/Ovinger/Oving6/Strenghandtering.ipynb
@@ -0,0 +1,372 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": 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=\"_Oving6.ipynb\">Øving 6</a>\n",
+ " </div>\n",
+ " <ul class=\"nav navbar-nav\">\n",
+ " <li ><a href=\"Aksessering.ipynb\">Aksessering av karakter</a></li>\n",
+ " <li ><a href=\"Strenger%20og%20konkatinering.ipynb\">Konkatinering</a></li>\n",
+ " <li ><a href=\"Slicing.ipynb\">Slicing</a></li>\n",
+ " <li ><a href=\"Tekstbehandling.ipynb\">Tekstbehandling</a></li>\n",
+ " <li class=\"active\"><a href=\"Strenghandtering.ipynb\">Strenghåndtering</a></li>\n",
+ " <li ><a href=\"Innebygde%20funksjoner.ipynb\">Innebygde funksjoner og lister</a></li>\n",
+ " <li><a href=\"Fjesboka.ipynb\">Fjesboka</a></li>\n",
+ " <li ><a href=\"Akkorder%20og%20toner.ipynb\">Akkorder og toner</a></li>\n",
+ " <li ><a href=\"Ideel%20gasslov.ipynb\">Ideel Gasslov</a></li>\n",
+ " <li><a href=\"Sammenhengende%20tallrekke.ipynb\">Sammenhengende Tallrekke</a></li>\n",
+ " <li ><a href=\"Sortering.ipynb\">Sortering</a></li>\n",
+ " <li ><a href=\"Strengmanipulasjon.ipynb\">Strengmanipulasjon</a></li>\n",
+ " <li ><a href=\"Kryptering.ipynb\">Kryptering</a></li>\n",
+ " <li ><a href=\"Litt%20sjakk.ipynb\">Litt Sjakk</a></li>\n",
+ " <li ><a href=\"Lister%20og%20tupler.ipynb\">Lister og tupler</a></li>\n",
+ " </ul>\n",
+ " </div>\n",
+ "</nav>\n",
+ "\n",
+ "# Strenghåndtering\n",
+ "\n",
+ "**Læringsmål:**\n",
+ "\n",
+ "* Strenger\n",
+ "* Løkker\n",
+ " \n",
+ "\n",
+ "I denne oppgaven skal vi lære å sammenligne, reversere og sjekke om en streng er et palindrom."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "### a)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Lag en funksjon `check_equal(str1, str2)` som sjekker om to strenger er like ved å sammenligne dem tegn for tegn. Funksjonen returnerer `True` hvis strengene er like; `False` ellers.\n",
+ "\n",
+ "***Skriv koden din i kodeblokken under:***"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "**Test av kode:**"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "str1 = 'hei'\n",
+ "str2 = 'hello'\n",
+ "str3 = 'hello'\n",
+ "print(check_equal(str1, str2))\n",
+ "print(check_equal(str3, str2))\n",
+ "# Denne koden skal returnere:\n",
+ "# False\n",
+ "# True"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "### b)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Lag en funksjon `reversed_word(string)` som tar inn en streng, reverserer den og returnerer den reverserte strengen. Dette skal gjøres tegn for tegn med en løkke.\n",
+ "\n",
+ "***Skriv koden din i kodeblokken under:***"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "**Test av kode:**"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "string = 'star desserts'\n",
+ "print(reversed_word(string))\n",
+ "# Denne koden skal returnere:\n",
+ "# stressed rats"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "### c)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Et palindrom er et ord som staves likt begge veier (eks. “abbaâ€). Lag en funksjon `check_palindrome(string)` som returnerer `True` om en streng er et palindrom; `False` ellers.\n",
+ "\n",
+ "***Skriv koden din i kodeblokken under:***"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "**Test av kode:**"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2019-07-04T06:14:09.130262Z",
+ "start_time": "2019-07-04T06:14:08.799088Z"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "str1 = 'agnes i senga'\n",
+ "str2 = 'hello'\n",
+ "print(check_palindrome(str1))\n",
+ "print(check_palindrome(str2))\n",
+ "# Denne koden skal returnere:\n",
+ "# True\n",
+ "# False"
+ ]
+ },
+ {
+ "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-04T06:13:35.155690Z",
+ "start_time": "2019-07-04T06:13:35.144678Z"
+ },
+ "deletable": false,
+ "editable": false,
+ "hidden": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "bruk metoder du har laget tidligere som hjelpemetoder."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "### d)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Lag en funksjon `contains_string(str1, str2)` som tar inn to strenger og sjekker om den første strengen inneholder den andre. Dersom den gjør det, returner **posisjonen** den andre strengen begynner på (fra 0). Returner **-1** ellers.\n",
+ "\n",
+ "***Skriv koden din i kodeblokken under:***"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "**Test av kode:**"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "str1 = 'pepperkake'\n",
+ "str2 = 'per'\n",
+ "str3 = 'ola'\n",
+ "print(contains_string(str1, str2))\n",
+ "print(contains_string(str1, str3))\n",
+ "# Denne koden skal returnere:\n",
+ "# 3\n",
+ "# -1"
+ ]
+ }
+ ],
+ "metadata": {
+ "celltoolbar": "Edit Metadata",
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.7.4"
+ },
+ "toc": {
+ "base_numbering": 1,
+ "nav_menu": {},
+ "number_sections": false,
+ "sideBar": true,
+ "skip_h1_title": false,
+ "title_cell": "Table of Contents",
+ "title_sidebar": "Contents",
+ "toc_cell": false,
+ "toc_position": {},
+ "toc_section_display": true,
+ "toc_window_display": false
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/Ovinger/Oving6/Strengmanipulasjon.ipynb b/Ovinger/Oving6/Strengmanipulasjon.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..9874c9f65df7e85c8e0e0f9b4877257c0dd2c984
--- /dev/null
+++ b/Ovinger/Oving6/Strengmanipulasjon.ipynb
@@ -0,0 +1,200 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": 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=\"_Oving6.ipynb\">Øving 6</a>\n",
+ " </div>\n",
+ " <ul class=\"nav navbar-nav\">\n",
+ " <li ><a href=\"Aksessering.ipynb\">Aksessering av karakter</a></li>\n",
+ " <li ><a href=\"Strenger%20og%20konkatinering.ipynb\">Konkatinering</a></li>\n",
+ " <li ><a href=\"Slicing.ipynb\">Slicing</a></li>\n",
+ " <li ><a href=\"Tekstbehandling.ipynb\">Tekstbehandling</a></li>\n",
+ " <li ><a href=\"Strenghandtering.ipynb\">Strenghåndtering</a></li>\n",
+ " <li ><a href=\"Innebygde%20funksjoner.ipynb\">Innebygde funksjoner og lister</a></li>\n",
+ " <li ><a href=\"Fjesboka.ipynb\">Fjesboka</a></li>\n",
+ " <li ><a href=\"Akkorder%20og%20toner.ipynb\">Akkorder og toner</a></li>\n",
+ " <li><a href=\"Ideel%20gasslov.ipynb\">Ideel Gasslov</a></li>\n",
+ " <li><a href=\"Sammenhengende%20tallrekke.ipynb\">Sammenhengende Tallrekke</a></li>\n",
+ " <li ><a href=\"Sortering.ipynb\">Sortering</a></li>\n",
+ " <li class=\"active\"><a href=\"Strengmanipulasjon.ipynb\">Strengmanipulasjon</a></li>\n",
+ " <li ><a href=\"Kryptering.ipynb\">Kryptering</a></li>\n",
+ " <li ><a href=\"Litt%20sjakk.ipynb\">Litt Sjakk</a></li>\n",
+ " <li ><a href=\"Lister%20og%20tupler.ipynb\">Lister og tupler</a></li>\n",
+ " </ul>\n",
+ " </div>\n",
+ "</nav>\n",
+ "\n",
+ "# Strengmanipulasjon\n",
+ "\n",
+ "**Læringsmål:**\n",
+ "\n",
+ "* Strenger\n",
+ "* Funksjoner\n",
+ "* Lister\n",
+ "* Løkker\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "### a)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Lag funksjonen `find_substring_indexes` som tar inn to strenger som argumenter (str1 og str2). Funksjonen skal finne plasseringen til alle substrengene av str1 i strengen str2. Den første indeksen til hver forekomst av str1 som substreng i str2 skal samles i en liste, og denne listen skal returneres. \n",
+ "Funksjonen tar ikke hensyn til store og små bokstaver, altså vil str2 = \"Is this the real life? Is this just fantasy?\" ha 4 substrenger av str1 = \"iS\"; \"**Is** th**is** the real life? **Is** th**is** just fantasy?\".\n",
+ "\n",
+ "**Eksempel på kjøring:**\n",
+ "```python\n",
+ "str1 = \"iS\", str2 = \"Is this the real life? Is this just fantasy?\"\n",
+ "output -> [0, 5, 23, 28]\n",
+ " \n",
+ "str1 = \"oo\", str2 = \"Never let you go let me go. Never let me go ooo\" #Legg merke til at 'ooo' telles som to substrenger av 'oo'!\n",
+ "output -> [44, 45]\n",
+ "```\n",
+ "\n",
+ "***Skriv funksjonen i kodeblokken under og test at den fungerer som den skal:***"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "### b)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Nå skal du lage en funksjon som tar inn tre strenger som argumenter (str1, str2 og str3). Funksjonen skal finne alle substrenger av str1 i str2, og returnere en streng der disse substrengene i str2 er endret til str3. (Dette skal gjøres uten å bruke innebygde funksjoner.)\n",
+ "\n",
+ "**Eksempel på kjøring:**\n",
+ "```python\n",
+ "str1 = \"iS\", str2 = \"Is this the real life? Is this just fantasy?\", str3 = \"cool\"\n",
+ "output -> cool thcool the real life? cool thcool just fantasy?\n",
+ " \n",
+ "str1 = \"oo\", str2 = \"Never let you goooo let me goo. Never let me goo oooo\", str3 = \"cool\"\n",
+ "output -> Never let you gcoolcoolcool let me gcool. Never let me gcool coolcoolcool\n",
+ "```\n",
+ "\n",
+ "***Skriv funksjonen i kodeblokken under og test at den fungerer som den skal:***"
+ ]
+ },
+ {
+ "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": [
+ "Bruk funksjonen fra a)."
+ ]
+ }
+ ],
+ "metadata": {
+ "celltoolbar": "Edit Metadata",
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.7.4"
+ },
+ "toc": {
+ "base_numbering": 1,
+ "nav_menu": {},
+ "number_sections": false,
+ "sideBar": true,
+ "skip_h1_title": false,
+ "title_cell": "Table of Contents",
+ "title_sidebar": "Contents",
+ "toc_cell": false,
+ "toc_position": {},
+ "toc_section_display": true,
+ "toc_window_display": false
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/Ovinger/Oving6/Tekstbehandling.ipynb b/Ovinger/Oving6/Tekstbehandling.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..a7f330286cd798d9610e198d141e4ad4d29a0b7a
--- /dev/null
+++ b/Ovinger/Oving6/Tekstbehandling.ipynb
@@ -0,0 +1,486 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": 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=\"_Oving6.ipynb\">Øving 6</a>\n",
+ " </div>\n",
+ " <ul class=\"nav navbar-nav\">\n",
+ " <li ><a href=\"Aksessering.ipynb\">Aksessering av karakter</a></li>\n",
+ " <li ><a href=\"Strenger%20og%20konkatinering.ipynb\">Konkatinering</a></li>\n",
+ " <li ><a href=\"Slicing.ipynb\">Slicing</a></li>\n",
+ " <li class=\"active\"><a href=\"Tekstbehandling.ipynb\">Tekstbehandling</a></li>\n",
+ " <li ><a href=\"Strenghandtering.ipynb\">Strenghåndtering</a></li>\n",
+ " <li ><a href=\"Innebygde%20funksjoner.ipynb\">Innebygde funksjoner og lister</a></li>\n",
+ " <li><a href=\"Fjesboka.ipynb\">Fjesboka</a></li>\n",
+ " <li ><a href=\"Akkorder%20og%20toner.ipynb\">Akkorder og toner</a></li>\n",
+ " <li ><a href=\"Ideel%20gasslov.ipynb\">Ideel Gasslov</a></li>\n",
+ " <li><a href=\"Sammenhengende%20tallrekke.ipynb\">Sammenhengende Tallrekke</a></li>\n",
+ " <li ><a href=\"Sortering.ipynb\">Sortering</a></li>\n",
+ " <li ><a href=\"Strengmanipulasjon.ipynb\">Strengmanipulasjon</a></li>\n",
+ " <li ><a href=\"Kryptering.ipynb\">Kryptering</a></li>\n",
+ " <li ><a href=\"Litt%20sjakk.ipynb\">Litt Sjakk</a></li>\n",
+ " <li ><a href=\"Lister%20og%20tupler.ipynb\">Lister og tupler</a></li>\n",
+ " </ul>\n",
+ " </div>\n",
+ "</nav>\n",
+ "\n",
+ "# Tekstbehandling\n",
+ "\n",
+ "**Læringsmål:**\n",
+ "\n",
+ "* Strenger\n",
+ "* Funksjoner\n",
+ "* Løkker\n",
+ "* Kodeforståelse\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "heading_collapsed": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "## Generelt om testing, søking og manipulering av strenger"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "hidden": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "**Testing av strenger:**\n",
+ "\n",
+ "Python har to nyttige operatoerer `in` og `not in`. Disse kan brukes til å sjekke om en streng er inneholdt i en annen.\n",
+ "\n",
+ ">La streng 1 og streng 2 være tilordnet to forskjellige strenger.\n",
+ "Det logiske uttrykket:\n",
+ "```python\n",
+ "streng1 in streng2\n",
+ "```\n",
+ "vil returnere True om streng1 er inneholdt i streng2, f.eks vil uttrykket\n",
+ "```python\n",
+ "\"Ber\" in \"Bob Bernt\"\n",
+ "```\n",
+ "returnere True, mens uttrykket\n",
+ "```python\n",
+ "\"obo\" in \"Bob Bernt\"\n",
+ "```\n",
+ "returnerer False.\n",
+ "Tilsvarende vil det logiske uttrykket\n",
+ "```python\n",
+ "streng1 not in streng2\n",
+ "```\n",
+ "returnere True om streng1 IKKE er inneholdt i streng2, altså det motsatte av det streng1 in streng2 ville returnert.\n",
+ "\n",
+ "Strenger i Python har flere metoder som kan brukes til å teste en streng for bestemte karaktertrekk. Tabellen under viser enkelte av disse:\n",
+ "\n",
+ "\n",
+ "\n",
+ "Generelt format for bruk av disse metodene er: streng.metode(argument)\n",
+ "\n",
+ "F.eks. vil `streng.isupper()` returnere *True* om alle bokstavene i streng er blokkbokstaver og lengden til strengen er større eller lik 1.\n",
+ "\n",
+ "Metodene i tabellen over er boolske metoder som vil returnere enten *True* eller *False*.\n",
+ "\n",
+ "**Modifisering av strenger:**\n",
+ "\n",
+ "Strengemodifiserings-metoder (se tabellen nedenfor) er metoder som returnerer en modifisert kopi av strengen metoden kalles på. På denne måten kan man \"simulere\" at strenger endres, enda de ikke egentlig vil dette (strenger er jo ikke-muterbare).\n",
+ "\n",
+ "\n",
+ "\n",
+ "F.eks. vil \n",
+ "```python\n",
+ "\" Cake is good \".strip()\n",
+ "```\n",
+ "\n",
+ "returnere strengen \"Cake is good\".\n",
+ "\n",
+ "**Søking i strenger og erstatting av karakterer:**\n",
+ "\n",
+ "Det finnes også flere metoder som kan søke og finne substrenger i en streng, om de skulle være til stede. I tillegg er det mulig å bruke metoden `streng.replace(old,new)` til å få en kopi av streng der alle instanser av *old* er erstattet med instanser av *new*.\n",
+ "\n",
+ "**Eksempel på bruk av replace(old,new):**"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2019-07-03T15:07:18.895928Z",
+ "start_time": "2019-07-03T15:07:18.885645Z"
+ },
+ "hidden": true
+ },
+ "outputs": [],
+ "source": [
+ "s = \"I like cake, and I also like ice cream.\"\n",
+ "s = s.replace(\"like\",\"love\") #Argumentene old og new må være strenger. Husk at s.replace(old,new) IKKE endrer på strengen s, men returnerer en modifisert kopi av denne. Det er dermed viktig å tilordne en variabel til den modifiserte strengen om den skal brukes senere.\n",
+ "print(s)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "heading_collapsed": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "## Kort om repetisjons-operatoren og splitting av strenger"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "hidden": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "**Repetisjons-operatoren:**\n",
+ "\n",
+ "Som du alt har lært, kan man duplisere en liste vha. repetisjons-operatoren *. Det samme gjelder for strenger. Det generelle formatet er:\n",
+ "\n",
+ "*streng * n*\n",
+ "\n",
+ "Dette vil gi en streng bestående av n repeterte kopier av strengen *streng*.\n",
+ "\n",
+ "**Eksempler på bruk av split: (kjør koden)**"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "hidden": true
+ },
+ "outputs": [],
+ "source": [
+ "#Eks 1\n",
+ "s = \"bla\"*5\n",
+ "print(s)\n",
+ " \n",
+ "#Eks 2\n",
+ "for i in range(1,5):\n",
+ " print('X'*i)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "hidden": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "**Splitting av en streng:**\n",
+ "\n",
+ "Python har en metode kalt *split* som returnerer en liste med ordene i strengen metoden blir kalt på. Dvs. at `s.split()` returnerer en liste bestående av ordene i strengen s.\n",
+ "\n",
+ "*split*-metoden kan ta inn en streng som argument. Om *split*-metoden ikke får inn noe argument vil den bruke mellomrom som skilletegn. Om den derimot får inn et argument, f.eks. '-', vil den splitte på disse, og ikke mellomrom."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2019-07-03T15:16:25.720013Z",
+ "start_time": "2019-07-03T15:16:25.712102Z"
+ },
+ "hidden": true
+ },
+ "outputs": [],
+ "source": [
+ "#Eks 1\n",
+ "s = \"Lilac and gooseberries\"\n",
+ "liste = s.split() #Vil bruker standard-skilletegnet som er mellomrom\n",
+ "print(liste)\n",
+ " \n",
+ "#Eks 2\n",
+ "s = \"ISBN 978-0-765-32635-5\"\n",
+ "liste = s.split('-') #Vil bruke '-' som skilletegn\n",
+ "print(liste)\n",
+ " \n",
+ "#Eks 3\n",
+ "s = \"Numuhukumakiaki'aialunamor\"\n",
+ "liste = s.split('u') #Vil bruke 'u' som skilletegn\n",
+ "print(liste)\n",
+ "\n",
+ "#Eks 4\n",
+ "s = \"98765439876542987698762498721598652976298763\"\n",
+ "liste = s.split('987') #Vil bruke '987' som skilletegn\n",
+ "print(liste)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "## a)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Skriv en funksjon som tar inn en streng som argument, og endrer bokstavene i den til blokkbokstaver. I tillegg skal funksjonen fjerne eventuell whitespace på start og slutt av strengen. Den resulterende strengen skal så returneres.\n",
+ "\n",
+ "**Eksempel på kjøring:**\n",
+ "```python\n",
+ "streng = \" \\n Far over the Misty Mountains \\t \"\n",
+ "output -> FAR OVER THE MISTY MOUNTAINS\n",
+ "```\n",
+ "\n",
+ "***Skriv koden din i kodeblokken under:***"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## b)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Lag en funksjon som tar inn en streng og en karakter som argumenter. Funksjonen skal splitte strengen med hensyn på denne karakteren, og returnere listen man får av denne splittingen.\n",
+ "\n",
+ "```python\n",
+ "streng = \"Hakuna Matata\", karakter = 'a'\n",
+ "output -> ['H', 'kun', ' M', 't', 't', '']\n",
+ "```\n",
+ "\n",
+ "***Skriv koden din i kodeblokken under***"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "## c)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Hva vil følgende kodesnutt skrive ut til skjerm?\n",
+ "```python\n",
+ "s1 = \"eat\"\n",
+ "s2 = \"I want to be like a caterpillar. Eat a lot. Sleep for a while. Wake up beautiful.\"\n",
+ "def func(s1, s2):\n",
+ " s = \"My bed is a magical place where I suddenly remember everything I forgot to do.\"\n",
+ " if s1 in s2.lower():\n",
+ " s = \"The more you weigh, the harder you are to kidnap. Stay safe. Eat cake.\"\n",
+ " print(s)\n",
+ "```\n",
+ "```python\n",
+ "func(s1,s2)\n",
+ "```"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Svar:** <dobbeltklikk her for å skrive\\>\n",
+ " "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "## d)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Skriv en funksjon som, vha. løkker og repetisjons-operatoren, skriver ut følgende til skjerm:\n",
+ " \n",
+ "```\n",
+ "Z\n",
+ "ZZ\n",
+ "ZZZ\n",
+ "ZZZZ\n",
+ "ZZZZZ\n",
+ "ZZZZZZ\n",
+ "ZZZZZZZ\n",
+ "ZZZZZZZZ\n",
+ "ZZZZZZZ\n",
+ "ZZZZZZ\n",
+ "ZZZZZ\n",
+ "ZZZZ\n",
+ "ZZZ\n",
+ "ZZ\n",
+ "Z\n",
+ "```\n",
+ "\n",
+ "***Skriv koden din i kodeblokken under:***"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "heading_collapsed": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "#### Hint"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "hidden": true,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Bruk to for-løkker (IKKE nøstede løkker), der den første teller opp, f.o.m. 1 t.o.m. 7, og den andre teller ned, f.o.m. 8 t.o.m. 1. \n",
+ "Se også \"Eksempler med repetisjons-operatoren\" under \"Kort om repetisjons-operatoren og splitting av strenger\"."
+ ]
+ }
+ ],
+ "metadata": {
+ "celltoolbar": "Edit Metadata",
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.7.4"
+ },
+ "toc": {
+ "base_numbering": 1,
+ "nav_menu": {},
+ "number_sections": false,
+ "sideBar": true,
+ "skip_h1_title": false,
+ "title_cell": "Table of Contents",
+ "title_sidebar": "Contents",
+ "toc_cell": false,
+ "toc_position": {},
+ "toc_section_display": true,
+ "toc_window_display": false
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/Ovinger/Oving6/_Oving6.ipynb b/Ovinger/Oving6/_Oving6.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..9cb03384b9b06e3feb1943b17854d44637b500b7
--- /dev/null
+++ b/Ovinger/Oving6/_Oving6.ipynb
@@ -0,0 +1,92 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "# Øving 6\n",
+ "\n",
+ "**Læringsmål:** \n",
+ "\n",
+ "* Lister\n",
+ "* Tekstbehandling\n",
+ "* Numpy\n",
+ "\n",
+ " \n",
+ "\n",
+ "## Godkjenning:\n",
+ "\n",
+ "For å få godkjent øvingen må du gjøre ***4*** av ***13*** oppgaver. \n",
+ "\n",
+ "Oppgaver som er litt ekstra vanskelig er markert med stjerne. Oppgaver som går forbi det som er blitt forelest er markert med to stjerner.\n",
+ "\n",
+ "Alle oppgavene skal demonstreres til en læringsassistent på sal. I oppgaver der du skriver programkode skal også denne vises fram. Lykke til!\n",
+ "\n",
+ "Oppgave | Tema | Vanskelighetsgrad\n",
+ "--- | --- | ---\n",
+ "[Aksessering av karakterer i streng](Aksessering.ipynb) |Strenger| \n",
+ "[Strenger og konkatinering](Strenger%20og%20konkatinering.ipynb)|Strenger|\n",
+ "[Slicing av strenger](Slicing.ipynb)|Strenger|\n",
+ "[Tekstbehandling](Tekstbehandling.ipynb)|Strenger|\n",
+ "[Strenghåndtering](Strenghandtering.ipynb)|Strenger, Løkker|\n",
+ "[Innebygde funksjoner og lister](Innebygde%20funksjoner.ipynb)|Lister|\n",
+ "[Fjesboka](Fjesboka.ipynb)|Lister, Strenger|\n",
+ "[Akkorder og toner](Akkorder%20og%20toner.ipynb)|Lister|Bør ha noe kunnskap innen musikk\n",
+ "[Ideel gasslov](Ideel%20gasslov.ipynb)|Lister, Løkker, Strenger| Kjemi-oppgave\n",
+ "[Sammenhengende tallrekke](Sammenhengende%20tallrekke.ipynb)|Lister, løkker|\n",
+ "[Sortering](Sortering.ipynb)|Lister, Algoritmer|\n",
+ "[Strengmanipulasjon](Strengmanipulasjon.ipynb)|Strenger, Lister| \n",
+ "[Kryptering](Kryptering.ipynb)|Lister, Sikkerhet| \n",
+ "[Litt sjakk](Litt%20sjakk.ipynb)|2D-lister| \n",
+ "[Lister og tupler](Lister%20og%20tupler.ipynb)|Lister, Tupler| "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ }
+ ],
+ "metadata": {
+ "celltoolbar": "Edit Metadata",
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.7.4"
+ },
+ "toc": {
+ "base_numbering": 1,
+ "nav_menu": {},
+ "number_sections": false,
+ "sideBar": true,
+ "skip_h1_title": false,
+ "title_cell": "Table of Contents",
+ "title_sidebar": "Contents",
+ "toc_cell": false,
+ "toc_position": {},
+ "toc_section_display": true,
+ "toc_window_display": false
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}