uitwerkingen week 7

_toc.yml

@@ -135,6 +135,11 @@ parts:
         sections:
           - file: problems/7_basis
           - file: problems/7_extra
+      - file: course/solutions_7
+        sections:
+          - file: solutions/7a_text_genereren
+          - file: solutions/7_basis
+          - file: solutions/7_extra
 
   - caption: Oefening
     chapters:

course/solutions_7.md

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

solutions/7_basis.ipynb

@@ -0,0 +1,82 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Basis"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## De Rij van Conway of Lees-en-Huiver\n",
+    "In deze opgave ga je de wiskundig interessante [Rij van Conway](https://nl.wikipedia.org/wiki/Rij_van_Conway) (ja, dezelfde Conway!), ook wel bekend onder de Engelse naam Look-and-Say, implementeren."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "```python\n",
+    "def count(n, term):\n",
+    "    \"\"\"\n",
+    "    telt hoevaak de character n voorkomt aan het begin van de string term. \n",
+    "    \"\"\"\n",
+    "    result = 0\n",
+    "    string = str(term)\n",
+    "    char = str(n)\n",
+    "    while result < len(string) and string[result] == char :\n",
+    "        result += 1\n",
+    "    return result\n",
+    "\n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "```python\n",
+    "def next(term):\n",
+    "    \"\"\"\n",
+    "    bepaald de volgende term in de reeks. \n",
+    "    \"\"\"\n",
+    "    string = str(term)\n",
+    "    index = 0\n",
+    "    result = ''\n",
+    "    while len(string) > 0:\n",
+    "        counter = count (string[0], string)\n",
+    "        result = result + str(counter) + string[0]\n",
+    "        string = string[counter:]\n",
+    "\n",
+    "    return int(result)\n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "```python\n",
+    "def read_it(n):\n",
+    "    \"\"\"\n",
+    "    print een reeks van n lang. \n",
+    "    \"\"\"\n",
+    "    term = 1\n",
+    "    for _ in range(0, n):\n",
+    "        print (term)\n",
+    "        term = next(term)\n",
+    "```"
+   ]
+  }
+ ],
+ "metadata": {
+  "language_info": {
+   "name": "python"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

solutions/7_extra.ipynb

@@ -0,0 +1,185 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Extra"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## John Conway's Game of Life"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Game of Life is een *cellulaire automaat* uitgevonden door de in 2020 overleden wiskundige John Conway. Game of Life is niet zozeer een \"spel\" in de traditionele betekenis, maar een proces dat over tijd veranderd aan de hand van een paar simpele regels. Het proces wordt opgezet als een raster cellen, die ieder \"levend\" of \"dood\" kunnen zijn op een gegeven tijdstip. Op elk tijdstip overleven of sterven cellen aan de hand van de volgende regels:\n",
+    "\n",
+    "1. Een cel met minder dan twee levende buren sterft (vanwege isolatie)\n",
+    "2. Een cel met meer dan 3 levende buren sterft (vanwege overbevolking)\n",
+    "3. Een dode cel met precies 3 levende buren komt weer tot leven\n",
+    "4. Alle andere cellen blijven in dezelfde toestand\n",
+    "\n",
+    "Alhoewel deze regels simpel lijken leiden ze tot complexe en interessante patronen. Meer informatie en een aantal interessante patronen kan je vinden op [Conway's Game of Life](https://en.wikipedia.org/wiki/Conway%27s_Game_of_Life).\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "```python\n",
+    "import random\n",
+    "\n",
+    "\n",
+    "def main():\n",
+    "    a = [[0, 0, 0, 0, 0], \n",
+    "        [0, 0, 1, 0, 0], \n",
+    "        [0, 0, 1, 0, 0], \n",
+    "        [0, 0, 1, 0, 0], \n",
+    "        [0, 0, 0, 0, 0]\n",
+    "    ]  # vertical bar\n",
+    "\n",
+    "    print_board(a)\n",
+    "    a2 = next_life_generation(a)\n",
+    "    print_board(a2)\n",
+    "    a3 = next_life_generation(a2)\n",
+    "    print_board(a3)\n",
+    "\n",
+    "\n",
+    "def create_one_row(width):\n",
+    "    \"\"\" returns one row of zeros of width \"width\"...  \n",
+    "         You might use this in your create_board(width, height) function \"\"\"\n",
+    "    row = []\n",
+    "    for col in range(width):\n",
+    "        row += [0]\n",
+    "    return row\n",
+    "\n",
+    "def create_board(width, height):\n",
+    "    \"\"\"Returns a 2D array with \"height\" rows and \"width\" columns.\"\"\"\n",
+    "    a = []\n",
+    "    for row in range(height):\n",
+    "        a += [create_one_row(width)]        # gebruik de bovenstaande functie zodat ... één rij is!!\n",
+    "    return a\n",
+    "\n",
+    "def print_board(a):\n",
+    "    \"\"\"This function prints the 2D list-of-lists a.\"\"\"\n",
+    "    for row in a:               # row is de hele rij\n",
+    "        for col in row:         # col is het individuele element\n",
+    "            print(col, end='')  # druk dat element af\n",
+    "        print()\n",
+    "\n",
+    "def diagonalize(width, height):\n",
+    "    \"\"\"Creates an empty board and then modifies it\n",
+    "       so that it has a diagonal strip of \"on\" cells.\n",
+    "       But do that only in the *interior* of the 2D array.\n",
+    "    \"\"\"\n",
+    "    a = create_board(width, height)\n",
+    "\n",
+    "    for row in range(1, height - 1):\n",
+    "        for col in range(1, width - 1):\n",
+    "            if row == col:\n",
+    "                a[row][col] = 1\n",
+    "            else:\n",
+    "                a[row][col] = 0\n",
+    "\n",
+    "    return a\n",
+    "\n",
+    "def inner_cells(w, h):\n",
+    "    board = create_board(w,h)\n",
+    "    for row in range (1, h -1):\n",
+    "        for col in range(1, w-1):\n",
+    "            board[row][col] = 1\n",
+    "    return board\n",
+    "\n",
+    "def random_cells(w, h):\n",
+    "    board = create_board(w,h)\n",
+    "    for row in range (1, h -1):\n",
+    "        for col in range(1, w-1):\n",
+    "            board[row][col] = random.choice([0,1])\n",
+    "    return board\n",
+    "\n",
+    "def copy(a):\n",
+    "    \"\"\"Returns a DEEP copy of the 2D array a.\"\"\"\n",
+    "    height = len(a)\n",
+    "    width = len(a[0])\n",
+    "    new_a = create_board(width, height)\n",
+    "\n",
+    "    for row in range(1, height - 1):\n",
+    "        for col in range(1, width - 1):\n",
+    "            new_a[row][col] = a[row][col]\n",
+    "            ...\n",
+    "\n",
+    "    return new_a\n",
+    "\n",
+    "def inner_reverse(a):\n",
+    "\n",
+    "    height = len(a)\n",
+    "    width = len(a[0])\n",
+    "    new_a = create_board(width, height)\n",
+    "\n",
+    "    for row in range(1, height - 1):\n",
+    "        for col in range(1, width - 1):\n",
+    "            new_a[row][col] = abs(a[row][col] - 1)\n",
+    "\n",
+    "    return new_a\n",
+    "\n",
+    "def count_neighbours(row, col, a):\n",
+    "    buren = 0\n",
+    "    if a[row-1][col-1] == 1:\n",
+    "        buren += 1\n",
+    "    if a[row-1][col] == 1:\n",
+    "        buren += 1\n",
+    "    if a[row-1][col+1] == 1:\n",
+    "        buren += 1\n",
+    "    if a[row][col-1] == 1:\n",
+    "        buren += 1\n",
+    "    if a[row][col+1] == 1:\n",
+    "        buren += 1\n",
+    "    if a[row+1][col-1] == 1:\n",
+    "        buren += 1\n",
+    "    if a[row+1][col] == 1:\n",
+    "        buren += 1\n",
+    "    if a[row+1][col+1] == 1:\n",
+    "        buren += 1\n",
+    "\n",
+    "    return buren\n",
+    "\n",
+    "\n",
+    "def next_life_generation(a):\n",
+    "\n",
+    "    height = len(a)\n",
+    "    width = len(a[0])\n",
+    "    new_a = copy(a)\n",
+    "\n",
+    "    for row in range(1, height - 1):\n",
+    "        for col in range(1, width - 1):\n",
+    "            buren = count_neighbours(row, col, a)\n",
+    "            if a[row][col] == 1 and buren < 2:\n",
+    "                new_a[row][col] = 0\n",
+    "            elif a[row][col] == 1 and buren >3:\n",
+    "                new_a[row][col] = 0\n",
+    "            elif a[row][col] == 0 and buren == 3:\n",
+    "                new_a[row][col] = 1\n",
+    "            \n",
+    "\n",
+    "    return new_a\n",
+    "\n",
+    "\n",
+    "main()\n",
+    "```"
+   ]
+  }
+ ],
+ "metadata": {
+  "language_info": {
+   "name": "python"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

solutions/7a_text_genereren.ipynb

@@ -0,0 +1,87 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Tekst genereren met Markovprocessen"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Je doel bij deze opgave is om een programma te schrijven dat uit zichzelf \"betekenisvolle\" tekst kan genereren! Je gaat dit doel bereiken door het schrijven van een algoritme dat met behulp van zogeheten Markovprocessen tekst genereert."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "```python\n",
+    "import random\n",
+    "\n",
+    "def main():\n",
+    "    dict = create_dictionary(\"tekst.txt\")\n",
+    "    print(generate_text(dict, 100))\n",
+    "\n",
+    "# functie #1\n",
+    "#\n",
+    "def create_dictionary(filename):\n",
+    "    \"\"\"\n",
+    "    genereert een dictionairy waarin staat welke woorden na elk woord komt. \n",
+    "    \"\"\"\n",
+    "    # bestand lezen\n",
+    "    f = open(filename)\n",
+    "    text = f.read()\n",
+    "    f.close()\n",
+    "\n",
+    "    # woorden tellen\n",
+    "    words = text.split()\n",
+    "    print(\"Er zijn\", len(words), \"woorden\")\n",
+    "\n",
+    "    # het aantal keer dat elk woord voorkomt tellen\n",
+    "    d = {}\n",
+    "    pw = '$'\n",
+    "\n",
+    "    for nw in words:\n",
+    "        if pw not in d:\n",
+    "            d[pw] = [nw]\n",
+    "        else:\n",
+    "            d[pw] += [nw]\n",
+    "        pw = nw\n",
+    "        if pw[-1] in \".?!\":\n",
+    "            pw = '$'\n",
+    "\n",
+    "    # d teruggeven voor andere code\n",
+    "    return d\n",
+    "\n",
+    "\n",
+    "# functie #2\n",
+    "def generate_text(d, n):\n",
+    "    \"\"\"\n",
+    "    genereert text via de markov process. \n",
+    "    \"\"\"\n",
+    "    cw = '$'\n",
+    "    tekst = ''\n",
+    "    for i in range(n):\n",
+    "        nw = random.choice(d[cw])\n",
+    "        tekst += nw + \" \" \n",
+    "        cw = nw\n",
+    "        if cw[-1] in \".?!\":\n",
+    "            cw = '$'\n",
+    "    return tekst\n",
+    "\n",
+    "main()\n",
+    "```"
+   ]
+  }
+ ],
+ "metadata": {
+  "language_info": {
+   "name": "python"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}