Week 4 uitwerkingen

#55 uitwerkingen

_toc.yml

@@ -81,6 +81,11 @@ parts:
           - file: problems/4_opstap
           - file: problems/4_basis
           - file: problems/4_extra
+      - file: course/solutions_4
+        sections:
+          - file: solutions/4_python_bat
+          - file: solutions/4_basis
+          - file: solutions/4_extra
 
   - caption: PGM1 Week 5
     chapters:

course/solutions_4.md

@@ -0,0 +1,5 @@
+# Uitwerkingen
+
+
+```{tableofcontents}
+```

solutions/4_basis.ipynb

@@ -0,0 +1,166 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Basis"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Opdracht 1b\n",
+    "b. Maak nu een nieuwe functie `power(b, p)` door de bovenstaande functie te kopiëren en aan te passen, of door de functie zelf te schrijven op dezelfde manier. Deze functie moet aan de volgende eisen voldoen:\n",
+    "\n",
+    "-   Accepteert een numerieke waarde `b` (base, grondtal)\n",
+    "-   Accepteert een niet-negatieve integer `p` (power, macht) (`p` kan 0 zijn)\n",
+    "-   Geeft de waarde van `b ** p` terug\n",
+    "-   De functie moet een `for`-lus gebruiken! Je mag niet gewoon `b ** p` gebruiken...\n",
+    "-   In dit geval doen we alsof `power(0, 0)` gelijk is aan `1.0`, ook als dat wiskundig niet helemaal juist is."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "power(2, 5): is 32 == 32\n",
+      "power(5, 2): is 25 == 25\n",
+      "power(42, 0): is 1 == 1\n",
+      "power(0, 42): is 0 == 0\n",
+      "power(0, 0): is 1 == 1\n"
+     ]
+    }
+   ],
+   "source": [
+    "def power(b,p):\n",
+    "    result = 1\n",
+    "    for x in range(0,p):\n",
+    "        result = result * b\n",
+    "    return result\n",
+    "\n",
+    "print(\"power(2, 5): is 32 ==\", power(2, 5))\n",
+    "print(\"power(5, 2): is 25 ==\", power(5, 2))\n",
+    "print(\"power(42, 0): is 1 ==\", power(42, 0))\n",
+    "print(\"power(0, 42): is 0 ==\", power(0, 42))\n",
+    "print(\"power(0, 0): is 1 ==\", power(0, 0))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Opdracht 2b\n",
+    "b. Maak nu zelf een functie `summed_odds(L)` door deze functie als voorbeeld te gebruiken, die\n",
+    "\n",
+    "-   Een lijst integers `L` accepteert.\n",
+    "-   Je mag ervan uitgaan dat de lijst alleen integers bevat.\n",
+    "-   De functie moet de som teruggeven van alle **oneven** getallen in `L`.\n",
+    "-   Als er geen oneven getallen in de lijst zijn, moet de functie 0 teruggeven.\n",
+    "-   Maak gebruik van een lus!"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def summed_odds(l):\n",
+    "    result = 0\n",
+    "    for x in l:\n",
+    "        if x % 2 == 1:\n",
+    "            result = result + x\n",
+    "    return result\n",
+    "\n",
+    "assert summed_odds([4, 5, 6]) == 5\n",
+    "assert summed_odds(range(3, 10)) == 24"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Opdracht 3b\n",
+    "b. Gebruik `count_guesses` als voorbeeld om een variant te schrijven die we `until_a_repeat(high)` gaan noemen.\n",
+    "\n",
+    "-   Deze functie houdt een lijst `L` bij van alle getallen die geraden zijn. Begin met `L = []`!\n",
+    "-   We blijven getallen raden zolang alle elementen van `L` uniek zijn (dus zolang er geen herhalingen zijn).\n",
+    "    -   Gebruik een `while`-lus!\n",
+    "    -   Gebruik de functie `unique(L)` hieronder die een boolean teruggeeft.\n",
+    "-   Binnen de `while`-lus doet de funtie het volgende:\n",
+    "    -   Gok een getal van 0 tot high met behulp van `range(0, high)`\n",
+    "    -   Houd het aantal geraden getallen bij (bijvoorbeeld met een telvariabele)\n",
+    "    -   Voeg het getal toe aan de lijst `L`\n",
+    "-   Als de `while`-lus klaar is moet de functie het aantal geraden getallen teruggeven dat nodig was om een dubbel getal te krijgen."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "6\n"
+     ]
+    }
+   ],
+   "source": [
+    "import random\n",
+    "\n",
+    "def unique(L):\n",
+    "    \"\"\"Returns whether all elements in L are unique.\n",
+    "\n",
+    "    Argument: L, a list of any elements.\n",
+    "    Return value: True, if all elements in L are unique,\n",
+    "            or False, if there is any repeated element\n",
+    "    \"\"\"\n",
+    "    if len(L) == 0:\n",
+    "        return True\n",
+    "    elif L[0] in L[1:]:\n",
+    "        return False\n",
+    "    else:\n",
+    "        return unique(L[1:])  # in deze functie mag je WEL recursie gebruiken!\n",
+    "\n",
+    "def until_a_repeat(high):\n",
+    "    result = []\n",
+    "    while unique(result):\n",
+    "        ran = random.choice(range(0,high))\n",
+    "        result = result + [ran]\n",
+    "    return len(result)\n",
+    "\n",
+    "print(until_a_repeat(365))"
+   ]
+  }
+ ],
+ "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.11.2"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

solutions/4_extra.ipynb

@@ -0,0 +1,129 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Extra"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Pi met Pijltjes\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Het is misschien verbazingwekkend dat het mogelijk is om de wiskundige constante π te berekenen zonder dat je andere operaties nodig hebt dan tellen, optellen en vermenigvuldigen. In deze opgave ga je twee functies schrijven om pi (3.14159...) te benaderen door het gooien van pijltjes."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "```python\n",
+    "import random\n",
+    "import math\n",
+    "\n",
+    "def throw_dart():\n",
+    "    \"\"\" Deze functie maakt gebruik van de random library om een\n",
+    "    willekeurige x- en een willekeurige y-coördinaat te genereren\n",
+    "    tussen -1 en 1. Als de pijl de cirkel raakt geeft de functie\n",
+    "    True terug anders False.\n",
+    "    \"\"\"\n",
+    "\n",
+    "    x = random.uniform(-1.0,1.0)\n",
+    "    y = random.uniform(-1.0,1.0)\n",
+    "\n",
+    "    distance = math.sqrt((x * x) + (y * y))\n",
+    "    if distance <= 1.0: # Raakt de cirkel\n",
+    "        return True\n",
+    "\n",
+    "    return False\n",
+    "def for_pi(n):\n",
+    "    \"\"\" Deze functie gooit n pijltjes om de constante pi te benaderen.\n",
+    "    De geschatte waarde pi wordt door de functie terug gegeven.\n",
+    "    \"\"\"\n",
+    "\n",
+    "    timesHit = 0.0\n",
+    "\n",
+    "    for dart in range(1, n+1): # Corrigeer voor range beginnen bij 0\n",
+    "        hit = throw_dart()\n",
+    "        if hit:\n",
+    "            timesHit += 1.0\n",
+    "\n",
+    "        print(str(timesHit) + \" raak van de \" + str(dart) + \" worpen dus pi is \" + str((4.0*timesHit)/dart))\n",
+    "\n",
+    "    return ((4.0*timesHit)/n)\n",
+    "\n",
+    "# print(\"Laatste schattig for pi is \" + str(for_pi(500)))\n",
+    "# Mocht je tijd hebben en een pc die dit wel aan kan:\n",
+    "# print(\"Laatste schatting for pi is \" + str(for_pi(5000000)))\n",
+    "\n",
+    "def find_number_of_decimals(x):\n",
+    "    \"\"\" Geeft het aantal cijfers achter de komma voor float x (gegeven als string!) als integer terug.\n",
+    "    \"\"\"\n",
+    "    if len(x) == 0:\n",
+    "        return 0\n",
+    "    if x[-1] == '.':\n",
+    "        return 0\n",
+    "    else:\n",
+    "        return 1 + find_number_of_decimals(x[0:-1])\n",
+    "\n",
+    "assert find_number_of_decimals(str(3.12345)) == 5\n",
+    "assert find_number_of_decimals(str(456.98756429)) == 8\n",
+    "assert find_number_of_decimals(str(0.1)) == 1\n",
+    "\n",
+    "def while_pi(accuracy):\n",
+    "    \"\"\" Geeft het aantal pijltjes terug dat nodig was om nauwkeurigheid\n",
+    "    x te halen.\n",
+    "    \"\"\"\n",
+    "    # Omdat de schatting van pi veel meer decimalen geeft dan de mee gegeven nauwkeurigheid\n",
+    "    # en dit problemen geeft met een is gelijk aan statement, zullen we gebruik maken van de\n",
+    "    # round functie. Hiervoor houden we het aantal decimalen aan van de mee gegeven variable en\n",
+    "    # gebruiken we een hulp functie.\n",
+    "    # Maak van de float een een str om gebruik te kunnen maken van string slicing om het aantal decimalen te krijgen\n",
+    "    decimal = find_number_of_decimals(str(accuracy))\n",
+    "    #print(\"Number of decimals: \" + str(decimal))\n",
+    "    timesHit = 0.0\n",
+    "    dart = 0\n",
+    "    correct_accuracy = True\n",
+    "\n",
+    "    while correct_accuracy:\n",
+    "        hit = throw_dart()\n",
+    "        if hit:\n",
+    "            timesHit += 1.0\n",
+    "        dart += 1 # We hebben nu de eerste pijl gegooit\n",
+    "        guess_pi = (4.0*timesHit)/dart\n",
+    "\n",
+    "        # Beperk aantal prints bij meer decimalen voor leesbaarheid output\n",
+    "        if decimal <= 2:\n",
+    "            # print(\"(Hit? \" + str(hit) + \")\\t\" + str(timesHit) + \" raak van de \" + str(dart) + \" worpen dus pi is \" + str(guess_pi))\n",
+    "            print(str(timesHit) + \" raak van de \" + str(dart) + \" worpen dus pi is \" + str(guess_pi))\n",
+    "        else:\n",
+    "            if dart % 100 == 0:\n",
+    "                print(str(timesHit) + \" raak van de \" + str(dart) + \" worpen dus pi is \" + str(guess_pi))\n",
+    "\n",
+    "        if round(guess_pi, decimal) == round(3.0 + accuracy, decimal):\n",
+    "            correct_accuracy = False\n",
+    "\n",
+    "    if decimal > 2:\n",
+    "        print(str(timesHit) + \" raak van de \" + str(dart) + \" worpen dus pi is \" + str(guess_pi))\n",
+    "    return dart\n",
+    "\n",
+    "```"
+   ]
+  }
+ ],
+ "metadata": {
+  "language_info": {
+   "name": "python"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}