diff --git a/Ovingsforelesning/uke44/oppgaverLF.ipynb b/Ovingsforelesning/uke44/oppgaverLF.ipynb new file mode 100644 index 0000000..2492590 --- /dev/null +++ b/Ovingsforelesning/uke44/oppgaverLF.ipynb @@ -0,0 +1,647 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Øvingsforelesning 8 - ITGK\n", + "Algoritmer og rekursjon" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Oppgave 1: Is int\n", + "\n", + "Vi ønsker å lage funksjonen `is_int(str)` ved hjelp av try-except. Funksjonen skal returnere `True` om strengen `str` kan leses som et heltall med `int()`" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def is_int(str):\n", + " try:\n", + " int(str)\n", + " return True\n", + " except:\n", + " return False\n", + "print(is_int(\"2\"))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Oppgave 2: Skriving til og lesing fra fil\n", + "\n", + "Vi har listen `weather_data`: `[[\"mandag”, \"sol\", 2], [“tirsdag”, \"regn\", 13], [“onsdag”, \"vind\", 5], [“torsdag”, \"torden\", 1]]`.\n", + "\n", + "Lag en funksjon som tar inn værdata og lagrer dette i en tekstfil.\n", + "\n", + "I tillegg skal du lage en funksjon for å lese denne tekstfilen og hente ut data på samme format som det var før det ble lagret. \n", + "\n", + "`write_data(weather_data, filename)`\n", + "\n", + "`read_data(filename)`" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def write_data(weather_data, filename):\n", + " with open(filename, 'w') as file:\n", + " for liste in weather_data:\n", + " line = liste.copy()\n", + " line[2] = str(line[2])\n", + " file.write(\",\".join(line))\n", + " file.write(\"\\n\")\n", + "\n", + "def read_data(filename):\n", + " out = []\n", + " with open(filename, 'r') as file:\n", + " for line in file.readlines():\n", + " elements = line.strip().split(',')\n", + " elements[2] = int(elements[2])\n", + " out.append(elements)\n", + " return out\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "True\n" + ] + } + ], + "source": [ + "weather_data = [[\"mandag\", \"sol\", 2], [\"tirsdag\", \"regn\", 13], [\"onsdag\", \"vind\", 5], [\"torsdag\", \"torden\", 1]]\n", + "\n", + "write_data(weather_data, \"weather.txt\")\n", + "\n", + "weather_data_from_file = read_data(\"weather.txt\")\n", + "\n", + "print(weather_data == weather_data_from_file)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Oppgave 3\n", + "\n", + "Lag en **rekursiv funksjon** som tar inn et heltall som parameter, og returnerer fakulteten av tallet" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "def fac(n):\n", + " if n == 1:\n", + " return 1\n", + " return n * fac(n-1)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1\n", + "24\n", + "30414093201713378043612608166064768844377641568960512000000000000\n" + ] + } + ], + "source": [ + "print(fac(1)) # Skal være 1\n", + "print(fac(4)) # Skal være 24\n", + "print(fac(50))# Skal være 30414093201713378043612608166064768844377641568960512000000000000" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Oppgave 4\n", + "Lag en funksjon `fib(n)` som regner ut the `n`-te fibonaccitallet\n", + "\n", + "Fibonaccitall: 0,1,1,2,3,5,8, …\n", + "\n", + "Regelen er at neste tall er summen av de to forrige\n" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [], + "source": [ + "def fib(n):\n", + " if n <= 1:\n", + " return n\n", + " return fib(n-1) + fib(n-2)" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "14930352\n" + ] + } + ], + "source": [ + "# print(fib(2)) # 1\n", + "# print(fib(5)) # 5\n", + "# print(fib(20)) # 6765\n", + "print(fib(37))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Oppgave 5\n", + "\n", + "Lag en funksjon som tar inn en liste som parameter. Listen kan inneholde tall eller andre lister, som igjen kan inneholde tall eller aldre lister, osv. \n", + "\n", + "Funksjonen skal returnere summen av alle tallene i listen, inkludert tallene i indre lister\n", + "\n", + "Eksempel: `sum_list([1,3,[5,3], [6,[4,2]]])` = 24" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [], + "source": [ + "def sum_list(lst):\n", + " total = 0\n", + " for element in lst:\n", + " if isinstance(element, list):\n", + " total += sum_list(element)\n", + " else:\n", + " total += element\n", + " return total\n" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "15\n", + "24\n" + ] + } + ], + "source": [ + "print(sum_list([1,2,3,4,5])) # 15\n", + "print(sum_list([1,3,[5,3],[6,[4,2]]])) # 24" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Eksamen TDT4110 Høst 2019\n", + "\n", + "Denne eksamenen var **ikke** hjemmeeksamen, og hadde **ikke** mulighet til å kjøre kode.\n", + "\n", + "#### Domenebeskrivelse\n", + "Oppgavene handler om å hjelpe fiskebåter med registrering av fangst og videresalg til kunder.\n", + "Firmaet Avkok A/S tar imot fangst fra mange ulike båter. Fangsten varierer i fiskeslag og antall kilo kjøpt.\n", + "Når butikker og restauranter kjøper fisk, skal båten som fanget fisken få betalt etter gjeldende kilopris.\n", + "Vi kan anta at når en handel blir registrert i systemet, blir den fysiske overføringen av fisken også gjennomført samtidig.\n", + "Du kan også anta at du ikke trenger å tenke på hvor fisken fysisk blir lagret – dette avgjøres av båt og kunde.\n", + "Du fungerer kun som mellomledd og får en viss provisjon per handel. Du trenger heller ikke ta hensyn til at fisk råtner.\n", + "\n", + "#### Beskrivelse av datastruktur\n", + "Registeret over båter og lagret fangst er en dictionary kalt register.\n", + "Nøkkelen er registreringsnummeret til båten. Dette er unikt for hver båt.\n", + "Knyttet til hver nøkkel ligger verdien: den lagrede fangsten.\n", + "Denne er representert ved en todimensjonal liste der hvert indre element representerer et fiskeslag og antall kilo som er tilgjengelig for salg.\n", + "\n", + "#### Eksempel\n", + "Båten med registreringsnummer N64Ø har 511 kilo torsk og 342 kilo hyse til salgs.\n", + "Båten Z4F har 233 kilo torsk og 122 kilo hyse.\n", + "Da ser strukturen slik ut:\n", + "\n", + "```python\n", + "register = {'N34Ø': [['torsk', 511], ['hyse', 342]], 'Z4F': [['torsk', 233]]}\n", + "```\n", + "\n", + "Gjennom hele oppgaven kan du bruke funksjoner fra tidligere deloppgaver.\n", + "Om du ikke har løst en tidligere oppgave, kan du anta at funksjonen eksisterer." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Oppgave 3a – Registrering av fiskebåt\n", + "\n", + "Du tar imot fisk fra både kjente og nye fiskebåter. Fiskeren registrerer en ny båt ved å taste inn nummeret til båten i samsvar med fiskeriregisteret. \n", + "I bakgrunnen kaller datasystemet en funksjon kalt `check_registration` med registreringsnummeret som parameter. \n", + "Funksjonen returnerer `True` eller `False` avhengig av om registreringsnummeret følger retningslinjene i registeret.\n", + "\n", + "Reglene er som følger: \n", + "Nummeret i fiskeriregisteret har formen **bokstav–tall–bokstav**, for eksempel **N64Ø** («Solbris»). \n", + "Den første bokstaven tilsvarer fylkesbokstaven som ble brukt på bilskilt fram til omkring 1970. \n", + "Tallene blir fortløpende gitt til fiskere i hver enkelt kommune, og kan derfor ha enten ett eller to siffer. \n", + "Til slutt står det én eller to bokstaver som angir kommunen. \n", + "\n", + "Eksemplet **N64Ø** viser at dette var fiskefartøy nummer 64 i Øksnes kommune i Nordland. \n", + "Vi gjentar: **\\<1 bokstav>\\<1–2 siffer>\\<1–2 bokstaver\\>**.\n", + "\n", + "Skriv funksjonen `check_registration` som skal ta imot et registreringsnummer og returnere om det er skrevet i samsvar med retningslinjene i fiskeriregisteret.\n", + "\n", + "#### Eksempel\n", + "```python\n", + "print(check_registration(\"N64Ø\")) # True\n", + "print(check_registration(\"NN4Ø\")) # False\n", + "```\n", + "\n", + "Eksemplene over er kun illustrasjoner – man skal ikke hardkode sjekk mot akkurat disse.\n", + "\n", + "Følgende registreringsnumre skal for eksempel også returnere `True`: **N4A**, **B46MC**, **P53V**, **Z4HB**.\n", + "\n", + "Følgende registreringsnumre skal returnere `False`: **NR5H**, **P557J**, **672NH**." + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [], + "source": [ + "def check_registration(regnummer):\n", + " if not regnummer[0].isalpha():\n", + " return False\n", + " if not regnummer[1].isnumeric():\n", + " return False\n", + " if not regnummer[-1].isalpha():\n", + " return False\n", + " \n", + " if len(regnummer) == 3:\n", + " return True\n", + " if len(regnummer) == 4 and regnummer[2].isalnum():\n", + " return True\n", + " if len(regnummer) == 5 and regnummer[2].isnumeric() and regnummer[3].isalpha():\n", + " return True\n", + " \n", + " return False" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "True\n", + "True\n", + "True\n", + "True\n", + "False\n", + "False\n", + "False\n" + ] + } + ], + "source": [ + "print(check_registration(\"N4A\"))\n", + "print(check_registration(\"B46MC\"))\n", + "print(check_registration(\"P53V\"))\n", + "print(check_registration(\"Z4HB\"))\n", + "\n", + "print(check_registration(\"NR5H\"))\n", + "print(check_registration(\"P557J\"))\n", + "print(check_registration(\"672NH\"))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Oppgave 3b\n", + "\n", + "Hver båt har lagret fisken i en todimensjonal liste. \n", + "Det kan være nyttig å finne ut hvor mye som er lagret av en bestemt fiskeart. \n", + "\n", + "Her kan vi ta for gitt at den lagrede fisken for en gitt fisker er tilgjengelig gjennom parameteren `store`, \n", + "mens fisketypen er en streng gitt i parameteren `kind`. \n", + "\n", + "Hvis det ikke finnes noen fisk av denne typen, skal funksjonen returnere tallet `0`.\n", + "\n", + "Skriv funksjonen `fish_amount` som tar parameterne `store` og `kind`.\n", + "\n", + "#### Eksempel\n", + "```python\n", + "store = [['torsk', 200], ['sei', 100]]\n", + "print(fish_amount(store, 'torsk')) # 200\n", + "print(fish_amount(store, 'månefisk')) # 0" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": {}, + "outputs": [], + "source": [ + "def fish_amount(store, kind):\n", + " for kind_in_store, amount in store:\n", + " if kind_in_store == kind:\n", + " return amount\n", + " return 0\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "200\n", + "0\n" + ] + } + ], + "source": [ + "store = [[\"torsk\", 200], [\"sei\", 100]]\n", + "print(fish_amount(store, \"torsk\"))\n", + "print(fish_amount(store, \"månefisk\"))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Oppgave 3c – Legg til fisk\n", + "\n", + "Lageret skal oppdateres når det kommer inn mer fisk. \n", + "Dette oppgis som en liste med fiskeslag og antall kilo, for eksempel `['torsk', 200]`. \n", + "\n", + "Lag et nytt element dersom fisketypen ikke allerede finnes i lageret. \n", + "\n", + "Skriv funksjonen `add_fish`, som tar `store` og en `liste` som inputparametere, og returnerer det oppdaterte lageret.\n", + "\n", + "#### Eksempel\n", + "```python\n", + "store = [['torsk', 200], ['sei', 100]]\n", + "add_fish(store, ['torsk', 100])\n", + "add_fish(store, ['hyse', 70])\n", + "print(store) # [['torsk', 300], ['sei', 100], ['hyse', 70]]\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def add_fish(store, liste):\n", + " for elem in store:\n", + " if elem[0] == liste[0]:\n", + " elem[1] += liste[1]\n", + " break\n", + " else:\n", + " store.append(liste)\n", + " \n", + " return store\n", + "\n", + " \n", + "def add_fish(store, liste):\n", + " found = False\n", + " for elem in store:\n", + " if elem[0] == liste[0]:\n", + " elem[1] += liste[1]\n", + " found = True\n", + " break\n", + " \n", + " if not found:\n", + " store.append(liste)\n", + "\n", + " return store\n", + " \n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[['torsk', 300], ['sei', 100], ['hyse', 70]]\n" + ] + } + ], + "source": [ + "\n", + "store = [['torsk', 200], ['sei', 100]]\n", + "add_fish(store, ['torsk', 100])\n", + "add_fish(store, ['hyse', 70])\n", + "print(store) # [['torsk', 300], ['sei', 100], ['hyse', 70]]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Oppgave 3d – Lagre masse fisk\n", + "\n", + "En fisker kan fange mange typer fisk på én gang – og ønsker derfor å rapportere inn alt samlet. \n", + "Flere typer fisk rapporteres inn som en todimensjonal liste, på samme format som `store`: \n", + "`[['type', mengde], ['type', mengde], ['type', mengde]]`\n", + "\n", + "Skriv funksjonen `add_much_fish` som tar `store` og en 2D-liste som inputparametere.\n", + "\n", + "#### Eksempel\n", + "```python\n", + "store = [['torsk', 300], ['sei', 100], ['hyse', 70]]\n", + "add_much_fish(store, [['kveite', 120], ['torsk', 200]])\n", + "print(store) # [['torsk', 500], ['sei', 100], ['hyse', 70], ['kveite', 120]]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def add_much_fish(store, liste):\n", + " for fish in liste:\n", + " add_fish(store, fish)" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[['torsk', 500], ['sei', 100], ['hyse', 70], ['kveite', 120]]\n" + ] + } + ], + "source": [ + "store = [['torsk', 300], ['sei', 100], ['hyse', 70]]\n", + "add_much_fish(store, [['kveite', 120], ['torsk', 200]])\n", + "print(store) # [['torsk', 500], ['sei', 100], ['hyse', 70], ['kveite', 120]]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Bonus\n", + "\n", + "Skriv en funksjon som fjerner en viss mengde fisk fra et gitt `store`. \n", + "\n", + "- Dersom det blir **0 kg igjen** av fisken, skal den fjernes fra `store`. \n", + "- Dersom man prøver å **fjerne mer fisk enn det som finnes**, skal det gis en beskjed om at dette **ikke er lov**, og ingenting skal endres. \n", + "- Dersom fisken **ikke finnes** i `store`, skal det også gis beskjed om dette.\n", + "\n", + "#### Eksempel\n", + "```python\n", + "store = [['torsk', 300], ['sei', 100], ['hyse', 70]]\n", + "\n", + "remove_fish(store, ['sei', 50])\n", + "print(store) \n", + "# [['torsk', 300], ['sei', 50], ['hyse', 70]]\n", + "\n", + "remove_fish(store, ['hyse', 70])\n", + "print(store) \n", + "# [['torsk', 300], ['sei', 50]]\n", + "\n", + "remove_fish(store, ['torsk', 400])\n", + "# Utskrift: \"Kan ikke fjerne mer fisk enn det som finnes!\"\n", + "\n", + "remove_fish(store, ['laks', 10])\n", + "# Utskrift: \"Fisketypen finnes ikke i lageret!\"\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def remove_fish(store, remove):\n", + " for elem in store:\n", + " if elem[0] != remove[0]:\n", + " continue\n", + " if remove[1] > elem[1]:\n", + " print(f'Not enough {elem[0]} left!')\n", + " return\n", + " elif remove[1] == elem[1]:\n", + " store.remove(elem)\n", + " return\n", + " else:\n", + " elem[1] -= remove[1]\n", + " return\n", + " print(f'{remove[0]} not in the store!')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "månefisk is not in the store\n", + "[['torsk', 300], ['sei', 100], ['hyse', 70]]\n" + ] + } + ], + "source": [ + "\n", + "store = [['torsk', 300], ['sei', 100], ['hyse', 70]]\n", + "\n", + "remove_fish(store, ['sei', 50])\n", + "print(store)\n", + "# [['torsk', 300], ['sei', 50], ['hyse', 70]]\n", + "\n", + "remove_fish(store, ['hyse', 70])\n", + "print(store)\n", + "# [['torsk', 300], ['sei', 50]]\n", + "\n", + "remove_fish(store, ['torsk', 400])\n", + "# Not enough torsk left!\n", + "\n", + "remove_fish(store, ['laks', 10])\n", + "# laks not in the store!" + ] + } + ], + "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.12.6" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +}