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