solutions.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Øvingsforelesning 9 - TDT4110"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Eksamen høst 2017, oppgave 3\n",
    "\n",
    "Vi skal lage programvare for to fotobokser (fotoboks A og fotoboks B) som blant skal brukes til å måle gjennomsnittsfart på kjøretøy. \n",
    "\n",
    "<img src=\"../../Resources/Images/fotoboks.png\" style=\"width: 300px\">\n",
    "\n",
    "Hver fotoboks gjenkjenner registreringsnummer, dato (år, måned, dag) og tidspunkt (timer, minutter, sekund) for alle biler som passerer i en retning (først fotoboks A, deretter fotoboks B)\n",
    "\n",
    "Målinger fra en fotoboks lagres i en 2-dimensjonal liste på følgende format (her for boks A):\n",
    "\n",
    "```\n",
    "box_a= [ \n",
    "  [2017, 11, 17, 6, 21, 12, 'HB69082'], \n",
    "  [2017, 11, 17, 6, 21, 53, 'CV86023'], \n",
    "  ... ,  \n",
    "  [2017, 11, 17, 6, 23, 0, 'HD27560']\n",
    "]\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "box_a = [\n",
    "    [2017, 11, 17, 6, 21, 12, \"HB69082\"],\n",
    "    [2017, 11, 17, 6, 21, 53, \"CV86023\"],\n",
    "    [2017, 11, 17, 6, 23, 0, \"HD27560\"],\n",
    "    [2017, 11, 17, 6, 23, 2, \"UT29891\"],\n",
    "    [2017, 11, 17, 6, 24, 25, \"IS11293\"],\n",
    "    [2017, 11, 17, 6, 24, 40, \"EL73840\"],\n",
    "    [2017, 11, 17, 6, 24, 41, \"UT55227\"],\n",
    "    [2017, 11, 17, 6, 26, 55, \"NB59108\"],\n",
    "    [2017, 11, 17, 6, 27, 29, \"UT46408\"],\n",
    "    [2017, 11, 17, 6, 28, 19, \"LE68228\"],\n",
    "]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Oppgave 3b)\n",
    "\n",
    "Skriv funksjonen ```time_diff``` som tar inn to lister (```start``` og ```end```), der hver liste beskriver et tidspunkt angitt med dato og klokkeslett. Den første lista (```start```) er tidspunktet for passering av fotoboks A, mens den andre liste (```end```) er tidspunkt for passering av fotoboks B (senere tidspunkt enn A). **Funksjonen skal returnere differansen mellom tidspunktene angitt i sekunder.** \n",
    "\n",
    "Funksjonen skal også fungere for forskjellige datoer for å ta hensyn til kjøring rundt midnatt. For å beregne antall dager mellom datoer, kan du bruke funksjonen ```diff_date(d1,d2)``` som returnerer antall dager mellom ```d2``` og ```d1```, der ```d1``` og ```d2``` er dato spesifisert som ei liste på formatet *[y,m,d]*, for eksempel *[2017,11,17]*.\n",
    "\n",
    "**Eksempel på kjøring:**\n",
    "```\n",
    ">>> diff = time_diff([2017,11,17,6,24,40],[2017,11,17,6,32,40])\n",
    ">>> print(diff) \n",
    "480\n",
    ">>> diff = time_diff([2017,11,17,23,59,59],[2017,11,18,0,9,12])\n",
    ">>> print(diff)\n",
    "553\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### FORKLARING AV LØSNING\n",
    "\n",
    "Denne oppgaven kan se ganske vanskelig ut så jeg prøver meg på å legge ved en tekstlig forklaring av løsningen under. Tanken her er først (i motsetning til det jeg gjorde i forelesning) å se på forskjell i klokkeslett. La oss ta noen eksempler:\n",
    "\n",
    "06:20:00 - 06:21:00 = 60 sekunder\n",
    "18:21:32 - 18:22:33 = 61 sekunder\n",
    "\n",
    "Disse to er relatit enkle, for her kan vi bare ta `end - start` for hvert felt, altså f. eks. `end_minutt - start_minutt = 21 - 20 = 1` -> `60 sekunder`. Men hva skjer om et felt i `end` er mindre enn tilsvarende felt i `start`? La oss ta et eksempel til:\n",
    "\n",
    "06:20:05 - 06:21:00 = 55 sekunder\n",
    "\n",
    "Hvordan kan vi tenke på dette? La oss se på verdiene for de ulike feltene:\n",
    " - Time: `06 - 06 = 0` -> `0 sekunder`\n",
    " - Minutt: `21 - 20 = 1` -> `60 sekunder`\n",
    " - Sekund: `00 - 05 = -5` -> `-5 sekunder`\n",
    "\n",
    "Om vi tar summen av disse får vi 55, som er riktig svar! Dette er tankegangen som er benyttet gjennom hele løsningen av oppgaven under, hvor vi starter med den største enheten, og beveger oss til nærmeste \"hele\" av den, f. eks. når vi sjekker datoforskjeller beveger vi oss kun i steg på størrelse med en dag. Vi utnytter da at tidsforskjellen mellom klokkesletten er negative når `end` er mindre enn `start`, og dermed kan vi bevege oss bakover i tid mot løsningen:\n",
    "\n",
    "18:20:05 - 18:15:30 = -275 sekunder\n",
    "\n",
    "```python\n",
    "timestamp_diff = diff_date(start_date, end_date) * DAYS_TO_SECONDS\n",
    "```\n",
    "\n",
    "Deretter beveger vi oss til neste enhet, som er timer, og regner ut forskjellen her. Legg merke til at dersom timeverdien i `end` er lavere enn i `start` vil vi få et negativt tall, og dermed bevege oss \"bakover\" i tid mot løsningen:\n",
    "\n",
    "```python\n",
    "timestamp_diff += (end[3] - start[3]) * HOURS_TO_SECONDS\n",
    "```\n",
    "\n",
    "Vi gjentar samme steget for minutter og sekunder, og finner dermed svaret.\n",
    "\n",
    "Håper denne forklaringen hjelper!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "480\n",
      "553\n"
     ]
    }
   ],
   "source": [
    "from datetime import datetime\n",
    "\n",
    "MINUTES_TO_SECONDS = 60\n",
    "HOURS_TO_SECONDS = 60 * MINUTES_TO_SECONDS\n",
    "DAYS_TO_SECONDS = 24 * HOURS_TO_SECONDS\n",
    "\n",
    "\n",
    "# Utdelt funksjon. Denne kan du bruke til å løse oppgave 3b.\n",
    "def diff_date(d1, d2):\n",
    "    d1 = datetime(d1[0], d1[1], d1[2])\n",
    "    d2 = datetime(d2[0], d2[1], d2[2])\n",
    "    return (d2 - d1).days\n",
    "\n",
    "def time_diff(start, end):\n",
    "    start_date = start[:3]\n",
    "    end_date = end[:3]\n",
    "\n",
    "    timestamp_diff = diff_date(start_date, end_date) * DAYS_TO_SECONDS\n",
    "    timestamp_diff += (end[3] - start[3]) * HOURS_TO_SECONDS\n",
    "    timestamp_diff += (end[4] - start[4]) * MINUTES_TO_SECONDS\n",
    "    timestamp_diff += end[5] - start[5]\n",
    "    return timestamp_diff\n",
    "\n",
    "\n",
    "# Din kode her\n",
    "print(time_diff([2017, 11, 17, 6, 24, 40], [2017, 11, 17, 6, 32, 40]))\n",
    "print(time_diff([2017,11,17,23,59,59],[2017,11,18,0,9,12]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "480\n",
      "553\n"
     ]
    }
   ],
   "source": [
    "# test koden din her\n",
    "diff = time_diff([2017, 11, 17, 6, 24, 40], [2017, 11, 17, 6, 32, 40])\n",
    "print(diff)  # 480\n",
    "\n",
    "diff = time_diff([2017, 11, 17, 23, 59, 59], [2017, 11, 18, 0, 9, 12])\n",
    "print(diff)  # 553"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Oppgave 3c)\n",
    "\n",
    "Skriv funksjonen ```check_min_distance``` som har parameterne ```car_table``` og ```diff```. Parameteren ```car_table``` er en todimensjonal tabell av passeringer som spesifisert i introduksjonen, mens ```diff``` er avstand som kreves mellom biler angitt i sekunder. \n",
    "\n",
    "**Funksjonen skal returnere registreringsnummer på biler som har mindre avstand i sekunder til bilen foran enn ```diff```.**\n",
    "\n",
    "Eksempel på kall av funksjonen ```check_min_distance``` med passeringer fra fotoboks A og for avstand mellom biler på mindre enn 3 sekunder:\n",
    "```\n",
    ">>> car_table=file_to_table('box_a.txt')\n",
    ">>> crazy_drivers=check_min_distance(car_table,3) \n",
    ">>> print(crazy_drivers)\n",
    "['UT29891', 'UT55227']\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "def check_min_distance(car_table, diff):\n",
    "    regnr = []\n",
    "\n",
    "    for i in range(len(car_table) - 1):\n",
    "        prev_car = car_table[i]\n",
    "        next_car = car_table[i + 1]\n",
    "        if time_diff(prev_car[:-1], next_car[:-1]) < diff:\n",
    "            regnr.append(next_car[-1])\n",
    "\n",
    "    return regnr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['UT29891', 'UT55227']\n"
     ]
    }
   ],
   "source": [
    "# test koden din her\n",
    "crazy_drivers = check_min_distance(box_a, 3)\n",
    "print(crazy_drivers)  # ['UT29891',  'UT55227']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Oppgave 3d)\n",
    "\n",
    "Skriv funksjonen ```list_el_cars``` som har en parameter ```car_table``` som er en **todimensjonal tabell av passeringer** slik som spesifisert i introduksjonen. \n",
    "\n",
    "**Funksjonen skal returnere antall el-biler som har passert.**\n",
    "\n",
    "El-biler har registreringsnummer som starter med EK, EL eller EV.\n",
    "\n",
    "Eksempel på kall av funksjonen ```list_el_cars``` med passeringer fra fotoboks A:\n",
    "```\n",
    ">>> el_cars=list_el_cars(car_table)\n",
    ">>> print(el_cars)\n",
    "1\n",
    "```\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Din kode her"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# test koden din her\n",
    "el_cars = list_el_cars(box_a)\n",
    "print(el_cars)  # 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Oppgave 3e)\n",
    "\n",
    "Skriv funksjonen ```generate_license_numbers``` som har en parameter ```amount```. Denne funksjonen skal **returnere ei liste av ```amount``` antall unike vilkårlige registreringsnummer** som kan brukes til testing av systemet. \n",
    "\n",
    "Bokstavene i registreringsnummeret kan være en av følgende: \n",
    "* BS, CV, EL, FY, KU, LE, NB, PC, SY, WC\n",
    "\n",
    "Tallet i registreringsnummeret skal være mellom **10000** og **99999.**\n",
    "\n",
    "Eksempel på kall av funksjonen ```generate_license_numbers```:\n",
    "\n",
    "```\n",
    ">>> cars=generate_license_numbers(10)\n",
    ">>> print(cars)\n",
    "['CV29728', 'KU73709', 'EL87605', 'NB76581', 'KU65980', \n",
    "'WC71086', 'PC48338', 'KU36868', 'NB44194', 'KU10621']\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "\n",
    "LETTERS = [\"BS\", \"CV\", \"EL\", \"FY\", \"KU\", \"LE\", \"NB\", \"PC\", \"SY\", \"WC\"]\n",
    "\n",
    "def generate_license_numbers(amount):\n",
    "    regnr = set()\n",
    "\n",
    "    while len(regnr) < amount:\n",
    "        gen = random.choice(LETTERS) + str(random.randint(10000, 99999))\n",
    "        regnr.add(gen)\n",
    "    \n",
    "    return list(regnr)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['WC55608', 'CV17255', 'SY41304', 'FY48025', 'WC75484', 'WC97942', 'CV87823', 'PC43316', 'FY87112', 'PC27087']\n",
      "[1, 1, 2, 3, 3]\n",
      "[1, 2, 3]\n"
     ]
    }
   ],
   "source": [
    "# test koden din her\n",
    "cars = generate_license_numbers(10)\n",
    "print(cars)\n",
    "\n",
    "my_list = [1, 1, 2, 3, 3]\n",
    "print(my_list)\n",
    "print(list(set(my_list)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Oppgave 3f)\n",
    "\n",
    "Skriv funksjonen ```list_speeders``` som har fire parameterere ```lst_A```, ```lst_B```, ```speed_limit``` og ```distance```. De to første parameterne er tabeller som inneholder passeringer for fotoboks A og B. Parameteren ```speed_limit``` angir fartsgrensen for strekningen oppgitt i km/t, mens parameteren ```distance``` oppgir avstand mellom fotoboksene angitt i km. \n",
    "\n",
    "**Funksjonen skal returnere en liste av registreringsnummer til alle biler som har kjørt over fartsgrensa (```speed_limit```) for angitt strekning (```distance```).** Det vil i praksis si at funksjonen skal liste opp registreringsnummer til alle **biler som har brukt for kort tid mellom fotoboksene**.\n",
    "\n",
    "Eksempel på kall av funksjonen ```list_speeders``` med tabellene som beskrevet i introduksjonen, med fartsgrense 60km/t og distanse på 10km:\n",
    "\n",
    "```\n",
    ">>> speeders = list_speeders('box_a','box_b',60,10) \n",
    ">>> print(speeders)\n",
    "['UT29891', 'EL73840', 'LE68228']\n",
    "```\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Din kode her"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Eksamen høst 2019 (09:00-15:00) Oppgave 3\n",
    "### Oppgave 3b\n",
    "Kvar båt har lagra fisken i ei todimensjonal liste. Det kan vere fint å finne ut kor mykje av ein enkelt fiskeart som er lagra. Her kan vi ta for gitt at lagra fisk for ein gitt fiskar er tilgjengeleg gjennom parameteren `store`, mens fisketypen er ein streng gitt i parameteren `kind`. \n",
    "Viss det ikkje finst noko fisk av denne typen skal funksjonen returnere talet **0**.\n",
    "\n",
    "Skriv funksjonen `fish_amount` som tek parameterane `store` og `kind`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "store = [[\"torsk\", 200], [\"sei\", 100]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Din kode her"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# test koden din her\n",
    "torsk_amount = fish_amount(store, \"torsk\")\n",
    "print(torsk_amount)  # 200\n",
    "flygefisk_amount = fish_amount(store, \"flygefisk\")\n",
    "print(flygefisk_amount)  # 0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Oppgave 3c\n",
    "Lageret skal oppdaterast når det kjem inn meir fisk. Dette vert oppgitt som ei liste med fiskeslag og talet på kilo: `['torsk', 200]`. Lag eit nytt element viss fisketypen ikkje allereie finst i lageret.\n",
    "Skriv funksjonen `add_fish`, som tar `store` og ei liste som inputparameterar og returnerer det oppdaterte lageret."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Din kode her"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# test koden din her\n",
    "print(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": [
    "## Eksamen kont 2020 (TDT4109) Oppgave 2\n",
    "### Oppgave 2.4\n",
    "Lag funksjonen `calculate` som har ingen inn-parametere, men som skal be brukeren om å skrive inn et regnestykke som kun kan inneholde tall, + og -. Funksjonen skal ta hensyn til at man kan skrive desimaltall både med desimalkomma og desimalpunktum. Det må også tas hensyn til at det kan skrives åpenrom (mellomrom) i uttrykket. Løsningen kan ikke benytte seg av den innebygde funksjon eval() eller lignende.\n",
    "Funksjonen skal først spørre brukeren: \"Enter calculation\" - der brukeren skal skrive inn et regnestykke. Funksjonen beregne svaret og skrive ut svaret til konsollet etter teksten: \"Result: \""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "def calculate():\n",
    "    expression = input(\"Enter calculation: \")\n",
    "    expression = expression.replace(\",\", \".\").replace(\" \", \"\")\n",
    "\n",
    "    parts = expression.split(\"+\")\n",
    "    result = 0\n",
    "\n",
    "    for part in parts:\n",
    "        # part = 3 - 2.5 - 2 -> [\"3\", \"2.5\", \"2\"]\n",
    "        # part = 3 -> [\"3\"]\n",
    "        # part = 3 - 2.5\n",
    "        subparts = part.split(\"-\")\n",
    "        result += float(subparts[0])\n",
    "        for subpart in subparts[1:]:\n",
    "            result -= float(subpart)\n",
    "\n",
    "    print(f\"Result: {result}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Result: 2.5\n"
     ]
    }
   ],
   "source": [
    "# test koden din her\n",
    "calculate()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Oppgave 3.2\n",
    "Lag funksjonen `time_to_sec` som tar inn en input-parameter tstring som er en streng med tidsinformasjon spesifisert som \"time:minutt:sekund\" og regner den om til antall sekunder. Det er ikke gitt at alle elementene er med. Funksjonen må håndtere strenger som \"30\",\"20:30\",\"1:20:30\",\"1::30\",\"::45\",\":12:\",\"1::\".\n",
    "Funksjonen behøver ikke ta hensyn til strenger som ikke følger dette formatet. Funksjonen skal returnere antall sekunder strengen representerer som et heltall."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "def parse_int_safely(string):\n",
    "    if string == \"\":\n",
    "        return 0\n",
    "    return int(string)\n",
    "\n",
    "def time_to_sec(tstring):\n",
    "    parts = tstring.split(\":\")\n",
    "    result = parse_int_safely(parts[-1])\n",
    "\n",
    "    if len(parts) >= 2:\n",
    "        result += parse_int_safely(parts[-2]) * MINUTES_TO_SECONDS\n",
    "\n",
    "    if len(parts) == 3:\n",
    "        result += parse_int_safely(parts[-3]) * HOURS_TO_SECONDS\n",
    "    \n",
    "    return result\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n"
     ]
    }
   ],
   "source": [
    "# test koden din her\n",
    "sec = time_to_sec(\"2:03:04\")\n",
    "print(sec)  # 7384"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Eksamen høst 2020 (TDT4109) Oppgave 2\n",
    "### Oppgave 2.1 \n",
    "Lag funksjonen `check_across_div` som har to input-parametere `num1` og `num2`, som begge er heltall. Funksjonen skal sjekke om tverrsummen av num1 er delelig med num2.\n",
    "Tverrsummen av et tall finner man ved at man summerer sifferne i tallet: Tverrsummen av 123 = 1 + 2 + 3 = 6, og tverrsummen av 255 = 2 + 5 + 5 = 12\n",
    "Funksjonen skal returnere `True` hvis tverrsummen av num1 er delelig med num2. Hvis ikke, skal `False` returneres."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "def check_across_div(num1, num2):\n",
    "    tverrsum = 0\n",
    "    for siffer in str(num1):\n",
    "        tverrsum += int(siffer)\n",
    "    \n",
    "    return tverrsum % num2 == 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "# test koden din her\n",
    "print(check_across_div(123, 6))  # True\n",
    "print(check_across_div(10, 10))  # False\n",
    "print(check_across_div(243, 3))  # True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Oppgave 2.2\n",
    "Lag funksjonen `pick_num_string` som har en input-parameter `txt` som er en tekststreng som kan bestå av både bokstaver og tall.\n",
    "Funksjonen skal returnere alle tallene som ble funnet i tekststrengen som en liste i stigende rekkefølge. Lista skal ikke ha duplikater av samme tall hvis man finner tallet flere ganger i txt.\n",
    "Funksjonen kan testes med følgende argument: `txt='948ugj23dsfh34hgf834nsd321395j'`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# test koden din her\n",
    "liste = pick_num_string(\"948ugj23dsfh34hgf834nsd321395j\")\n",
    "print(liste)  # [1, 2, 3, 4, 5, 8, 9]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Eksamen høst 2020 (TDT4109) Oppgave 3\n",
    "### Oppgave 3.1 \n",
    "Vi representerer internt hvert kort **[i en kortstokk]** som et 2-tuppel: `(v,f)`.\n",
    "Her er v et tall fra 2 til 14 (14 er ess), og f er et av tegnene **'s','h','d','c'**,\n",
    "for henholdsvis spar (spades), hjerter (hearts), ruter (diamonds) og kløver (clubs).\n",
    "\n",
    "a) Skriv funksjonen `new_deck` uten input-parametre, som returnerer en liste med alle 52 kort, representert som tupler beskrevet over. Rekkefølgen spiller ingen rolle.\n",
    "\n",
    "b) Skriv funksjonen `shuffle` som tar en input-parameter liste, som er en liste (muterbar sekvens). Den skal returnere en liste med de samme elementene, men i en annen og tilfeldig rekkefølge."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Din kode her"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# test koden din her\n",
    "deck = new_deck()\n",
    "print(deck)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(shuffle(deck))"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.9.7 ('tdt4195')",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.5"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "63b89d9bfc14eb4486c27c9b239bf0a08c4c63a21c176f83036370f0e204c130"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}