Adds notebook for basic algorithms

_doc/api/index.rst

@@ -4,3 +4,4 @@ Code inclus dans cette librairie
 .. toctree::
 
     classique
+    tools

_doc/api/tools.rst

@@ -0,0 +1,6 @@
+tools
+=====
+
+.. autofunction:: teachpyx.tools.draw_diagram
+
+.. autofunction:: teachpyx.tools.total_size

_doc/conf.py

@@ -170,6 +170,8 @@
 """
 
 epkg_dictionary = {
+    "Algorithme de Strassen": "https://fr.wikipedia.org/wiki/Algorithme_de_Strassen",
+    "algorithme de Strassen": "https://fr.wikipedia.org/wiki/Algorithme_de_Strassen",
     "ACP": "https://fr.wikipedia.org/wiki/Analyse_en_composantes_principales",
     "AESA": "https://tavianator.com/aesa/",
     "algorithme": "https://fr.wikipedia.org/wiki/Algorithme",
@@ -182,6 +184,7 @@
     "Awesome Python": "https://awesome-python.com/",
     "B+ tree": "https://en.wikipedia.org/wiki/B%2B_tree",
     "BLAS": "https://www.netlib.org/blas/",
+    "blockdiag": "https://github.com/blockdiag/blockdiag",
     "Branch and Bound": "https://en.wikipedia.org/wiki/Branch_and_bound",
     "bytearray": "https://docs.python.org/3/library/functions.html#bytearray",
     "C++": "https://fr.wikipedia.org/wiki/C%2B%2B",

_doc/practice/algo-base/exercice_echelle.ipynb

@@ -0,0 +1,294 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Calculer le nombre de façons de monter une échelle.\n",
+    "\n",
+    "Une grenouille monte une échelle. Elle peut faire des bonds de un ou deux barreaux. Combien a-t-elle de façons de monter une échelle de treize barreaux ? Notion abordée : fonction récursive."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Enoncés"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Enoncé 1\n",
+    "\n",
+    "On suppose qu'une grenouille peut montrer une échelle de 13 barreaux avec des sauts de 1 ou 2 barreaux. Combien a-t-elle de façons de monter les 13 premiers barreaux ?"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Enoncé 2\n",
+    "\n",
+    "Le problème est presque le même excepté que l'épaisseur des barreaux est plus ou moins grande. L'épaisseur du barreau $i$ est un entier $e_i > 0$. Arrivée au barreau $i$, la grenouille peut faire un bond de $k$ barreaux avec $k \\leqslant e_i$. La grenouille commence toujours au barreau."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Enoncé 3\n",
+    "\n",
+    "On considère la grenouille de l'énoncé 2 mais on souhaite connaître le chemin pour lequel la grenouille a fait le moins de bonds possible."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Solutions"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Solution au problème 1\n",
+    "\n",
+    "L'idée de départ consiste à considérer le problème par récurrence. D'où la grenouille peut-elle venir si elle est au barreau $n$ ? La réponse est assez simple :\n",
+    "- elle a pu venir du barreau $n-1$ avec un saut de un barreau,\n",
+    "- elle a pu venir du barreau $n-2$ avec un saut de deux barreaux\n",
+    "\n",
+    "On obtient la formule de récurrence suivante : $f(n) = f(n-1) + f(n-2)$. C'est une [suite de Fibonacci](http://fr.wikipedia.org/wiki/Suite_de_Fibonacci)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "barreau 0 : 1 façons de monter\n",
+      "barreau 1 : 1 façons de monter\n",
+      "barreau 2 : 2 façons de monter\n",
+      "barreau 3 : 3 façons de monter\n",
+      "barreau 4 : 5 façons de monter\n",
+      "barreau 5 : 8 façons de monter\n",
+      "barreau 6 : 13 façons de monter\n",
+      "barreau 7 : 21 façons de monter\n",
+      "barreau 8 : 34 façons de monter\n",
+      "barreau 9 : 55 façons de monter\n",
+      "barreau 10 : 89 façons de monter\n",
+      "barreau 11 : 144 façons de monter\n",
+      "barreau 12 : 233 façons de monter\n",
+      "barreau 13 : 377 façons de monter\n"
+     ]
+    }
+   ],
+   "source": [
+    "def grenouille(n):\n",
+    "    a = 1  # 1 façon d'arriver au barreau 0\n",
+    "    b = 1  # 1 façon d'arriver au barreau 1\n",
+    "    i = 1\n",
+    "    while i < n:\n",
+    "        a, b = b, a + b\n",
+    "        i += 1\n",
+    "    return b\n",
+    "\n",
+    "\n",
+    "for i in range(0, 14):\n",
+    "    print(\"barreau {0} : {1} façons de monter\".format(i, grenouille(i)))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Solution au problème 2\n",
+    "\n",
+    "La solution au second problème est presque la même. L'idée de départ consiste toujours à considérer le problème par récurrence. D'où la grenouille peut-elle venir si elle est au barreau $n$ ? La réponse est assez simple :\n",
+    "- elle a pu venir du barreau $n-1$ avec un saut de un barreau si $e_{n-1} \\geqslant 1$\n",
+    "- elle a pu venir du barreau $n-2$ avec un saut de deux barreaux si $e_{n-2} \\geqslant 2$\n",
+    "- elle a pu venir du barreau $n-k$ avec un saut de deux barreaux si $e_{n-k} \\geqslant k$"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "barreau 0 : 1 = 1 façons de monter\n",
+      "barreau 1 : 1 = 1 façons de monter\n",
+      "barreau 2 : 2 = 1 façons de monter\n",
+      "barreau 3 : 3 = 2 façons de monter\n",
+      "barreau 4 : 5 = 3 façons de monter\n",
+      "barreau 5 : 8 = 5 façons de monter\n",
+      "barreau 6 : 13 = 8 façons de monter\n",
+      "barreau 7 : 21 = 13 façons de monter\n",
+      "barreau 8 : 34 = 21 façons de monter\n",
+      "barreau 9 : 55 = 34 façons de monter\n",
+      "barreau 10 : 89 = 55 façons de monter\n",
+      "barreau 11 : 144 = 89 façons de monter\n",
+      "barreau 12 : 233 = 144 façons de monter\n",
+      "barreau 13 : 377 = 233 façons de monter\n"
+     ]
+    }
+   ],
+   "source": [
+    "def grenouille2(n, barreaux):\n",
+    "    nb = [1, 1]  # 1 façon d'arriver au barreau 0 ou 1\n",
+    "    while len(nb) < n:\n",
+    "        s = 0\n",
+    "        i = len(nb)\n",
+    "        for k in range(0, i):\n",
+    "            if barreaux[i - k - 1] >= k + 1:\n",
+    "                s += nb[i - k - 1]\n",
+    "        nb.append(s)\n",
+    "        i += 1\n",
+    "    return nb[-1]\n",
+    "\n",
+    "\n",
+    "# on regarde si on obtient le même résultat que précédemment\n",
+    "g1 = [2 for i in range(0, 14)]\n",
+    "for i in range(0, 14):\n",
+    "    print(\n",
+    "        \"barreau {0} : {1} = {2} façons de monter\".format(\n",
+    "            i, grenouille(i), grenouille2(i, g1)\n",
+    "        )\n",
+    "    )"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "La solution est légèrement différente car contrairement au premier énoncé, la grenouille ne peut aller directement au barreau 2. On essaye avec un autre example trivial mais qui permet de s'assurer que la fonction retourne bien le résultat voulu."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "barreau 0 : 1 façons de monter\n",
+      "barreau 1 : 1 façons de monter\n",
+      "barreau 2 : 1 façons de monter\n",
+      "barreau 3 : 1 façons de monter\n",
+      "barreau 4 : 1 façons de monter\n",
+      "barreau 5 : 1 façons de monter\n",
+      "barreau 6 : 1 façons de monter\n",
+      "barreau 7 : 2 façons de monter\n",
+      "barreau 8 : 3 façons de monter\n",
+      "barreau 9 : 3 façons de monter\n",
+      "barreau 10 : 3 façons de monter\n",
+      "barreau 11 : 3 façons de monter\n",
+      "barreau 12 : 3 façons de monter\n",
+      "barreau 13 : 3 façons de monter\n"
+     ]
+    }
+   ],
+   "source": [
+    "g2 = [1 for i in range(0, 14)]\n",
+    "g2[4] = 3\n",
+    "for i in range(0, 14):\n",
+    "    print(\"barreau {0} : {1} façons de monter\".format(i, grenouille2(i, g2)))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Solution au problème 3\n",
+    "\n",
+    "Pour ce problème, la solution est quasi identique excepté qu'au lieu de sommer les nombres de chemins, on souhaite garder le nombre de bonds du chemin qui en contient le moins."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "barreau 0 : 1 bonds pour le chemin qui en contient le moins\n",
+      "barreau 1 : 1 bonds pour le chemin qui en contient le moins\n",
+      "barreau 2 : 1 bonds pour le chemin qui en contient le moins\n",
+      "barreau 3 : 2 bonds pour le chemin qui en contient le moins\n",
+      "barreau 4 : 2 bonds pour le chemin qui en contient le moins\n",
+      "barreau 5 : 3 bonds pour le chemin qui en contient le moins\n",
+      "barreau 6 : 3 bonds pour le chemin qui en contient le moins\n",
+      "barreau 7 : 4 bonds pour le chemin qui en contient le moins\n",
+      "barreau 8 : 4 bonds pour le chemin qui en contient le moins\n",
+      "barreau 9 : 5 bonds pour le chemin qui en contient le moins\n",
+      "barreau 10 : 5 bonds pour le chemin qui en contient le moins\n",
+      "barreau 11 : 6 bonds pour le chemin qui en contient le moins\n",
+      "barreau 12 : 6 bonds pour le chemin qui en contient le moins\n",
+      "barreau 13 : 7 bonds pour le chemin qui en contient le moins\n"
+     ]
+    }
+   ],
+   "source": [
+    "def grenouille3(n, barreaux):\n",
+    "    nb = [1, 1]  # 1 façon d'arriver au barreau 0 ou 1\n",
+    "    while len(nb) < n:\n",
+    "        s = 0\n",
+    "        i = len(nb)\n",
+    "        for k in range(0, i):\n",
+    "            if barreaux[i - k - 1] >= k + 1 and (s == 0 or nb[i - k - 1] < s):\n",
+    "                # on prend le miminum\n",
+    "                s = nb[i - k - 1]\n",
+    "        nb.append(s + 1)\n",
+    "        i += 1\n",
+    "    return nb[-1]\n",
+    "\n",
+    "\n",
+    "g1 = [2 for i in range(0, 14)]\n",
+    "for i in range(0, 14):\n",
+    "    print(\n",
+    "        \"barreau {0} : {1} bonds pour le chemin qui en contient le moins\".format(\n",
+    "            i, grenouille3(i, g1)\n",
+    "        )\n",
+    "    )"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Si on veut conserver le chemin précis qui contient le moins de bonds possibles, il suffit de mémoriser le barreau précédent $i$ que la grenouille a emprunté pour aller en un minimum de bonds au barreau $n$ : on conserve en mémoire le **prédécesseur**. Pour construire le meilleur chemin, on remonte de prédécesseur en prédécesseur."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 1
+}