NSIT_e99a_sujet0_ex1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"width:100%;border-collapse:separate;border:solid 2px;border-radius:14px;\">\n",
    "    <div style=\"display:flex;\">\n",
    "        <div style=\"display:inline;width:5%;\"></div>\n",
    "        <div style=\"display:inline;width:15%;\">NSIT</div>\n",
    "        <div style=\"display:inline;width:15%;\">e99a</div>\n",
    "        <div style=\"display:inline;width:70%;text-align:right;\"><b>Bachotage</b></div>\n",
    "        <div style=\"display:inline;width:5%;\"></div>\n",
    "    </div>\n",
    "    <div  style=\"display: flex;background-color:#EEE\">\n",
    "        <p style=\"width:100%;text-align:center;\">Sujet 0: 2020-2021 </p>\n",
    "    </div>\n",
    "    <div  style=\"display: flex;\">\n",
    "        <p style=\"width:100%;text-align:center;\">Correction de l'exercice 1: Le crêpier psycho-rigide</p>\n",
    "    </div>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class = \"alert alert-success\">\n",
    "    \n",
    "**Objectifs de la séquence:** \n",
    "- Proposer des programmes répondant aux questions de l'exercice 1 qui fait référence au problème classique du crêpier psycho-rigide\n",
    "- Approfondir l'exercice avec une seconde implémentation du type pile (POO)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from IPython.display import YouTubeVideo\n",
    "YouTubeVideo('o6-4g4I6mOg', width = 800, height = 600)\n",
    "# Vidéo explicative de l'Inria d'une version de ce problème (ici, les crêpes ont un sens): Voir à partir de 2min00s"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class = \"alert alert-info\">\n",
    "    \n",
    "**Sommaire :**\n",
    "\n",
    "<a href=#Q1>Question 1:</a> Premières manipulations sur les primitives  \n",
    "<a href=#Q2>Question 2:</a> Hauteur de la pile et maximum d'une partie de la pile  \n",
    "<a href=#Q3>Question 3:</a> Retourner une partie de la pile  \n",
    "<a href=#Q4>Question 4:</a> Trier une pile de crêpes  \n",
    "<a href=#A1>Approfondissement 1:</a> Implémentation d'une pile en POO\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div id=\"Q1\"></div>\n",
    "\n",
    "## Question 1: Premières manipulations sur les primitives"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![ennonce_ex_1](https://github.com/ebuonocore/NSIT_99_bachotage/blob/main/NSIT_99a_2020_2021_sujet0/sources/ex_1_q1_primitives_pile.png?raw=true)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pour faire foncitonner les programmes on propose ici une programmation fonctionnelle des piles.  \n",
    "Cette implémentation repose sur une liste. Elle est compatible avec les primitives données dans l'énoncé:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def creer_pile_vide():\n",
    "    return [] #Renvoie une liste vide\n",
    "\n",
    "def est_vide(pile):\n",
    "    return len(pile)==0 #Renvoie True si la pile est vide, sinon False\n",
    "\n",
    "def empiler(pile, valeur):\n",
    "    pile.append(valeur) #Ajoute valeur en bout de liste. Ce qui correspond au haut de la pile\n",
    "\n",
    "def depiler(pile):\n",
    "    return pile.pop() #Renvoie le dernier élément de la liste après l'avoir supprimé\n",
    "\n",
    "def afficher(pile): # Assez vilain pour des éléments inférieurs à -9999 et supérieurs à 99999\n",
    "    for i in range(len(pile)): #Parcourt tous les éléments de la liste et les affiche\n",
    "        print('|\\t', pile[-i-1],'\\t|')\n",
    "    for i in range(17):\n",
    "        print(\"-\", end=\"\")\n",
    "    print()\n",
    "    print()\n",
    "\n",
    "# Test des primitives et de l'affichage\n",
    "P = creer_pile_vide()\n",
    "empiler(P, 8)\n",
    "empiler(P, 5)\n",
    "empiler(P, 2)\n",
    "empiler(P, 3)\n",
    "depiler(P)\n",
    "empiler(P, 4)\n",
    "afficher(P)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Réponse à la question 1\n",
    "Q = creer_pile_vide()\n",
    "print(\"Avant l'exécution du code\")\n",
    "print(\"Contenu de la pile P:\")\n",
    "afficher(P)\n",
    "print(\"Contenu de la pile Q:\")\n",
    "afficher(Q)\n",
    "\n",
    "while not est_vide(P):\n",
    "    empiler(Q, depiler(P)) \n",
    "\n",
    "print(\"\\nAprès l'exécution du code\")\n",
    "print(\"Contenu de la pile P:\")\n",
    "afficher(P)\n",
    "print(\"Contenu de la pile Q:\")\n",
    "afficher(Q)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div id=\"Q2\"></div>\n",
    "\n",
    "## Question 2: Hauteur de la pile et maximum d'une partie de la pile\n",
    "\n",
    "On appelle hauteur d’une pile le nombre d’éléments qu’elle contient.  \n",
    "La fonction <code>hauteur_pile</code> prend en paramètre une pile P et renvoie sa hauteur.  \n",
    "Après appel de cette fonction, la pile P doit avoir retrouvé son état d’origine.  \n",
    "**Exemple :** si P est la pile de la question 1 : hauteur_pile(P) = 4."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Question 2.1: hauteur_pile()\n",
    "def hauteur_pile (P):\n",
    "    Q = creer_pile_vide()\n",
    "    n = 0\n",
    "    while not (est_vide(P)):\n",
    "        n = n + 1 # Ligne complétée: On incrémente le compteur\n",
    "        x = depiler(P)\n",
    "        empiler(Q, x)\n",
    "    while not(est_vide(Q)):\n",
    "        x = depiler(Q) # Ligne complétée: La valeur dépilée depuis la pile Q est stockée en x\n",
    "        empiler(P, x)\n",
    "    return n # Ligne complétée: Renvoie la valeur du compteur n qui correspond au nombre d'éléments transférés\n",
    "print(\"Hauteur de la pile Q:\",hauteur_pile(Q))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Créer une fonction <code>max_pile</code> ayant pour paramètres une pile P et un entier i.  \n",
    "Cette fonction renvoie la position j de l’élément maximum parmi les i derniers éléments empilés de la pile P.  \n",
    "Après appel de cette fonction, la pile P devra avoir retrouvé son état d’origine.  \n",
    "La position du sommet de la pile est 1.  \n",
    "**Exemple :** si P est la pile de la question 1 : max_pile(P, 2) = 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Question 2.2: max_pile()\n",
    "P = creer_pile_vide()\n",
    "empiler(P, 8)\n",
    "empiler(P, 5)\n",
    "empiler(P, 2)\n",
    "empiler(P, 4)\n",
    "\n",
    "def max_pile(P, i):\n",
    "    assert i <= hauteur_pile(P), \"La pile compte moins de i éléments\"\n",
    "    # Initialisation\n",
    "    rang = 1 # L'indice de l'élément en cours de traitement\n",
    "    rang_maxi = 1 # le rang du maximum en cours\n",
    "    maxi = depiler(P) # au début, le maximum est le premier élément ...\n",
    "    empiler(P, maxi) # ... que l'on rempile immédiatement\n",
    "    Q = creer_pile_vide() # une pile vide pour stocker les éléments traités\n",
    "    # On lit tous les éléments jusqu'au i-ième pour trouver le maximum\n",
    "    while rang <= i:\n",
    "        x = depiler(P)\n",
    "        if x > maxi:\n",
    "            maxi = x\n",
    "            rang_maxi = rang\n",
    "        empiler(Q, x)\n",
    "        rang += 1\n",
    "    # On reconstitue la pile P\n",
    "    while not(est_vide(Q)):\n",
    "        empiler(P, depiler(Q))\n",
    "    return rang_maxi\n",
    "\n",
    "afficher(P)\n",
    "for profondeur_max in range(1, hauteur_pile(P)+1):\n",
    "    print(\"Indice du maximum des\",profondeur_max,\"plus hauts éléments de P:\",max_pile(P,profondeur_max))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div id=\"Q3\"></div>\n",
    "\n",
    "## Question 3:  Retourner une partie de la pile\n",
    "Créer une fonction <code>retourner</code> ayant pour paramètres une pile P et un entier j.  \n",
    "Cette fonction inverse l’ordre des j derniers éléments empilés et ne renvoie rien.  \n",
    "On pourra utiliser deux piles auxiliaires."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Question 3: retrouner()\n",
    "\n",
    "def retourner(P, j):\n",
    "    assert j <= hauteur_pile(P), \"La pile compte moins de j éléments\"\n",
    "    # Initialisation\n",
    "    Q = creer_pile_vide() # une pile vide pour vider P\n",
    "    R = creer_pile_vide() # une pile vide pour vider Q\n",
    "    rang = 1 # le rang de l'élément en cours de traitement\n",
    "    # On dépile les j premiers éléments dans Q\n",
    "    while rang <= j:\n",
    "        empiler(Q, depiler(P))\n",
    "        rang += 1\n",
    "    # On vide Q dans R\n",
    "    while not(est_vide(Q)):\n",
    "        empiler(R, depiler(Q))\n",
    "    # On vide R dans P\n",
    "    while not(est_vide(R)):\n",
    "        empiler(P, depiler(R))\n",
    "    # La fonction ne renvoie rien (en réalité None en python)\n",
    "    # On peut tout aussi bien se passer de retour\n",
    "    # ce qui aura le même effet lors de l'exécution\n",
    "    return None\n",
    "\n",
    "retourner(P, 3)\n",
    "afficher(P)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div id=\"Q4\"></div>\n",
    "\n",
    "## Question 4:  Trier une pile de crêpes \n",
    "L’objectif de cette question est de trier une pile de crêpes.  \n",
    "On modélise une pile de crêpes par une pile d’entiers représentant le diamètre de chaque crêpe.  \n",
    "On souhaite réordonner les crêpes de la plus grande (placée en bas de la pile) à la plus petite (placée en haut de la pile).  \n",
    "On dispose uniquement d’une spatule que l’on peut insérer dans la pile de crêpes de façon à retourner l’ensemble des crêpes qui lui sont au-dessus.  \n",
    "Le principe est le suivant :  \n",
    "— On recherche la plus grande crêpe.  \n",
    "— On retourne la pile à partir de cette crêpe de façon à mettre cette plus grande crêpe tout en haut de la pile.  \n",
    "— On retourne l’ensemble de la pile de façon à ce que cette plus grande crêpe se retrouve tout en bas.  \n",
    "— La plus grande crêpe étant à sa place, on recommence le principe avec le reste de la pile.  \n",
    "**Exemple :**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![ex_1_q4_00](https://github.com/ebuonocore/NSIT_99_bachotage/blob/main/NSIT_99a_2020_2021_sujet0/sources/ex_1_q4_tri_crepes.png?raw=true)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Créer la fonction tri_crepes ayant pour paramètre une pile P.  \n",
    "Cette fonction trie la pile P selon la méthode du tri crêpes et ne renvoie rien.  \n",
    "On utilisera les fonctions créées dans les questions précédentes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "P = creer_pile_vide()\n",
    "empiler(P, 7)\n",
    "empiler(P, 14)\n",
    "empiler(P, 12)\n",
    "empiler(P, 5)\n",
    "empiler(P, 8)\n",
    "\n",
    "print(\"Avant l'exécution du tri\")\n",
    "print(\"Contenu de la pile P:\")\n",
    "afficher(P)\n",
    "\n",
    "# Question 4: tri_crepes()\n",
    "def tri_crepes(P) :\n",
    "    assert not est_vide(P), \"Il n'y a pas de crêpe à trier !\"\n",
    "    h = hauteur_pile(P)\n",
    "    for i in range(0, h-1):\n",
    "        rang_maxi = max_pile(P, h-i)\n",
    "        retourner(P, rang_maxi)\n",
    "        afficher(P) # Placer en commentaire pour ne pas voir les étapes intermédiaires\n",
    "        retourner(P, h-i)\n",
    "        afficher(P) # Placer en commentaire pour ne pas voir les étapes intermédiaires\n",
    "    # La fonction ne renvoie rien (en réalité None en python)\n",
    "    # On peut tout aussi bien se passer de retour\n",
    "    # ce qui aura le même effet lors de l'exécution\n",
    "    return None\n",
    "\n",
    "tri_crepes(P)\n",
    "print(\"\\nAprès l'exécution du tri\")\n",
    "print(\"Contenu de la pile P:\")\n",
    "afficher(P)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div id=\"A1\"></div>\n",
    "\n",
    "## Approfondissement 1: Implémentation d'une pile en POO\n",
    "\n",
    "Nous nous propospns maintenant de traiter le même problème avec une autre implémentation des piles en programmation orientée objet.  \n",
    "Une instances de la classe Pile (non-vide) est constitué de maillons.  \n",
    "Les instances de la classe Maillon ont 2 attributs: une valeur et un pointeur vers le maillon plus bas dans la pile (ou sur None s'il n'y a pas de suivant).\n",
    "Voici une représentation par Python Tutor de la pile T créée plus bas:\n",
    "\n",
    "![Python_tutor_implementation_POO](https://github.com/ebuonocore/NSIT_99_bachotage/blob/main/NSIT_99a_2020_2021_sujet0/sources/ex_1_a1_POO.png?raw=true)\n",
    "Et ici une description des deux classes mises en jeu:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"width:100%\">\n",
    "    <div style=\"display:inline-flex;width:49%\">\n",
    "        <table style=\"width:200px;\">\n",
    "            <tr>\n",
    "                <td style=\"width:200px;background-color:#CCD;text-align:left\">\n",
    "                    <big>\n",
    "                    <b>Maillon</b>\n",
    "                    </big>\n",
    "                </td>\n",
    "            </tr> \n",
    "            <tr>\n",
    "                <td style=\"width:200px;background-color:#EEF;text-align:left\">\n",
    "                    <big>\n",
    "                    <i><u>Attributs :</u></i><br>\n",
    "                    valeur<br>\n",
    "                    suivant<br>\n",
    "                    </big>\n",
    "                </td>\n",
    "            </tr> \n",
    "            <tr>\n",
    "                <td style=\"width:200px;background-color:#CCD;text-align:left\">\n",
    "                    <big>\n",
    "                    <i><u>Méthodes:</u></i><br>\n",
    "                    </big>\n",
    "                </td>\n",
    "            </tr> \n",
    "        </table>\n",
    "    </div>\n",
    "    <div style=\"display:inline-flex;width:49%\">\n",
    "        <table style=\"width:200px\">\n",
    "            <tr>\n",
    "                <td style=\"width:200px;background-color:#CCD;text-align:left\">\n",
    "                    <big>\n",
    "                    <b>Pile</b>\n",
    "                    </big>\n",
    "                </td>\n",
    "            </tr> \n",
    "            <tr>\n",
    "                <td style=\"width:200px;background-color:#EEF;text-align:left\">\n",
    "                    <big>\n",
    "                    <i><u>Attributs :</u></i><br>\n",
    "                    sommet<br>\n",
    "                    </big>\n",
    "                </td>\n",
    "            </tr> \n",
    "            <tr>\n",
    "                <td style=\"width:200px;background-color:#CCD;text-align:left\">\n",
    "                    <big>\n",
    "                    <i><u>Méthodes:</u></i><br>\n",
    "                    est_vide()<br>                  \n",
    "                    empiler()<br>\n",
    "                    depiler()<br>\n",
    "                    hauteur_pile()<br>\n",
    "                    max_pile()<br>\n",
    "                    retourner()<br>\n",
    "                    tri_crepes()<br>\n",
    "                    </big>\n",
    "                </td>\n",
    "            </tr> \n",
    "        </table>\n",
    "    </div>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Maillon:\n",
    "    def __init__(self, valeur, suivant=None):\n",
    "        self.valeur = valeur\n",
    "        self.suivant = suivant\n",
    "\n",
    "class Pile:\n",
    "    def __init__(self): # Equivalent à creer_pile_vide()\n",
    "        self.sommet = None\n",
    "        \n",
    "    def est_vide(self):\n",
    "        return self.sommet is None\n",
    "        \n",
    "    def empiler(self, valeur):\n",
    "        self.sommet = Maillon(valeur, self.sommet)\n",
    "\n",
    "    def depiler(self):\n",
    "        if self.est_vide() ==  False:\n",
    "            valeur = self.sommet.valeur\n",
    "            self.sommet = self.sommet.suivant\n",
    "            return valeur\n",
    "    \n",
    "    def hauteur_pile(self):\n",
    "        pass\n",
    "    \n",
    "    def max_pile(self, i):\n",
    "        pass\n",
    "\n",
    "    def retourner(self, j):\n",
    "        pass\n",
    "    \n",
    "    def tri_crepes(self):\n",
    "        pass\n",
    "    \n",
    "    def __str__(self):\n",
    "        ch = \"\"\n",
    "        sommet = self.sommet\n",
    "        while sommet != None:\n",
    "            ch += \"|\\t\" + str(sommet.valeur) + \"\\t|\" + \"\\n\"\n",
    "            sommet = sommet.suivant\n",
    "        ch += \"-\"*17\n",
    "        return ch\n",
    "\n",
    "# Pile test T\n",
    "T = Pile()\n",
    "T.empiler(1)\n",
    "T.empiler(2)\n",
    "T.empiler(3)\n",
    "T.depiler()\n",
    "T.empiler(4)\n",
    "T.empiler(5)\n",
    "T.empiler(6)\n",
    "print(T)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "a) Créez la pile P telle que décrite dans l'exercice 1 (Elle contient les valeurs 8, 5, 2 et 4)  \n",
    "<div style=\"display:inline-flex;width:100px\">&#x1F511; <a href=\"https://github.com/ebuonocore/NSIT_99_bachotage/blob/main/NSIT_99a_2020_2021_sujet0/corrections/ex1_a_aide\">Aide</a></div>\n",
    "<div style=\"display:inline-flex;width:100px\">&#x2705; <a href=\"https://github.com/ebuonocore/NSIT_99_bachotage/blob/main/NSIT_99a_2020_2021_sujet0/corrections/ex1_a.txt\">Correction</a></div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "...\n",
    "print(P)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "b) Modifiez la classe Pile (à la place du pass): Implémentez la méthode <code>hauteur_pile()</code>  \n",
    "Inspirez-vous de la question 2  \n",
    "<div style=\"display:inline-flex;width:100px\">&#x1F511; <a href=\"https://github.com/ebuonocore/NSIT_99_bachotage/blob/main/NSIT_99a_2020_2021_sujet0/corrections/ex1_b_aide\">Aide</a></div>\n",
    "<div style=\"display:inline-flex;width:100px\">&#x2705; <a href=\"https://github.com/ebuonocore/NSIT_99_bachotage/blob/main/NSIT_99a_2020_2021_sujet0/corrections/ex1_b.txt\">Correction</a></div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(P.hauteur_pile())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "c) Modifiez la classe Pile (à la place du pass): Implémentez la méthode <code>max_pile()</code>\n",
    "Inspirez-vous de la question 2  \n",
    "<div style=\"display:inline-flex;width:100px\">&#x2705; <a href=\"https://github.com/ebuonocore/NSIT_99_bachotage/blob/main/NSIT_99a_2020_2021_sujet0/corrections/ex1_c.txt\">Correction</a></div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for profondeur_max in range(1, P.hauteur_pile()+1):\n",
    "    print(\"Indice du maximum des\",profondeur_max,\"plus hauts éléments de P:\",P.max_pile(profondeur_max))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "d) Modifiez la classe Pile (à la place du pass): Implémentez la méthode <code>retourner()</code>\n",
    "Inspirez-vous de la question 3  \n",
    "<div style=\"display:inline-flex;width:100px\">&#x2705; <a href=\"https://github.com/ebuonocore/NSIT_99_bachotage/blob/main/NSIT_99a_2020_2021_sujet0/corrections/ex1_d.txt\">Correction</a></div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "P.retourner(4)\n",
    "print(P)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "e) Modifiez la classe Pile (à la place du pass): Implémentez la méthode <code>tri_crepes()</code>\n",
    "Inspirez-vous de la question 4   \n",
    "<div style=\"display:inline-flex;width:100px\">&#x2705; <a href=\"https://github.com/ebuonocore/NSIT_99_bachotage/blob/main/NSIT_99a_2020_2021_sujet0/corrections/ex1_e.txt\">Correction</a></div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "C = Pile()\n",
    "C.empiler(7)\n",
    "C.empiler(14)\n",
    "C.empiler(12)\n",
    "C.empiler(5)\n",
    "C.empiler(8)\n",
    "print(\"Avant le tri\")\n",
    "print(C)\n",
    "C.tri_crepes()\n",
    "print(\"Après le tri\")\n",
    "print(C)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "<p style=\"font-family:Comic Sans MS; text-align: center; color:gray; font-size: x-small; \">- Eric Buonocore. Janvier 2021 -<br></p>\n",
    "\n",
    "![Licence CC BY NC SA](https://licensebuttons.net/l/by-nc-sa/3.0/88x31.png)\n",
    "<p style=\"font-family:Comic Sans MS; text-align: center; color:gray; font-size: x-small; \">D'après la correction proposée par Nicolas Revéret<br></p>"
   ]
  }
 ],
 "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.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}