agreg/TP_Programmation_2017-18/TP1__Python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "toc": "true"
   },
   "source": [
    "<h1>Table of Contents<span class=\"tocSkip\"></span></h1>\n",
    "<div class=\"toc\"><ul class=\"toc-item\"><li><span><a href=\"#TP-1---Programmation-pour-la-préparation-à-l'agrégation-maths-option-info\" data-toc-modified-id=\"TP-1---Programmation-pour-la-préparation-à-l'agrégation-maths-option-info-1\"><span class=\"toc-item-num\">1&nbsp;&nbsp;</span>TP 1 - Programmation pour la préparation à l'agrégation maths option info</a></span><ul class=\"toc-item\"><li><span><a href=\"#Remarques-sur-le-style\" data-toc-modified-id=\"Remarques-sur-le-style-1.1\"><span class=\"toc-item-num\">1.1&nbsp;&nbsp;</span>Remarques sur le style</a></span></li></ul></li><li><span><a href=\"#Fonctions\" data-toc-modified-id=\"Fonctions-2\"><span class=\"toc-item-num\">2&nbsp;&nbsp;</span>Fonctions</a></span><ul class=\"toc-item\"><li><span><a href=\"#Exercice-4\" data-toc-modified-id=\"Exercice-4-2.1\"><span class=\"toc-item-num\">2.1&nbsp;&nbsp;</span>Exercice 4</a></span></li><li><span><a href=\"#Exercice-5\" data-toc-modified-id=\"Exercice-5-2.2\"><span class=\"toc-item-num\">2.2&nbsp;&nbsp;</span>Exercice 5</a></span></li><li><span><a href=\"#Exercice-6\" data-toc-modified-id=\"Exercice-6-2.3\"><span class=\"toc-item-num\">2.3&nbsp;&nbsp;</span>Exercice 6</a></span></li></ul></li><li><span><a href=\"#Récursivité\" data-toc-modified-id=\"Récursivité-3\"><span class=\"toc-item-num\">3&nbsp;&nbsp;</span>Récursivité</a></span><ul class=\"toc-item\"><li><span><a href=\"#Exercice-7\" data-toc-modified-id=\"Exercice-7-3.1\"><span class=\"toc-item-num\">3.1&nbsp;&nbsp;</span>Exercice 7</a></span></li><li><span><a href=\"#Exercice-8\" data-toc-modified-id=\"Exercice-8-3.2\"><span class=\"toc-item-num\">3.2&nbsp;&nbsp;</span>Exercice 8</a></span></li><li><span><a href=\"#Exercice-9\" data-toc-modified-id=\"Exercice-9-3.3\"><span class=\"toc-item-num\">3.3&nbsp;&nbsp;</span>Exercice 9</a></span></li><li><span><a href=\"#Exercice-10\" data-toc-modified-id=\"Exercice-10-3.4\"><span class=\"toc-item-num\">3.4&nbsp;&nbsp;</span>Exercice 10</a></span></li><li><span><a href=\"#Exercice-11\" data-toc-modified-id=\"Exercice-11-3.5\"><span class=\"toc-item-num\">3.5&nbsp;&nbsp;</span>Exercice 11</a></span></li></ul></li><li><span><a href=\"#Listes\" data-toc-modified-id=\"Listes-4\"><span class=\"toc-item-num\">4&nbsp;&nbsp;</span>Listes</a></span><ul class=\"toc-item\"><li><span><a href=\"#Exercice-12\" data-toc-modified-id=\"Exercice-12-4.1\"><span class=\"toc-item-num\">4.1&nbsp;&nbsp;</span>Exercice 12</a></span></li><li><span><a href=\"#Exercice-13\" data-toc-modified-id=\"Exercice-13-4.2\"><span class=\"toc-item-num\">4.2&nbsp;&nbsp;</span>Exercice 13</a></span></li><li><span><a href=\"#Exercice-14\" data-toc-modified-id=\"Exercice-14-4.3\"><span class=\"toc-item-num\">4.3&nbsp;&nbsp;</span>Exercice 14</a></span></li><li><span><a href=\"#Exercice-15\" data-toc-modified-id=\"Exercice-15-4.4\"><span class=\"toc-item-num\">4.4&nbsp;&nbsp;</span>Exercice 15</a></span></li><li><span><a href=\"#Exercice-16\" data-toc-modified-id=\"Exercice-16-4.5\"><span class=\"toc-item-num\">4.5&nbsp;&nbsp;</span>Exercice 16</a></span></li><li><span><a href=\"#Exercice-17\" data-toc-modified-id=\"Exercice-17-4.6\"><span class=\"toc-item-num\">4.6&nbsp;&nbsp;</span>Exercice 17</a></span></li></ul></li><li><span><a href=\"#Exponentiation-rapide\" data-toc-modified-id=\"Exponentiation-rapide-5\"><span class=\"toc-item-num\">5&nbsp;&nbsp;</span>Exponentiation rapide</a></span><ul class=\"toc-item\"><li><span><a href=\"#Exercice-18\" data-toc-modified-id=\"Exercice-18-5.1\"><span class=\"toc-item-num\">5.1&nbsp;&nbsp;</span>Exercice 18</a></span></li><li><span><a href=\"#Exercice-19\" data-toc-modified-id=\"Exercice-19-5.2\"><span class=\"toc-item-num\">5.2&nbsp;&nbsp;</span>Exercice 19</a></span></li><li><span><a href=\"#Exercice-20\" data-toc-modified-id=\"Exercice-20-5.3\"><span class=\"toc-item-num\">5.3&nbsp;&nbsp;</span>Exercice 20</a></span></li><li><span><a href=\"#Exercice-21\" data-toc-modified-id=\"Exercice-21-5.4\"><span class=\"toc-item-num\">5.4&nbsp;&nbsp;</span>Exercice 21</a></span></li><li><span><a href=\"#Exercice-22\" data-toc-modified-id=\"Exercice-22-5.5\"><span class=\"toc-item-num\">5.5&nbsp;&nbsp;</span>Exercice 22</a></span></li><li><span><a href=\"#Exercice-23\" data-toc-modified-id=\"Exercice-23-5.6\"><span class=\"toc-item-num\">5.6&nbsp;&nbsp;</span>Exercice 23</a></span></li></ul></li><li><span><a href=\"#Formule-du-calcul-propositionnel\" data-toc-modified-id=\"Formule-du-calcul-propositionnel-6\"><span class=\"toc-item-num\">6&nbsp;&nbsp;</span>Formule du calcul propositionnel</a></span><ul class=\"toc-item\"><li><span><a href=\"#Exercice-24\" data-toc-modified-id=\"Exercice-24-6.1\"><span class=\"toc-item-num\">6.1&nbsp;&nbsp;</span>Exercice 24</a></span></li><li><span><a href=\"#Exercice-25\" data-toc-modified-id=\"Exercice-25-6.2\"><span class=\"toc-item-num\">6.2&nbsp;&nbsp;</span>Exercice 25</a></span></li><li><span><a href=\"#Exercice-26\" data-toc-modified-id=\"Exercice-26-6.3\"><span class=\"toc-item-num\">6.3&nbsp;&nbsp;</span>Exercice 26</a></span></li><li><span><a href=\"#Exercice-27\" data-toc-modified-id=\"Exercice-27-6.4\"><span class=\"toc-item-num\">6.4&nbsp;&nbsp;</span>Exercice 27</a></span></li><li><span><a href=\"#Exercice-28\" data-toc-modified-id=\"Exercice-28-6.5\"><span class=\"toc-item-num\">6.5&nbsp;&nbsp;</span>Exercice 28</a></span></li></ul></li><li><span><a href=\"#Conclusion\" data-toc-modified-id=\"Conclusion-7\"><span class=\"toc-item-num\">7&nbsp;&nbsp;</span>Conclusion</a></span></li></ul></div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# TP 1 - Programmation pour la préparation à l'agrégation maths option info\n",
    "\n",
    "## Remarques sur le style\n",
    "Ici, pour vous montrer, j'ai utilisé :\n",
    "- En Python 3, avec des annotations de types.\n",
    "- Notez que ce ne sont que des annotations.\n",
    "- Pour plus, il faudrait utiliser [quelque chose comme `beartype`](https://stackoverflow.com/a/37961120/2809027).\n",
    "\n",
    "Notez que ce n'est absolument *pas nécessaire*, c'était juste pour montrer que ce genre d'annotations peut aider à passer de Caml à Python."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Fonctions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercice 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-09-21T14:07:17.088595Z",
     "start_time": "2020-09-21T14:07:17.077008Z"
    }
   },
   "outputs": [],
   "source": [
    "def successeur(i : int) -> int:\n",
    "    assert isinstance(i, int), \"Erreur : i = {} doit etre entier.\".format(i)\n",
    "    assert i >= 0, \"Erreur : i = {} doit etre >= 0.\".format(i)\n",
    "    return i + 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-09-21T14:07:17.664661Z",
     "start_time": "2020-09-21T14:07:17.628150Z"
    }
   },
   "outputs": [
    {
     "ename": "AssertionError",
     "evalue": "Erreur : i = 2.5 doit etre entier.",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mAssertionError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-66-92b9c730a603>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0msuccesseur\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0msuccesseur\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m2\u001b[0m \u001b[0;34m*\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0msuccesseur\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m2.5\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m<ipython-input-65-6247174adc0e>\u001b[0m in \u001b[0;36msuccesseur\u001b[0;34m(i)\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0msuccesseur\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m \u001b[0;34m:\u001b[0m \u001b[0mstr\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m->\u001b[0m \u001b[0mfloat\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m     \u001b[0;32massert\u001b[0m \u001b[0misinstance\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mint\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"Erreur : i = {} doit etre entier.\"\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mformat\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      3\u001b[0m     \u001b[0;32massert\u001b[0m \u001b[0mi\u001b[0m \u001b[0;34m>=\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"Erreur : i = {} doit etre >= 0.\"\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mformat\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m     \u001b[0;32mreturn\u001b[0m \u001b[0mi\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mAssertionError\u001b[0m: Erreur : i = 2.5 doit etre entier."
     ]
    }
   ],
   "source": [
    "successeur(3)\n",
    "successeur(2 * 2)\n",
    "successeur(2.5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercice 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def produit3(x, y, z):\n",
    "    return x * y * z\n",
    "\n",
    "produit3_2 = lambda x, y, z: x * y * z\n",
    "\n",
    "produit3_3 = lambda x: lambda y: lambda z: x * y * z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "<function __main__.<lambda>.<locals>.<lambda>.<locals>.<lambda>(z)>"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "produit3(1, 2, 3)\n",
    "produit3_2(1, 2, 3)\n",
    "produit3_3(1)(2)  # lambda z : 1 * 2 * z\n",
    "f = produit3_3(1)(2)  # lambda z : 1 * 2 * z\n",
    "f(3)\n",
    "produit3_3(1)(2)(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercice 6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def exercice6(n : int) -> None:\n",
    "    for i in range(1, n + 1):\n",
    "        print(i)\n",
    "    for i in range(n, 0, -1):\n",
    "        print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "4\n",
      "3\n",
      "2\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "exercice6(4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Récursivité\n",
    "\n",
    "C'est simple. Pas besoin d'un mot clé `rec` quand on définit une fonction récursive en Python."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercice 7"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def factorielle(n : int) -> int:\n",
    "    if n <= 0:\n",
    "        return 0\n",
    "    elif n == 1:\n",
    "        return 1\n",
    "    else:\n",
    "        return n * factorielle(n - 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0! =     0\n",
      "1! =     1\n",
      "2! =     2\n",
      "3! =     6\n",
      "4! =    24\n",
      "5! =   120\n",
      "6! =   720\n",
      "7! =  5040\n"
     ]
    }
   ],
   "source": [
    "for i in range(8):\n",
    "    print(\"{}! = {:>5}\".format(i, factorielle(i)))\n",
    "    # Note : ce {:>5} signifie que l'affichage utilise au moins\n",
    "    # 5 caractères, pour avoir un joli alignement :"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercice 8\n",
    "\n",
    "Pour ce genre de fonction, j'aime bien afficher les appels récursifs. On peut rendre ça optionnel, avec comme ici un argument nommé `log`, à valeur par défaut `log=False`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-09-21T14:27:30.915769Z",
     "start_time": "2020-09-21T14:27:30.901732Z"
    }
   },
   "outputs": [],
   "source": [
    "def pgcd(x : int, y : int, log: bool=False) -> int:\n",
    "    if log: print(\"x = {:>7}, y = {:>7}\".format(x, y))\n",
    "    assert x >= 0 and y >= 0\n",
    "    if y == 1:\n",
    "        return 1\n",
    "    elif y == x or y == 0:\n",
    "        return x\n",
    "    if x < y:\n",
    "        return pgcd(x, y % x, log=log)\n",
    "    else:\n",
    "        return pgcd(y, x % y, log=log)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-09-21T14:27:31.090611Z",
     "start_time": "2020-09-21T14:27:31.083568Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x =    2021, y =       4\n",
      "x =       4, y =       1\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pgcd(2021, 4, log=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-09-21T14:27:31.622002Z",
     "start_time": "2020-09-21T14:27:31.611480Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pgcd(10, 5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On peut faire des essais pour afficher notre calcul de PGCD, sur des entiers aléatoires entre $1$ et $100$.\n",
    "\n",
    "Pour se rassurer, on peut chercher dans la bibliothèque standard, à partir de Python 3.6 il y a la fonction `math.gcd` pour calculer le PGCD, sinon `fractions.gcd` ou encore dans le module (non standard) SymPy `sympy.gcd`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " 61 ^  61 =  61\n",
      " 44 ^  85 =   1\n",
      " 48 ^  79 =   1\n",
      " 84 ^  83 =   1\n",
      " 17 ^  20 =   1\n",
      " 39 ^   2 =   1\n",
      " 30 ^  68 =   2\n",
      " 14 ^  87 =   1\n",
      " 46 ^  63 =   1\n",
      " 83 ^  84 =   1\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    from math import gcd\n",
    "except ImportError:\n",
    "    try:\n",
    "        from fractions import gcd\n",
    "    except ImportError:\n",
    "        from sympy import gcd\n",
    "\n",
    "\n",
    "from random import randint\n",
    "for _ in range(10):\n",
    "    x = randint(1, 100)\n",
    "    y = randint(1, 100)\n",
    "    d = pgcd(x, y)\n",
    "    print(\"{:>3} ^ {:>3} = {:>3}\".format(x, y, d))\n",
    "    assert d == gcd(x, y), \"Erreur : mauvais calcul de pgcd(x={}, y={}) = {}, alors qu'il devrait etre = {}.\".format(x, y, pgcd(x, y), gcd(x, y))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercice 9\n",
    "\n",
    "Rien de particulier à faire, la récursivité fonctionne sans réfléchir :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-09-21T10:06:31.131948Z",
     "start_time": "2020-09-21T10:06:31.120250Z"
    }
   },
   "outputs": [],
   "source": [
    "def fibonacci(n : int) -> int:\n",
    "    assert n >= 0\n",
    "    if n == 0 or n == 1:\n",
    "        return 1\n",
    "    else:\n",
    "        return fibonacci(n - 1) + fibonacci(n - 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dans IPython (ou Jupyter) on peut facilement mesurer le temps (moyen) d'exécution d'une fonction sur une entrée donnée, avec la *macro* `%timeit`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4.92 s ± 90.1 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n"
     ]
    }
   ],
   "source": [
    "%timeit fibonacci(35)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dans Python, on peut faire pareil avec `timeit()` du module `timeit`.\n",
    "\n",
    "- avantage : on peut plus facilement récupérer le temps de calcul, et ensuite en faire des graphiques par exemple (e.g., afficher $T(f(n))$ en fonction de $n$ pour $n=10,100,...$),\n",
    "- inconvénients :\n",
    "    + il faut bien penser de passer l'argument optionnel `globals=globals()` (`globals()` donne un dictionnaire qui stocke la valeur de toutes les variables définies, donc ici notamment de `fibonacci()`)\n",
    "    + il faut penser à changer l'argument `number` qui par défaut vaut `1000000` : c'est très grand, et donc valable seulement pour estimer le temps de calculs très rapides, par exemple :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-09-21T10:11:10.816187Z",
     "start_time": "2020-09-21T10:11:09.308196Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "17.3 ns ± 0.152 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "1.744021200283896e-08"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%timeit 2**35\n",
    "from timeit import timeit\n",
    "timeit(\"2**35\") / 1000000"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-09-21T10:08:16.277536Z",
     "start_time": "2020-09-21T10:08:10.720734Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Pour calculer fibonacci(35), la fonction récursive naïve a pris 5.549288985988824 secondes (moyenne sur 1 essais)\n"
     ]
    }
   ],
   "source": [
    "from timeit import timeit\n",
    "number = 5\n",
    "temps_calcul_fibo35 = timeit(\"fibonacci(35)\", globals=globals(), number=number) / number\n",
    "print(\"Pour calculer fibonacci(35), la fonction récursive naïve a pris {} secondes (moyenne sur {} essais)\".format(temps_calcul_fibo35, number))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Fibonacci linéaire impérative\n",
    "Pour la version qui est en complexité (temporelle) linéaire dans l'entrée $n$, il suffit de déplier la récursion en calculant $F_{n+1}$ progressivement en partant de $F_0, F_1$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-09-21T10:13:14.453159Z",
     "start_time": "2020-09-21T10:13:14.448775Z"
    }
   },
   "outputs": [],
   "source": [
    "def fibonacci_lin(n : int) -> int:\n",
    "    fim1, fi = 1, 1\n",
    "    for _ in range(n):\n",
    "        fim1, fi = fi, fim1 + fi\n",
    "    return fim1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On peut vérifier que cette deuxième implémentation fonctionne comme la première, et ensuite vérifier qu'elle est (bien) plus rapide."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-09-21T10:13:15.930888Z",
     "start_time": "2020-09-21T10:13:15.924705Z"
    }
   },
   "outputs": [],
   "source": [
    "for i in range(10):\n",
    "    assert fibonacci(i) == fibonacci_lin(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-09-21T10:13:18.887322Z",
     "start_time": "2020-09-21T10:13:16.747666Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.54 µs ± 169 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)\n"
     ]
    }
   ],
   "source": [
    "%timeit fibonacci_lin(35)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Fibonacci linéaire récursive\n",
    "Pour la version qui est en complexité (temporelle) linéaire dans l'entrée $n$, il suffit de déplier la récursion en calculant $F_{n+1}$ progressivement en partant de $F_0, F_1$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-09-21T10:12:24.885160Z",
     "start_time": "2020-09-21T10:12:24.873494Z"
    }
   },
   "outputs": [],
   "source": [
    "def fibonacci_lin_rec(n: int) -> int:\n",
    "    # invariant :\n",
    "    #   m >= 1\n",
    "    #   u = fibo(n-m+1)\n",
    "    #   v = fibo(n-m)\n",
    "    #   aux m u v = fibo(n)\n",
    "    def aux(m: int, u: int, v: int) -> int:\n",
    "        assert m >= 0\n",
    "        if m <= 1:\n",
    "            return u\n",
    "        else:\n",
    "            return aux(m-1, u+v, u)\n",
    "    return aux(n, 1, 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On peut vérifier que cette troisième implémentation fonctionne comme la première, et ensuite vérifier qu'elle est (bien) plus rapide."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-09-21T10:12:25.705979Z",
     "start_time": "2020-09-21T10:12:25.698630Z"
    }
   },
   "outputs": [],
   "source": [
    "for i in range(10):\n",
    "    assert fibonacci(i) == fibonacci_lin_rec(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-09-21T10:12:43.246055Z",
     "start_time": "2020-09-21T10:12:34.747798Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9.52 µs ± 854 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)\n"
     ]
    }
   ],
   "source": [
    "%timeit fibonacci_lin_rec(35)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Voilà les différences :\n",
    "\n",
    "- Les deux implémentations linéaires sont bien plus rapides que l'implémentation naïve (exponentielle), comme prévu !\n",
    "- L'implémentation linéaire impérative est plus rapide que l'implémentation linéaire fonctionnelle récursive, car elle n'a pas besoin de faire des appels de fonctions et de dépiler ensuite les appels de fonctions."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Un petit graphique : juste pour montrer ce que l'on peut faire rapidement"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-09-21T10:15:06.920414Z",
     "start_time": "2020-09-21T10:15:06.545707Z"
    }
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-09-21T10:19:01.575836Z",
     "start_time": "2020-09-21T10:19:01.572500Z"
    }
   },
   "outputs": [],
   "source": [
    "# optionnel : vous ne l'aurez pas le jour de l'oral, mais c'est joli\n",
    "from tqdm.notebook import tqdm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-09-21T10:19:02.098801Z",
     "start_time": "2020-09-21T10:19:02.092203Z"
    }
   },
   "outputs": [],
   "source": [
    "valeurs_n = np.array(range(1, 32))\n",
    "number = 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-09-21T10:19:17.263522Z",
     "start_time": "2020-09-21T10:19:07.337190Z"
    }
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "84472a80e9a1439e8cdd8f869ef03907",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(FloatProgress(value=0.0, max=31.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "CPU times: user 9.91 s, sys: 3.99 ms, total: 9.91 s\n",
      "Wall time: 9.92 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "temps_calcul_fibo_rec = [\n",
    "    timeit(\"fibonacci({})\".format(n), globals=globals(), number=number) / number\n",
    "    for n in tqdm(valeurs_n)\n",
    "    # enrober un itérateur de la fonction tqdm(...)\n",
    "    # permet d'avoir une joli barre de progression\n",
    "]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-09-21T10:19:42.763913Z",
     "start_time": "2020-09-21T10:19:42.634631Z"
    }
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(FloatProgress(value=0.0, max=31.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(FloatProgress(value=0.0, max=31.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "number = 100\n",
    "temps_calcul_fibo_lin = [\n",
    "    timeit(\"fibonacci_lin({})\".format(n), globals=globals(), number=number) / number\n",
    "    for n in tqdm(valeurs_n)\n",
    "]\n",
    "temps_calcul_fibo_lin_rec = [\n",
    "    timeit(\"fibonacci_lin_rec({})\".format(n), globals=globals(), number=number) / number\n",
    "    for n in tqdm(valeurs_n)\n",
    "]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-09-21T10:21:47.428963Z",
     "start_time": "2020-09-21T10:21:47.099693Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1008x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(14, 10))\n",
    "plt.plot(valeurs_n, temps_calcul_fibo_rec, \"ro-\", label=\"Récursive naïve\")\n",
    "plt.plot(valeurs_n, temps_calcul_fibo_lin, \"bd:\", label=\"Linéaire impérative\")\n",
    "plt.plot(valeurs_n, temps_calcul_fibo_lin_rec, \"ys:\", label=\"Linéaire récursive\")\n",
    "\n",
    "plt.legend()\n",
    "plt.title(\"Comparaison de trois implémentations de la fonction de Fibonacci\")\n",
    "plt.xlabel(\"Valeurs de n\")\n",
    "plt.ylabel(\"Temps moyen de calcul en secondes\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-09-21T10:24:45.453220Z",
     "start_time": "2020-09-21T10:24:22.736662Z"
    }
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "b5408f83da864f7fb33b7d6eaf1ecee1",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(FloatProgress(value=0.0, max=99.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "cb04e6a859954213afff5ffe72136727",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(FloatProgress(value=0.0, max=99.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "CPU times: user 22.7 s, sys: 124 ms, total: 22.8 s\n",
      "Wall time: 22.7 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "valeurs_n = np.array(range(10, 1000, 10))\n",
    "number = 1000\n",
    "temps_calcul_fibo_lin = [\n",
    "    timeit(\"fibonacci_lin({})\".format(n), globals=globals(), number=number) / number\n",
    "    for n in tqdm(valeurs_n)\n",
    "]\n",
    "temps_calcul_fibo_lin_rec = [\n",
    "    timeit(\"fibonacci_lin_rec({})\".format(n), globals=globals(), number=number) / number\n",
    "    for n in tqdm(valeurs_n)\n",
    "]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-09-21T10:24:47.708424Z",
     "start_time": "2020-09-21T10:24:47.346345Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1008x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(14, 10))\n",
    "plt.plot(valeurs_n, temps_calcul_fibo_lin, \"bd:\", label=\"Linéaire impérative\")\n",
    "plt.plot(valeurs_n, temps_calcul_fibo_lin_rec, \"ys:\", label=\"Linéaire récursive\")\n",
    "\n",
    "plt.legend()\n",
    "plt.title(\"Comparaison de deux implémentations de la fonction de Fibonacci\")\n",
    "plt.xlabel(\"Valeurs de n\")\n",
    "plt.ylabel(\"Temps moyen de calcul en secondes\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercice 10\n",
    "\n",
    "Aucune hypothèse n'est faite sur les arguments de la fonction, on supposera seulement qu'elle est itérable sur sa sortie."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-09-21T10:26:36.528638Z",
     "start_time": "2020-09-21T10:26:36.515505Z"
    }
   },
   "outputs": [],
   "source": [
    "from types import FunctionType  # inutile, juste pour faire joli\n",
    "\n",
    "# première version, f : type x -> type x (simple)\n",
    "def itere(f : FunctionType, n : int) -> FunctionType:\n",
    "    def fn(x):\n",
    "        for _ in range(n):\n",
    "            x = f(x)\n",
    "        return x\n",
    "    return fn"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-09-21T10:26:36.970802Z",
     "start_time": "2020-09-21T10:26:36.956202Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "11"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "itere(lambda x: x + 1, 10)(1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On peut aussi écrire une version récursive :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-09-21T10:26:38.811765Z",
     "start_time": "2020-09-21T10:26:38.804786Z"
    }
   },
   "outputs": [],
   "source": [
    "def compose(f, g):\n",
    "    return lambda x: f(g(x))\n",
    "    \"\"\"\n",
    "    def f_rond_g(x):\n",
    "        return f(g(x))\n",
    "    return f_rond_g\n",
    "    \"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-09-21T10:26:49.870642Z",
     "start_time": "2020-09-21T10:26:49.866031Z"
    }
   },
   "outputs": [],
   "source": [
    "def itere_rec(f : FunctionType, n : int) -> FunctionType:\n",
    "    assert n >= 0\n",
    "    if n == 0:\n",
    "        return lambda x: x\n",
    "    elif n == 1:\n",
    "        return f\n",
    "    else:\n",
    "        return compose(f, itere_rec(f, n-1))\n",
    "        return compose(itere_rec(f, n-1), f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-09-21T10:26:50.233472Z",
     "start_time": "2020-09-21T10:26:50.222238Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "11"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "itere_rec(lambda x: x + 1, 10)(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-09-21T10:27:39.711749Z",
     "start_time": "2020-09-21T10:27:24.011871Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "969 µs ± 89.8 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)\n",
      "946 µs ± 79.5 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)\n"
     ]
    }
   ],
   "source": [
    "%timeit itere(lambda x: x + 1, 1000)(1)\n",
    "%timeit itere_rec(lambda x: x + 1, 1000)(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# deuxième version, f : tuple -> tuple (simple)\n",
    "def itere2(f : FunctionType, n : int) -> FunctionType:\n",
    "    def fn(*args):\n",
    "        for _ in range(n):\n",
    "            if isinstance(args, tuple):\n",
    "                args = f(*args)\n",
    "            else:\n",
    "                args = f(args)\n",
    "        if isinstance(args, tuple) and len(args) == 1:\n",
    "            return args[0]\n",
    "        else:\n",
    "            return args\n",
    "    return fn"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "11"
      ]
     },
     "execution_count": 132,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "(1024, 2048)"
      ]
     },
     "execution_count": 132,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def plusun(x):\n",
    "    return x + 1\n",
    "\n",
    "itere2(plusun, 10)(1)\n",
    "\n",
    "def foisdeux(x, y):\n",
    "    return x * 2, y * 2\n",
    "\n",
    "itere2(foisdeux, 10)(1, 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercice 11\n",
    "\n",
    "C'est assez naturel, on affiche la suite de mouvement à faire, comme une suite de `\"T1 -> T2\"` par exemple.\n",
    "La fonction suivante affiche les déplacements qu'il faut faire pour déplacer une tour de hauteur `n` initialement posée en `x`, à destination de `z` et avec `y` comme position intermédiaire.\n",
    "\n",
    "- le cas de base est pour une tour de hauteur 1 : un seul déplacement de `x` vers `z` suffit,\n",
    "- le cas récursif est très simple : pour une tour de hauteur `n`, il faut déplacer de `x` vers `y` le haut de la tour (de hauteur `n-1` : 1er appel récursif), puis déplacer le plus gros disque (en un mouvement) de `x` vers `z`, puis de nouveau déplacer le haut de la tour (toujours de hauteur `n-1` : 2nd appel récursif) de `y` vers `z`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def hanoi(x : str, y : str, z : str, n : int) -> None:\n",
    "    def hanoiaux(orig : str, dest : str, inter : str, n : int):\n",
    "        if n == 0:\n",
    "            return 0\n",
    "        c1 = hanoiaux(orig, inter, dest, n - 1)\n",
    "        print(\"{} -> {}\".format(orig, dest))\n",
    "        c2 = hanoiaux(inter, dest, orig, n - 1)\n",
    "        return c1 + 1 + c2\n",
    "    return hanoiaux(x, z, y, n)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "T1 -> T3\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 145,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hanoi(\"T1\", \"T2\", \"T3\", 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "T1 -> T2\n",
      "T1 -> T3\n",
      "T2 -> T3\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 146,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hanoi(\"T1\", \"T2\", \"T3\", 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "T1 -> T3\n",
      "T1 -> T2\n",
      "T3 -> T2\n",
      "T1 -> T3\n",
      "T2 -> T1\n",
      "T2 -> T3\n",
      "T1 -> T3\n",
      "T1 -> T2\n",
      "T3 -> T2\n",
      "T3 -> T1\n",
      "T2 -> T1\n",
      "T3 -> T2\n",
      "T1 -> T3\n",
      "T1 -> T2\n",
      "T3 -> T2\n",
      "T1 -> T3\n",
      "T2 -> T1\n",
      "T2 -> T3\n",
      "T1 -> T3\n",
      "T2 -> T1\n",
      "T3 -> T2\n",
      "T3 -> T1\n",
      "T2 -> T1\n",
      "T2 -> T3\n",
      "T1 -> T3\n",
      "T1 -> T2\n",
      "T3 -> T2\n",
      "T1 -> T3\n",
      "T2 -> T1\n",
      "T2 -> T3\n",
      "T1 -> T3\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "31"
      ]
     },
     "execution_count": 148,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hanoi(\"T1\", \"T2\", \"T3\", 5)  # 31 = 2^5 - 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "----\n",
    "# Listes\n",
    "## Exercice 12\n",
    "Les listes en Python sont des `list`.\n",
    "\n",
    "Elles ne fonctionnent **pas** comme des listes simplement chaînées comme en Caml : ce sont des tableaux, donc l'accès à `T[i]` pour n'importe quel `i` est en $\\mathcal{O}(1)$ pour n'importe quel `i` et `n`.\n",
    "\n",
    "<span style=\"color: red;\">MUST READ</span>\n",
    "Allez lire la page https://wiki.python.org/moin/TimeComplexity#list en détail !"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-09-21T10:33:06.517680Z",
     "start_time": "2020-09-21T10:33:06.511976Z"
    }
   },
   "outputs": [],
   "source": [
    "def concatene(liste1 : list, liste2 : list) -> list:\n",
    "    \"\"\" O(len(liste1) + len(liste2))\"\"\"\n",
    "    # return liste1 + liste2  # solution facile\n",
    "    n1, n2 = len(liste1), len(liste2)\n",
    "    res = []\n",
    "    for i in range(n1 + n2):\n",
    "        if i < n1:\n",
    "            res.append(liste1[i])\n",
    "        else:\n",
    "            res.append(liste2[i - n1])\n",
    "    return res"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 153,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 5]"
      ]
     },
     "execution_count": 153,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "concatene([1, 2, 3], [4, 5])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercice 13"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-09-21T10:33:47.266250Z",
     "start_time": "2020-09-21T10:33:47.259910Z"
    }
   },
   "outputs": [],
   "source": [
    "from types import FunctionType\n",
    "\n",
    "def applique(f : FunctionType, liste : list) -> list:\n",
    "    res = [f(x) for x in liste]  # solution facile\n",
    "    res = map(f, liste)  # encore plus facile\n",
    "    # en itérant la liste :\n",
    "    res = [ ]  # tableau vide\n",
    "    for x in liste:\n",
    "        res.append(f(x))\n",
    "    # en itérant ses valeurs :\n",
    "    res = [ ]  # tableau\n",
    "    for i in range(len(liste)):\n",
    "        res.append(f(liste[i]))\n",
    "    return res"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 164,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 3, 4]"
      ]
     },
     "execution_count": 164,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "applique(lambda x : x + 1, [1, 2, 3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercice 14"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 165,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def liste_carree(liste : list) -> list:\n",
    "    return applique(lambda x: x**2, liste)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 167,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 4, 9]"
      ]
     },
     "execution_count": 167,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "liste_carree([1, 2, 3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercice 15"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 180,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def miroir_quad(liste : list) -> list:\n",
    "    # aucune idée pour le faire innefficacement en Python,\n",
    "    # ce ne sont pas des listes chaînées\n",
    "    return liste[::-1]\n",
    "\n",
    "def miroir_lin(liste : list) -> list:\n",
    "    return [liste[-i] for i in range(1, len(liste) + 1)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 181,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[3, 2, 1]"
      ]
     },
     "execution_count": 181,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "miroir_lin([1, 2, 3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercice 16"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 186,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def insertion_dans_liste_triee(entiers : list, x : int) -> list:\n",
    "    i = 0\n",
    "    while i < len(entiers) and entiers[i] < x:\n",
    "        i += 1\n",
    "    return entiers[:i] + [x] + entiers[i:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 187,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 4, 5, 6]"
      ]
     },
     "execution_count": 187,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "insertion_dans_liste_triee([1, 2, 5, 6], 4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 190,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def tri_insertion(entiers : list) -> list:\n",
    "    assert all([isinstance(i, int) for _ in entiers])\n",
    "    def trix(e : list, acc : list) -> list:\n",
    "        if len(e) == 0: return acc\n",
    "        else: return trix(e[1:], insertion_dans_liste_triee(acc, e[0]))\n",
    "    return trix(entiers, [])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 191,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 4, 5, 6]"
      ]
     },
     "execution_count": 191,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tri_insertion([5, 2, 6, 1, 4])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercice 17"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 193,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def ordre_decroissant(x, y):\n",
    "    return x > y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 195,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from types import FunctionType\n",
    "\n",
    "def insertion_dans_liste_triee2(entiers : list, x : int, ordre : FunctionType) -> list:\n",
    "    i = 0\n",
    "    while i < len(entiers) and ordre(entiers[i], x):\n",
    "        i += 1\n",
    "    return entiers[:i] + [x] + entiers[i:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 196,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[6, 5, 4, 2, 1]"
      ]
     },
     "execution_count": 196,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "insertion_dans_liste_triee2([6, 5, 2, 1], 4, ordre_decroissant)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 197,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def tri_insertion2(entiers : list, ordre : FunctionType) -> list:\n",
    "    assert all([isinstance(i, int) for _ in entiers])\n",
    "    def trix(e : list, acc : list) -> list:\n",
    "        if len(e) == 0: return acc\n",
    "        else: return trix(e[1:], insertion_dans_liste_triee2(acc, e[0], ordre))\n",
    "    return trix(entiers, [])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 200,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 4, 5, 6]"
      ]
     },
     "execution_count": 200,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "[6, 5, 4, 2, 1]"
      ]
     },
     "execution_count": 200,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tri_insertion([5, 2, 6, 1, 4])\n",
    "tri_insertion2([5, 2, 6, 1, 4], ordre_decroissant)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "----\n",
    "# Exponentiation rapide\n",
    "## Exercice 18\n",
    "\n",
    "Une approche naïve, de complexité temporelle linéaire en $n$ ($\\mathcal{O}(n)$)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-09-21T15:48:17.801024Z",
     "start_time": "2020-09-21T15:48:17.791745Z"
    }
   },
   "outputs": [],
   "source": [
    "def exp(x : int, n : int) -> int:\n",
    "    res = 1\n",
    "    for _ in range(n):\n",
    "        res *= x\n",
    "    return res"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-09-21T15:50:07.079812Z",
     "start_time": "2020-09-21T15:50:07.062055Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3 ** 0 = 1 et = 1\n",
      "3 ** 1 = 3 et = 3\n",
      "3 ** 2 = 9 et = 9\n",
      "3 ** 3 = 27 et = 27\n",
      "3 ** 4 = 81 et = 81\n",
      "3 ** 5 = 243 et = 243\n",
      "3 ** 6 = 729 et = 729\n",
      "3 ** 7 = 2187 et = 2187\n"
     ]
    }
   ],
   "source": [
    "x = 3\n",
    "for n in range(8):\n",
    "    print(x, \"**\", n, \"=\", exp(x, n), \"et =\", x**n)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  3 ** 0 =     1\n",
      "  3 ** 1 =     3\n",
      "  3 ** 2 =     9\n",
      "  3 ** 3 =    27\n",
      "  3 ** 4 =    81\n",
      "  3 ** 5 =   243\n",
      "  3 ** 6 =   729\n",
      "  3 ** 7 =  2187\n"
     ]
    }
   ],
   "source": [
    "x = 3\n",
    "for n in range(8):\n",
    "    print(\"  {} ** {} = {:>5}\".format(x, n, exp(x, n)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercice 19\n",
    "\n",
    "Une approche maline (optimale, en fait).\n",
    "\n",
    "Si n = 0 $x^0 = 1$\n",
    "\n",
    "Si n est pair :\n",
    "$$ x^n = (x^{(n/2)})^2$$\n",
    "$$ x^n = (x*x)^{(n/2)}$$\n",
    "\n",
    "Si n est impair :\n",
    "$$ x^n = x * (x^{((n-1)/2)})^2$$\n",
    "$$ x^n = x * (x*x)^{((n-1)/2)}$$\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-09-21T15:56:43.800416Z",
     "start_time": "2020-09-21T15:56:43.794703Z"
    }
   },
   "outputs": [],
   "source": [
    "def exp2(x : int, n : int) -> int:\n",
    "    assert n >= 0\n",
    "    if n == 0:\n",
    "        return 1\n",
    "    elif n == 1:\n",
    "        return x\n",
    "    elif n % 2 == 0:\n",
    "        # NE PAS FAIRE CA\n",
    "         # return exp2(x, n // 2) * exp2(x, n // 2)\n",
    "        return exp2(x * x, n // 2)\n",
    "        return exp2(x, n // 2) ** 2\n",
    "    elif n % 2 == 1:\n",
    "        return exp2(x * x, (n - 1) // 2) * x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-09-21T15:56:44.097713Z",
     "start_time": "2020-09-21T15:56:44.090251Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  3 ** 0 =     1\n",
      "  3 ** 1 =     3\n",
      "  3 ** 2 =     9\n",
      "  3 ** 3 =    27\n",
      "  3 ** 4 =    81\n",
      "  3 ** 5 =   243\n",
      "  3 ** 6 =   729\n",
      "  3 ** 7 =  2187\n"
     ]
    }
   ],
   "source": [
    "x = 3\n",
    "for n in range(8):\n",
    "    print(\"  {} ** {} = {:>5}\".format(x, n, exp2(x, n)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-09-21T15:57:07.088811Z",
     "start_time": "2020-09-21T15:57:07.072244Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  3.1415 ** 0 =     1 et x**n = 1.0\n",
      "  3.1415 ** 1 = 3.1415 et x**n = 3.1415\n",
      "  3.1415 ** 2 = 9.86902225 et x**n = 9.86902225\n",
      "  3.1415 ** 3 = 31.003533398375 et x**n = 31.003533398375005\n",
      "  3.1415 ** 4 = 97.39760017099508 et x**n = 97.39760017099509\n",
      "  3.1415 ** 5 = 305.974560937181 et x**n = 305.9745609371811\n",
      "  3.1415 ** 6 = 961.2190831841542 et x**n = 961.2190831841544\n",
      "  3.1415 ** 7 = 3019.6697498230205 et x**n = 3019.6697498230214\n"
     ]
    }
   ],
   "source": [
    "x = 3.1415\n",
    "for n in range(8):\n",
    "    print(\"  {} ** {} = {:>5} et x**n = {}\".format(x, n, exp2(x, n), x**n))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercice 20\n",
    "On ne dispose pas de typage pour faire ça aussi joliment qu'en Caml..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def mult_float(x : float, y : float) -> float:\n",
    "    return x * y\n",
    "\n",
    "monoide_flottants = {\n",
    "    'mult': mult_float,   # (*.) en Caml\n",
    "    'neutre': 1.\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "class Monoide_flottant():\n",
    "    def __init__(self, x):\n",
    "        self.x\n",
    "        self.neutre = 1.0\n",
    "    \n",
    "    def mult(self, other_float):\n",
    "        return self.x * other_float.x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "def mult_ndarray(A : np.array, B : np.array) -> np.array:\n",
    "    return np.dot(A, B)\n",
    "\n",
    "# Pas possible d'avoir un neutre pour une taille quelconque !\n",
    "monoide_nparray = lambda n, m: {\n",
    "    'mult': mult_ndarray,\n",
    "    'neutre': np.eye(n, m)\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[4, 6],\n",
       "       [4, 6]])"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mult_ndarray([[1, 1], [1, 1]], [[1, 2], [3, 4]])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Manuellement ce n'est pas trop dur :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def mult_mat(A : list, B : list) -> list:\n",
    "    n, m = len(A), len(A[0])  # A est (n, m)\n",
    "    m2, p = len(B), len(B[0]) # B est (m2, p)\n",
    "    assert m == m2\n",
    "    C = [[0 for _ in range(p)] for _ in range(n)]  # C est (n, p)\n",
    "    for i in range(n):\n",
    "        for j in range(p):\n",
    "            for k in range(m):\n",
    "                C[i][j] += A[i][k] * B[k][j]\n",
    "    return C\n",
    "\n",
    "# Pas possible d'avoir un neutre pour une taille quelconque !\n",
    "monoide_mat = lambda n, m: {\n",
    "    'mult': mult_mat,\n",
    "    'neutre': [[int(i==j) for j in range(m)] for i in range(n)]  # I est (n, m)\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[4, 6], [4, 6]]"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mult_mat([[1, 1], [1, 1]], [[1, 2], [3, 4]])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercice 21"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-09-21T16:05:43.012097Z",
     "start_time": "2020-09-21T16:05:42.998146Z"
    }
   },
   "outputs": [],
   "source": [
    "def exp_rapide(monoide : dict, x, n : int):\n",
    "    mult = monoide['mult']\n",
    "    assert n >= 0\n",
    "    if n == 0:\n",
    "        return monoide['neutre']\n",
    "    elif n == 1:\n",
    "        return x\n",
    "    elif n % 2 == 0:\n",
    "        return exp_rapide(monoide, mult(x, x), n // 2)\n",
    "    elif n % 2 == 1:\n",
    "        return mult(exp_rapide(monoide, mult(x, x), (n - 1) // 2), x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercice 22"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def exp_rapide_float(x : float, n : int) -> float:\n",
    "    return exp_rapide(monoide_flottants, x, n)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "256.0"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "exp_rapide_float(2.0, 8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.560000000000002e-06"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "exp_rapide_float(0.2, 8)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Et pour les matrices, un petit piège à cause des tailles :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def exp_rapide_mat(A : list, k : int) -> float:\n",
    "    n, m = len(A), len(A[0])\n",
    "    mono = monoide_mat(n, m)\n",
    "    return exp_rapide(mono, A, k)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[1, 0], [0, 1]]"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "[[1, 1], [1, 1]]"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "[[2, 2], [2, 2]]"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "[[4, 4], [4, 4]]"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "[[8, 8], [8, 8]]"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "for k in range(5):\n",
    "    exp_rapide_mat([[1, 1], [1, 1]], k)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[1, 0, 0], [0, 1, 0], [0, 0, 1]]"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "[[0, 1, 2], [0, 0, 1], [0, 0, 0]]"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "[[0, 0, 1], [0, 0, 0], [0, 0, 0]]"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "[[0, 0, 0], [0, 0, 0], [0, 0, 0]]"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "[[0, 0, 0], [0, 0, 0], [0, 0, 0]]"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "for k in range(5):  # nilpotente\n",
    "    exp_rapide_mat([[0, 1, 2], [0, 0, 1], [0, 0, 0]], k)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercice 23\n",
    "\n",
    "- On peut commencer par réécrire l'exponentiation rapide avec un `itere` :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "def exp_rapide_2(x, n : int):\n",
    "    def mul_par_x(y):\n",
    "        return x * y\n",
    "    return itere(mul_par_x, n)(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "512.0"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "exp_rapide_2(2.0, 8)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Mais on demandait ici d'écrire `itere` avec l'exponentiation rapide :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-09-21T16:07:23.509631Z",
     "start_time": "2020-09-21T16:07:23.499248Z"
    }
   },
   "outputs": [],
   "source": [
    "def mult_fonction(f : FunctionType, g : FunctionType) -> FunctionType:\n",
    "    return lambda x: f(g(x))\n",
    "\n",
    "monoide_fonction = {\n",
    "    'mult': mult_fonction,\n",
    "    'neutre': lambda x: x  # identité !\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-09-21T16:07:23.909185Z",
     "start_time": "2020-09-21T16:07:23.901795Z"
    }
   },
   "outputs": [],
   "source": [
    "def itere_depuis_monoide(f, n):\n",
    "    return exp_rapide(monoide_fonction, f, n)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-09-21T16:07:53.176627Z",
     "start_time": "2020-09-21T16:07:52.882579Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "11\n",
      "1000001\n"
     ]
    }
   ],
   "source": [
    "print(itere_depuis_monoide(lambda x: x+1, 0)(1))  # 1\n",
    "print(itere_depuis_monoide(lambda x: x+1, 10)(1)) # 11\n",
    "print(itere_depuis_monoide(lambda x: x+1, 1000000)(1))  # pas de stack overflow car complexité O(log(n))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A comparer avec l'implémentation naïve qui était en $\\mathcal{O}(n)$ :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-09-21T16:09:25.163863Z",
     "start_time": "2020-09-21T16:09:19.166005Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "11\n"
     ]
    },
    {
     "ename": "RecursionError",
     "evalue": "maximum recursion depth exceeded in comparison",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mRecursionError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-101-e5141bc75381>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mitere\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# 1\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mitere\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m10\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# 11\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mitere\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m1000000\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# pas de stack overflow car complexité O(log(n))\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m<ipython-input-100-4ff528828113>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(x)\u001b[0m\n\u001b[1;32m      3\u001b[0m         \u001b[0;32mreturn\u001b[0m \u001b[0;32mlambda\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m     \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 5\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0;32mlambda\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mitere\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mn\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "... last 1 frames repeated, from the frame below ...\n",
      "\u001b[0;32m<ipython-input-100-4ff528828113>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(x)\u001b[0m\n\u001b[1;32m      3\u001b[0m         \u001b[0;32mreturn\u001b[0m \u001b[0;32mlambda\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m     \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 5\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0;32mlambda\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mitere\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mn\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mRecursionError\u001b[0m: maximum recursion depth exceeded in comparison"
     ]
    }
   ],
   "source": [
    "print(itere(lambda x: x+1, 0)(1))  # 1\n",
    "print(itere(lambda x: x+1, 10)(1)) # 11\n",
    "print(itere(lambda x: x+1, 1000000)(1))  # stack overflow car complexité O(n)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "----\n",
    "# Formule du calcul propositionnel\n",
    "\n",
    "**Spoiler alert** : en Python, c'est chaud.\n",
    "\n",
    "**ATTENTION** Il faut un peu d'habitude et d'idées pour réussir à faire tout ça aussi efficacement (enfin presque) qu'en OCaml.\n",
    "\n",
    "On va faire des choses non typées, avec des dictionnaires, pour bidouiller.\n",
    "\n",
    "## Exercice 24"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "``(not p ^ ((q ^ not p) v (r v q)))`` s'écrit en Caml `` (Conj(Not(V(\"p\")),Disj(Conj(V(\"q\"),Not(V(\"p\"))),Disj(V(\"r\"),V(\"q\")))))``.\n",
    "\n",
    "On va imbriquer des dictionnaires, les types, `V`, `Not`, `Conj` et `Disj` seront des clés, et les valeurs seront des formules ou couples de formules.\n",
    "Mais on va cacher ça et l'utilisateur verra exactement la même chose qu'en Caml !"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-09-21T10:35:56.912012Z",
     "start_time": "2020-09-21T10:35:56.884090Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Conj': ({'Not': {'V': 'p'}},\n",
       "  {'Disj': ({'Conj': ({'V': 'q'}, {'Not': {'V': 'p'}})},\n",
       "    {'Disj': ({'V': 'r'}, {'V': 'q'})})})}"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "V = lambda x: {'V': x}\n",
    "Not = lambda x: {'Not': x}\n",
    "Disj = lambda x, y: {'Disj': (x, y)}\n",
    "Conj = lambda x, y: {'Conj': (x, y)}\n",
    "\n",
    "p = V('p')\n",
    "r = V('r')\n",
    "q = V('q')\n",
    "not_p = Not(p)\n",
    "\n",
    "f = Conj(Not(p), Disj(Conj(q, not_p), Disj(r, q)))\n",
    "f"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-09-21T10:36:04.720779Z",
     "start_time": "2020-09-21T10:36:04.707038Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Conj': ({'Not': {'V': 'p'}},\n",
       "  {'Disj': ({'Conj': ({'V': 'q'}, {'Not': {'V': 'p'}})},\n",
       "    {'Disj': ({'V': 'r'}, {'V': 'q'})})})}"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f2 = (Conj(Not(V(\"p\")),Disj(Conj(V(\"q\"),Not(V(\"p\"))),Disj(V(\"r\"),V(\"q\")))))\n",
    "f2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si on veut afficher plus joliment ce genre de structures récursives, la fonction `pprint.pprint(...)` est là pour ça (elle affiche avec de l'indentation) :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-09-21T10:35:57.849835Z",
     "start_time": "2020-09-21T10:35:57.843083Z"
    }
   },
   "outputs": [],
   "source": [
    "from pprint import pprint"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-09-21T10:36:07.358858Z",
     "start_time": "2020-09-21T10:36:07.349955Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Conj': ({'Not': {'V': 'p'}},\n",
      "          {'Disj': ({'Conj': ({'V': 'q'}, {'Not': {'V': 'p'}})},\n",
      "                    {'Disj': ({'V': 'r'}, {'V': 'q'})})})}\n"
     ]
    }
   ],
   "source": [
    "pprint(f2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercice 25"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ensuite on fait une filtration \"à la main\" sur les clés du dictionnaire (de niveau 1, on ne récurse pas quand on teste `'V' in formule`)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-09-21T10:36:23.687937Z",
     "start_time": "2020-09-21T10:36:23.675670Z"
    }
   },
   "outputs": [],
   "source": [
    "def taille(formule : dict) -> int:\n",
    "    if 'V' in formule:\n",
    "        return 0\n",
    "    elif 'Not' in formule:\n",
    "        return 1 + taille(formule['Not'])\n",
    "    elif 'Conj' in formule:\n",
    "        x, y = formule['Conj']\n",
    "        return 1 + taille(x) + taille(y)\n",
    "    elif 'Disj' in formule:\n",
    "        x, y = formule['Disj']\n",
    "        return 1 + taille(x) + taille(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-09-21T10:36:24.188578Z",
     "start_time": "2020-09-21T10:36:24.175810Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "taille(f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-09-21T10:36:24.674392Z",
     "start_time": "2020-09-21T10:36:24.664847Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "taille(f2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercice 26"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def formule_to_string(formule : dict) -> str:\n",
    "    if 'V' in formule:\n",
    "        return formule['V']\n",
    "    elif 'Not' in formule:\n",
    "        return \"~\" + formule_to_string(formule['Not'])\n",
    "    elif 'Conj' in formule:\n",
    "        x, y = formule['Conj']\n",
    "        return \"(\" + formule_to_string(x) + \" ^ \" + formule_to_string(y) + \")\"\n",
    "    elif 'Disj' in formule:\n",
    "        x, y = formule['Disj']\n",
    "        return \"(\" + formule_to_string(x) + \" V \" + formule_to_string(y) + \")\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def affiche(formule):\n",
    "    print(formule_to_string(formule))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(~p ^ ((q ^ ~p) V (r V q)))\n"
     ]
    }
   ],
   "source": [
    "affiche(f)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Et voilà. Pas tellement plus dur hein !"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercice 27\n",
    "Les valeurs des variables seront données comme un dictionnaire associant nom de variable à valeurs booléennes.\n",
    "Et comme on veut frimer, on prend un [`defaultdict`](https://docs.python.org/3/library/collections.html#collections.defaultdict), qui est comme un `dict` mais qui stocke aussi une fonction qui donne la valeur des clés absentes du dictionnaire :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-09-21T16:11:46.830395Z",
     "start_time": "2020-09-21T16:11:46.815496Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n",
      "False\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "from collections import defaultdict\n",
    "\n",
    "d = defaultdict(lambda: False, {'p': True, 'q': False})\n",
    "print(d['p'])  # -> True car présent et True\n",
    "print(d['q'])  # -> False car présent et False\n",
    "print(d['x'])  # -> False car absent\n",
    "print(d['xokazeok'])  # -> False car absent"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [],
   "source": [
    "valeurs_1 = defaultdict(lambda: False, {'p': True})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "valeurs_2 = defaultdict(lambda: False, {'r': True})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def eval(valeurs : dict, formule : dict) -> bool:\n",
    "    if 'V' in formule:\n",
    "        return valeurs[formule['V']]\n",
    "    elif 'Not' in formule:\n",
    "        return not eval(valeurs, formule['Not'])\n",
    "    elif 'Conj' in formule:\n",
    "        x, y = formule['Conj']\n",
    "        return eval(valeurs, x) and eval(valeurs, y)\n",
    "    elif 'Disj' in formule:\n",
    "        x, y = formule['Disj']\n",
    "        return eval(valeurs, x) or eval(valeurs, y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "eval(valeurs_1, f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "eval(valeurs_2, f)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercice 28"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def extrait_variables_x(formule : dict) -> list:\n",
    "    if 'V' in formule:\n",
    "        return [formule['V']]\n",
    "    elif 'Not' in formule:\n",
    "        return extrait_variables_x(formule['Not'])\n",
    "    elif 'Conj' in formule:\n",
    "        x, y = formule['Conj']\n",
    "        return extrait_variables_x(x) + extrait_variables_x(y)\n",
    "    elif 'Disj' in formule:\n",
    "        x, y = formule['Disj']\n",
    "        return extrait_variables_x(x) + extrait_variables_x(y)\n",
    "\n",
    "# on enlève les doublons\n",
    "def extrait_variables(formule : dict) -> list:\n",
    "    return list(set(extrait_variables_x(formule)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['p', 'r', 'q']"
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "extrait_variables(f)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On trouve facilement les $n$ variables d'une formule.\n",
    "\n",
    "Ensuite, un [`itertools.product`](https://docs.python.org/3/library/itertools.html#itertools.product) permet de générer les $2^n$ valuations."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [],
   "source": [
    "from itertools import product\n",
    "\n",
    "def toutes_valeurs(variables):\n",
    "    for valeurs in product([False, True], repeat=len(variables)):\n",
    "        yield defaultdict(lambda: False, {k:v for k,v in zip(variables, valeurs)})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[defaultdict(<function __main__.toutes_valeurs.<locals>.<lambda>>,\n",
       "             {'p': False, 'q': False, 'r': False}),\n",
       " defaultdict(<function __main__.toutes_valeurs.<locals>.<lambda>>,\n",
       "             {'p': False, 'q': True, 'r': False}),\n",
       " defaultdict(<function __main__.toutes_valeurs.<locals>.<lambda>>,\n",
       "             {'p': False, 'q': False, 'r': True}),\n",
       " defaultdict(<function __main__.toutes_valeurs.<locals>.<lambda>>,\n",
       "             {'p': False, 'q': True, 'r': True}),\n",
       " defaultdict(<function __main__.toutes_valeurs.<locals>.<lambda>>,\n",
       "             {'p': True, 'q': False, 'r': False}),\n",
       " defaultdict(<function __main__.toutes_valeurs.<locals>.<lambda>>,\n",
       "             {'p': True, 'q': True, 'r': False}),\n",
       " defaultdict(<function __main__.toutes_valeurs.<locals>.<lambda>>,\n",
       "             {'p': True, 'q': False, 'r': True}),\n",
       " defaultdict(<function __main__.toutes_valeurs.<locals>.<lambda>>,\n",
       "             {'p': True, 'q': True, 'r': True})]"
      ]
     },
     "execution_count": 103,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(toutes_valeurs(extrait_variables(f)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def str_of_bool(x : bool) -> str:\n",
    "    # return str(int(x))\n",
    "    return '1' if x else '0'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def table_verite(formule : dict) -> None:\n",
    "    variables = extrait_variables(formule)\n",
    "    # D'abord la formule\n",
    "    for k in variables:\n",
    "        print(k, end=' ')\n",
    "    print('| ', end='')\n",
    "    affiche(f)\n",
    "    # Puis toutes ces valeurs possibles\n",
    "    for valeurs in toutes_valeurs(variables):\n",
    "        for k in variables:\n",
    "            print(str_of_bool(valeurs[k]), end=' ')\n",
    "        print('| ', end='')\n",
    "        print(str_of_bool(eval(valeurs, formule)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "p r q | (~p ^ ((q ^ ~p) V (r V q)))\n",
      "0 0 0 | 0\n",
      "0 0 1 | 1\n",
      "0 1 0 | 1\n",
      "0 1 1 | 1\n",
      "1 0 0 | 0\n",
      "1 0 1 | 0\n",
      "1 1 0 | 0\n",
      "1 1 1 | 0\n"
     ]
    }
   ],
   "source": [
    "table_verite(f)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note : ce code est encore plus concis que celui donné dans la solution en Caml.\n",
    "\n",
    "> On peut vérifier, par exemple sur [Wolfram|Alpha](https://www.wolframalpha.com/input/?i=%28%28not+p%29+and+%28%28q+and+%28not+p%29%29+or+%28r+or+q%29%29%29) que l'on obtient bien le bon résultat..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "----\n",
    "\n",
    "# Conclusion\n",
    "\n",
    "Comme vous le voyez, on arrive à répondre aux mêmes questions dans les deux langages, et il n'y a pas de grosses différences en pratique dans la mise en oeuvre.\n",
    "\n",
    "Là où OCaml excelle pour les types définis, le filtrage et la récursion, Python gagne en simplicité sur l'affichage, sa librairie standard et les dictionnaires et ensembles..."
   ]
  }
 ],
 "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.6.9"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {
    "height": "365px",
    "width": "251px"
   },
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": true,
   "toc_position": {
    "height": "523px",
    "left": "0px",
    "right": "1068px",
    "top": "116px",
    "width": "212px"
   },
   "toc_section_display": "block",
   "toc_window_display": true
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}