Uitwerkingen week 3

_toc.yml

@@ -61,6 +61,11 @@ parts:
           - file: problems/3_opstap
           - file: problems/3_basis
           - file: problems/3_extra
+      - file: course/solutions_3
+        sections:
+          - file: solutions/3_fijne_functies
+          - file: solutions/3_basis
+          - file: solutions/3_extra
 
   - caption: PGM1 Week 4
     chapters:

course/solutions_3.md

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

practicals/3_fijne_functies.ipynb

@@ -54,8 +54,6 @@
     "\n",
     "Functies zijn de fundamentele bouwstenen van programmeren. Wat Python onderscheidt van andere programmeertalen is het gemak waarmee je eigen functies kan maken!\n",
     "\n",
-    "Kopieer het volgende commentaar en de definitie van een functie met de naam `dbl` naar jouw bestand:\n",
-    "\n",
     "```python\n",
     "def dbl(x):\n",
     "    \"\"\"Returns twice the argument\n",

problems/3_extra.ipynb

@@ -44,7 +44,7 @@
     "tags": []
    },
    "source": [
-    "Schrijf de functie `trap(x)` die een getal accepteert en een omgekeerde # trap tekent (print). Maak gebruik van recursie."
+    "Schrijf de functie `trap(x)` die een getal accepteert en een omgekeerde # trap tekent (print). Maak gebruik van recursie en niet van lussen."
    ]
   },
   {

solutions/3_basis.ipynb

@@ -0,0 +1,192 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Basis"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Opdracht 1\n",
+    "Schrijf de functie `tpl(x)` die een getal als argument accepteert en drie keer de waarde van dat argument teruggeeft."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def tpl(x):\n",
+    "    \"\"\"Geeft driemaal het argument terug\n",
+    "\n",
+    "    :param x: De waarde om te verdrievoudigen\n",
+    "    :type x: int, float of string\n",
+    "    :rtype: int, float of string\n",
+    "    \"\"\"\n",
+    "    return 3 * x"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We hebben besloten de *docstring* van meer informatie te voorzien voor nog meer duidelijkheid.\n",
+    "\n",
+    "Aangezien het een simpele taak is die de functie moet doen, kan de berekening gelijk in de return gezet worden."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Opdracht 2a\n",
+    "Schrijf de functie `min_two(a, b)` die twee getallen als argument accepteert en de kleinste waarde teruggeeft."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def min_two(a, b):\n",
+    "    \"\"\" Geeft de laagste van de twee parameters terug\n",
+    "\n",
+    "    :param a, b: de twee waarden waarvan de laagste terug moet worden gegeven\n",
+    "    :type a, b: int\n",
+    "    :rtype: int\n",
+    "    \"\"\"\n",
+    "    if a < b:\n",
+    "        return a\n",
+    "    elif b < a:\n",
+    "        return b\n",
+    "    else:\n",
+    "        return \"Beide getallen zijn even groot!\""
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "In de opdracht werd niet gezegd dat we er van uit mogen gaan dat de twee getallen niet hetzelfde kunnen zijn.\n",
+    "\n",
+    "Daarom controleert de functie zowel of a kleiner is en of b kleiner is.\n",
+    "Als geen van beide kleiner zijn dan zullen de argumenten even groot zijn.\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Opdracht 2b\n",
+    "Schrijf de functie `min_three(a, b, c)` die drie getallen als argument accepteert en de kleinste waarde teruggeeft."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def min_three(a, b, c):\n",
+    "    \"\"\" Geeft de laagste van de drie parameters terug\n",
+    "\n",
+    "    :param a, b, c: de twee waarden waarvan de laagste terug moet worden gegeven\n",
+    "    :type a, b, c: int\n",
+    "    :rtype: int\n",
+    "    \"\"\"\n",
+    "    if a < b and a < c:\n",
+    "        return a\n",
+    "    elif b < a and b < c:\n",
+    "        return b\n",
+    "    elif c < a and c < b:\n",
+    "        return c\n",
+    "    else:\n",
+    "        return \"Er zijn getallen die even groot zijn!\""
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "In de opdracht werd niet gezegd dat we er van uit mogen gaan dat de twee getallen niet hetzelfde kunnen zijn.\n",
+    "\n",
+    "Daarom controleert de functie zowel of elke variable kleiner is dan de andere twee met de 'and' in de if statements.\n",
+    "\n",
+    "Als geen van de drie argumenten kleiner zijn dan de andere dan zullen er twee hetzelfde zijn of alle zelfs alle drie."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Opdracht 3\n",
+    "Schrijf de functie absolute(x,y) dat twee getallen accepteert en de afstand berekent tussen de twee getallen."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def absolute(x, y):\n",
+    "    \"\"\" Geeft de afstand tussen de twee parameters terug\n",
+    "\n",
+    "    :param x, y: de twee waarden waarvan de afstand terug moet worden gegeven\n",
+    "    :type a, b, c: int\n",
+    "    :rtype: int\n",
+    "    \"\"\"\n",
+    "    if x >= 0 and y >= 0:\n",
+    "        if x > y:\n",
+    "            # Bij twee positieve getallen dan krijg je de afstand\n",
+    "            # door het kleinste getal van de grote te trekken.\n",
+    "            return x - y\n",
+    "        else: # y is groter\n",
+    "            return y - x\n",
+    "    elif x < 0 and y >= 0:\n",
+    "        # y is groter dan de negatieve x.\n",
+    "        # Omdat x negatief is, is de afstand y plus de positieve versie van x.\n",
+    "        return y + (x * -1)\n",
+    "    elif x >= 0 and y < 0:\n",
+    "        # Nu is y negatief\n",
+    "        return x + (y * -1)\n",
+    "    else:\n",
+    "        # Beide getallen zijn negatief.\n",
+    "        # Vindt het kleinste getal.\n",
+    "        if x < y:\n",
+    "            # De afstand is altijd positief.\n",
+    "            # We corrigeren door het kleinste getal positief te maken\n",
+    "            # en het kleinste getal negatief te houden.\n",
+    "            return (x * -1) + y # Plus een negatief getal wordt een aftrek som\n",
+    "        else:\n",
+    "            return (y * -1) + x"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Als beide getallen positief zijn dan hoeft alleen de laagste van de hoogste af getrokken te worden.\n",
+    "\n",
+    "Als een van beide getallen negatief is dan is het andere getal automatisch het grotere getal. Om dan de juiste waarde te krijgen moet de positieve versie van het negatieve getal opgeteld worden bij het al positieve getal.\n",
+    "\n",
+    "Als beide getallen negatief zijn dan kunnen we de positieve versie van het kleinste getal nemen en het andere getal daarvan aftrekken.\n",
+    "\n",
+    "We maken hiervoor gebruik van het feit dat in Python wanneer je een negatief getal ergens bij optelt het een aftrek operatie wordt."
+   ]
+  }
+ ],
+ "metadata": {
+  "language_info": {
+   "name": "python"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

solutions/3_extra.ipynb

@@ -0,0 +1,142 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Extra"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Opdracht 1\n",
+    "Schrijf de functie `trap(x)` die een getal accepteert en een omgekeerde `#` trap tekent. Maak gebruik van recursie."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def trap(x):\n",
+    "    \"\"\" Print een onderste boven trap naar het scherm\n",
+    "\n",
+    "    :param x: het aantal traptreden\n",
+    "    :type x: int\n",
+    "    :rtype: geen return waarde\n",
+    "    \"\"\"\n",
+    "    if x > 0:\n",
+    "        print(x * \"#\")\n",
+    "        trap(x - 1)\n",
+    "    else:\n",
+    "        return"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Aangezien de bovenste tree de breedste is, kan het programma beginnen bij `x` en vanaf daar aftellen naar 0.\n",
+    "\n",
+    "Is `x` groter dan nul ( `x > 0` ) dan zijn er nog treden om te plaatsen. Plaats de trede, corrigeer x voor de geplaatste trede en roep de functie nog een keer aan.\n",
+    "\n",
+    "Is `x` gelijk aan nul ( `x == 0` ) dan zijn er geen treden meer om te plaatsen en kan de functie stoppen."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Opdracht 2a\n",
+    "Schrijf de functie `lines(x, space)` die twee `#`-lijnen tekent van `x` regels hoog en `space` geeft aan hoeveel spaties tussen de lijnen liggen.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def lines(x, space):\n",
+    "    \"\"\" Tekent twee lijnen met # voor <x> aantal regels met <space>\n",
+    "    aantal spaties tussen de twee lijnen\n",
+    "\n",
+    "    :param x: geeft aan hoeveel regels\n",
+    "    :param space: geeft aantal spaties tussen de twee lijnen\n",
+    "    :type x, space: int\n",
+    "    :rtype: geen return waarde\n",
+    "    \"\"\"\n",
+    "    if x > 0:\n",
+    "        print(\"#\" + space*\" \" + \"#\")\n",
+    "        lines(x - 1, space)\n",
+    "    else:\n",
+    "        return"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Hier geldt hetzelfde als voor de onderste boven trap.\n",
+    "\n",
+    "Zodra `x` gelijk is aan nul mag het programma stoppen, alle regels zijn naar het scherm geprint.\n",
+    "\n",
+    "Als `x` nog geen nul is dan moet er nog een regel naar het scherm geprint worden.\n",
+    "\n",
+    "```{note}\n",
+    "We veranderen hier alleen `x` en niet `space`, want de afstand tussen de lijnen is niet afhankelijk van hoeveel regels er al geprint zijn.\n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Opdracht 2b\n",
+    "Schrijf een functie `print_square(x)` die een getal accepteert en een `#` vierkant van grootte `x` print. Maak gebruik van de functie `lines`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def print_square(x):\n",
+    "    \"\"\" Tekent een vierkant van # met grootte x\n",
+    "\n",
+    "    :param x: geeft aan hoe groot het vierkant moet zijn\n",
+    "    :type x: int\n",
+    "    :rtype: geen return waarde\n",
+    "    \"\"\"\n",
+    "    print(x * \"#\")\n",
+    "    lines(x - 2, x - 2)\n",
+    "    print(x * \"#\")\n",
+    "    return"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Het verschil tussen `lines()` en `print_square()` is dat `print_square()` begint en eindigt met een volle regel met `x * \"#\"`.\n",
+    "\n",
+    "Deze kunnen direct naar het scherm geprint worden. Dit betekent dat `lines()` alleen de regels tussen de eerste en de twee hoeft te vullen.\n",
+    "\n",
+    "We gebruiken `x - 2` voor de `x` van lines omdat er al twee regels geprint worden door `print_square()` zelf.\n",
+    "\n",
+    "We gebruiken `x - 2` voor space omdat er voor en na de space een `#` geprint wordt. Als we hier geen rekening mee houden dan worden de `lines()` regels te breed."
+   ]
+  }
+ ],
+ "metadata": {
+  "language_info": {
+   "name": "python"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}