TP12.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "426e925d",
   "metadata": {},
   "source": [
    "# ITC - MPSI\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6edfb384",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "25defd867d312366e85870995147175b",
     "grade": false,
     "grade_id": "cell-9ff85a4a80d711c8",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "# TP12 : Utilisation d'un module\n",
    "\n",
    "Comme dans beaucoup de langages de programmation, l'installation de base en python contient certaines fonctionnalités, mais il existe des bibliothèques de fonctionnalités qu'on peut utiliser en le spécifiant à l'interpréteur. En `python`, ces bibliothèques s'appellent des _modules_.\n",
    "\n",
    "Vous avez déjà utilisé un module. Comparez l'exécution des deux cellules suivantes (évidemment une fois la deuxième cellule exécutée, la première fonctionnera à son tours) :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c36bf37e",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "288a6b8d01cc0494954d5f09cdd76ead",
     "grade": false,
     "grade_id": "cell-41dcf9e314941fa6",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "math.sqrt(8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "005b60f1",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "e5c5234754f1d2d119b81e7347b75eea",
     "grade": false,
     "grade_id": "cell-2918cfedd15a0e38",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "import math\n",
    "math.sqrt(8)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "959d8dc5",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "69fd04fa1bef4abb52068320c317037d",
     "grade": false,
     "grade_id": "cell-0de7d40f86e33f43",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "Il faut dont spécifier à l'interpréteur `python` qu'on veut utiliser un module avec le mot clef `import`. Ce mot-clef supporte plusieurs syntaxes:\n",
    "```python\n",
    "import math\n",
    "```\n",
    "et ensuite on peut utiliser tout ce qui apparaît dans le module `math` (fonction, variable globale ou autre) en écrivant par exemple `math.cos` ou `math.pi` (nom du module, suivi d'un point, suivi de l'identifiant de ce qui nous intéresse), ou alors\n",
    "```python\n",
    "from math import atan\n",
    "```\n",
    "et ensuite on peut utiliser l'identifiant directement, ici `atan` (sans rappeler le nom du module).\n",
    "\n",
    "La deuxième solution permet de ne pas avoir à réécrire le nom du module, mais a l'inconvénient de ne pas autoriser l'utilisation de fonctions provenant de différents modules et qui auraient le même nom."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5f83fa20",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "1227853ef12fa2cde340fe2610b4d7ed",
     "grade": false,
     "grade_id": "cell-78388d34ef8f2727",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "Pour avoir de la documenation sur une fonction, vous pouvez utiliser la fonction `help` avec en argument le nom de la fonction sur laquelle vous voulez de l'aide, par exemple :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "da9d760c",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "761e733f3f9b9ad7bf3c2cf3940f810f",
     "grade": false,
     "grade_id": "cell-5bdff03a7c06132b",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "help(max)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "08a85c27",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "e03f41302eafe3ed2a2f35bd467121df",
     "grade": false,
     "grade_id": "cell-124b73c1d3a2eeb4",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "Bien sûr, si cette fonction appartient à un module, il faudra d'abord faire l'import nécessaire puis identifier correctement la fonction.\n",
    "\n",
    "`help` peut être utilisée pour sur propres fonctions :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a7352164",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "60236eb952f3e22c10fa0e3c0dd3e5d2",
     "grade": false,
     "grade_id": "cell-019e1164be411bf5",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "def f():\n",
    "    \"\"\"fonction inutile et qui ne prend aucun argument\n",
    "    juste pour tester help\"\"\"\n",
    "    pass\n",
    "\n",
    "help(f)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "18b43827",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "085bbd465979540bf347c01e10f4761d",
     "grade": false,
     "grade_id": "cell-042c0ce9881e5454",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "Dans ce TP, nous allons utiliser un module appelé `ColabTurtlePlus`. Vous allez d'abord l'installer sur votre compte en exécutant la cellule suivante (une fois l'installation faite, le module reste installé, ce n'est pas la peine d'exécuter cette cellule à chaque fois, mais la première fois il faut relancer le noyau une fois l'installation faite) :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "78643c44",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "2e8f7fb5c9a16accc324be838afa7dc7",
     "grade": false,
     "grade_id": "cell-a1c1a54178de2727",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "pip install --user ColabTurtlePlus  ## ceci n'est pas du python"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9faf0ab6",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "edbb1c9b33d804761b4a8675ef57a675",
     "grade": false,
     "grade_id": "cell-90e96bb4e940e562",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "Vous devez ensuite importer la classe `Turtle` du module `ColabTurtlePlus`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "26b19c40",
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "1de7563cdf989d703ce873c2a492d410",
     "grade": false,
     "grade_id": "cell-f474fe7ae80ec0d0",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "## écrivez ici l'import\n",
    "# Écrire votre code ici\n",
    "raise NotImplementedError # effacer cette ligne une fois le code écrit"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "03564eb2",
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "bdd9439f7e54425b38ec51a6a7335f3e",
     "grade": true,
     "grade_id": "cell-20e0c943ddb70d48",
     "locked": false,
     "points": 1,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# Écrire votre code ici\n",
    "raise NotImplementedError # effacer cette ligne une fois le code écrit"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "921c02a4",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "c15c13c49a2d10e60e8ff1288dbb6eb4",
     "grade": false,
     "grade_id": "cell-b342c14fada23eb2",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "Les fonctions d'une classe s'utilisent avec la même syntaxe que les fonctions d'un module: nom de la classe, suivi d'un point, suivi du nom de la fonction. Voici un premier exemple de programme de dessin :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2fe73cfe",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "3c951940129f8d56d262e73954b2d670",
     "grade": false,
     "grade_id": "cell-fe8ad1ff740e95dc",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "Turtle.clearscreen()  ## à mettre au début de chaque nouveau dessin\n",
    "Turtle.delay(0)       ## pour que le dessin commence tout de suite\n",
    "Turtle.speed(10)      ## vitesse : 0 = à l'arrêt, 13 = le plus vite\n",
    "Turtle.setup(300,300) ## dimensions de la fenêtre\n",
    "Turtle.showborder()\n",
    "for i in range(4):\n",
    "  Turtle.forward(100)\n",
    "  Turtle.left(90)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1f304c47",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "fc48d36974de9ecef9dc02b2419e1969",
     "grade": false,
     "grade_id": "cell-bf70e65894384e32",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "### Exercice 1 : Marche aléatoire d'une tortue ivre\n",
    "\n",
    "Pour afficher une tortue plutôt qu'une flèche, il suffit d'utiliser l'appel `Turtle.shape('turtle')`. Écrire et documenter une fonction `marche_aleatoire` qui prend en argument un nombre de pas `n` et fait avancer la tortue de manière erratique : après chaque pas (un pas correspondant à une avancée de 20 unités), vous tirez au hasard l'angle de rotation de votre tortue, sans qu'elle puisse tourner de plus de 90 degré (une tortue ivre ne fait pas de gestes brusques) (fonction `randint` du module `random`)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b7a3c18d",
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "b32bd330060d2c6458e34ed7752bfc30",
     "grade": false,
     "grade_id": "cell-bc19071532b16a8f",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# Écrire votre code ici\n",
    "raise NotImplementedError # effacer cette ligne une fois le code écrit"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "680c4fb8",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "2af06d9e3a8bb07afe3e94b03a6248be",
     "grade": false,
     "grade_id": "cell-f19afd53cc6838d4",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "Vous pouvez maintenant regarder la marche aléatoire de votre tortue :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8e31984a",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "ae8168597dc122899e2755c5cd731390",
     "grade": false,
     "grade_id": "cell-f0dfcae530449841",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "marche_aleatoire(100)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "949c25c5",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "7ef53bc21a96ca662bb3132706ea4fbb",
     "grade": false,
     "grade_id": "cell-f7b7107d79dcc20e",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "### Exercice 2 : Trois chiens qui se poursuivent\n",
    "Dans cet exercice, on considère trois chiens, chacun au sommet d'un triangle équilatéral, et chacun poursuivant le chien sur sa droite. On veut représenter les trajectoires de ces chiens.\n",
    "\n",
    "1. À chaque unité de temps, chaque chien avance d'une unité en direction du chien qu'il poursuit. Écrire et documenter une fonction `avance` qui prend en argument deux listes de deux nombres: la première représente les coordonnées actuelles d'un chien, la deuxième les coordonnées de sa cible (supposées différentes, sans avoir à le vérifier). Cette fonction renvoie les nouvelle coordonnées du chien après une unité de temps, sous la forme d'une liste de deux nombres (rappel : la racine carrée est la fonction `sqrt` du module `math`)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9e8ff3d9",
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "3050d3efa4e14fd24616969ae50ef09b",
     "grade": false,
     "grade_id": "cell-4c1d9b14fcde49ae",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# Écrire votre code ici\n",
    "raise NotImplementedError # effacer cette ligne une fois le code écrit"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "668e52a0",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "fa58c501bd122ec834f8e0dc26eee9bc",
     "grade": true,
     "grade_id": "cell-91088165340166c2",
     "locked": true,
     "points": 2,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "import math\n",
    "\n",
    "epsilon = 0.0000001\n",
    "\n",
    "x, y = avance([0, 0], [1, 0])\n",
    "assert(math.fabs(x-1)<epsilon and math.fabs(y)<epsilon)\n",
    "\n",
    "x, y = avance([0, 0], [0, 1])\n",
    "assert(math.fabs(x)<epsilon and math.fabs(y-1)<epsilon)\n",
    "\n",
    "x, y = avance([0, 0], [1, 1])\n",
    "assert(math.fabs(x-0.7071067811865475)<epsilon and math.fabs(y-0.7071067811865475)<epsilon)\n",
    "\n",
    "x, y = avance([23, 89], [-12, 112])\n",
    "assert(math.fabs(x-22.164294520298725)<epsilon and math.fabs(y-89.54917788666084)<epsilon)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7c341ba2",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "54e7a4f7fe63565e161c99a8caf6106a",
     "grade": false,
     "grade_id": "cell-490387f5151b28a4",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "2. Écrire et documenter une fonction `poursuite_infernale` qui prend en argument une liste de 3 sous-listes représentant les coordonnées initiales des trois chiens et un entier représentant le nombre de pas de la simulation et renvoie une liste contenant 3 listes, chacune composées des coordonnées successives d'un des chiens."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f82b1abc",
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "5e28435c5fbe9526c0bdb4720e3aca64",
     "grade": false,
     "grade_id": "cell-7efc97d8f0fb677b",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# Écrire votre code ici\n",
    "raise NotImplementedError # effacer cette ligne une fois le code écrit"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fc922977",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "7b41d363c79f0e143455998a850626b4",
     "grade": false,
     "grade_id": "cell-52d9682a34a0bcf0",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "3. Pour faire l'animation, je vous fournis une fonction qui prend en argument le résultat de `poursuite_infernale` et effectue l'affichage correspondant. Vous pouvez tester vos fonctions en dessous."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2e7b60a9",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "26558c229af0a5116b2c71cbcfd8ab51",
     "grade": false,
     "grade_id": "cell-207e896964de3da0",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "def trace(trajectoires):\n",
    "    Turtle.clearscreen()\n",
    "    Turtle.setup(400,400)\n",
    "    Turtle.showborder()\n",
    "    chiens = [Turtle.Turtle(), Turtle.Turtle(), Turtle.Turtle()]\n",
    "    for i in range(3):\n",
    "        chiens[i].shape('blank')\n",
    "        chiens[i].delay(0)\n",
    "        chiens[i].speed(13)\n",
    "        chiens[i].jumpto(tuple(trajectoires[i][0]))\n",
    "                  \n",
    "    for k in range(1, len(trajectoires[0])):\n",
    "        for i in range(3):\n",
    "            chiens[i].goto(trajectoires[i][k][0], trajectoires[i][k][1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "11aeb94e",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "6f48fac381019fb66d439aaa58d016c0",
     "grade": false,
     "grade_id": "cell-045ca9b520e149d4",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "r = 200\n",
    "coord_initiales = [[r*math.cos(0), r*math.sin(0)], \n",
    "                   [r*math.cos(2*math.pi/3), r*math.sin(2*math.pi/3)],\n",
    "                   [r*math.cos(4*math.pi/3), r*math.sin(4*math.pi/3)]]\n",
    "trace(poursuite_infernale(coord_initiales, (int)(1.2*r)))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b2ea6266",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "0fda68fc652c42ff58655e5c9ae2a07e",
     "grade": false,
     "grade_id": "cell-45da280be4a32641",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "### Exercice 3 : Courbe du dragon\n",
    "\n",
    "![](dragon10.png)\n",
    "\n",
    "La _courbe du dragon_ peut être représentée par tableau de booléens. Elle est obtenue récursivement de la manière suivante (dans ce qui suit, je mets la suite des valeurs des cases du tableau, avec `F` pour `False` et `T` pour `True`) :\n",
    "\n",
    "* $C_0$ : `F`\n",
    "* $C_{n+1}$ : $C_n$ `F` $\\tilde{C_n}$, où $\\tilde{C}$ est construit à partir de $C$, en prenant le miroir du tableau (=cases lues de droite à gauche) et en inversant `True` et `False`.\n",
    "\n",
    "$\\def\\F{\\text{F}\\,}\n",
    "\\def\\T{\\text{T}\\,}$\n",
    "exemple de passage de $C$ à $\\tilde{C}$ :\n",
    "$$\\underbrace{\\F\\F\\F\\T\\T\\F}_{C} \\xrightarrow{\\text{miroir}} \\F\\T\\T\\F\\F\\F\n",
    "\\xrightarrow{\\text{inversion}} \\underbrace{\\T\\F\\F\\T\\T\\T}_{\\tilde{C\\ }}$$\n",
    "\n",
    "premières valeurs de la courbe du dragon :\n",
    "\n",
    "$$\\begin{array}{lcl}\n",
    "C_1 &=& \\underbrace{\\F}_{C_0} \\F \\underbrace{\\T}_{\\tilde{C_0}}\\\\\n",
    "C_2 &=& \\underbrace{\\F\\F\\T}_{C_1} \\F \\underbrace{\\F\\T\\T}_{\\tilde{C_1}}\\\\\n",
    "C_3 &=& \\underbrace{\\F\\F\\T\\F\\F\\T\\T}_{C_2} \\F \\underbrace{\\F\\F\\T\\T\\F\\T\\T}_{\\tilde{C_2}}\n",
    "\\end{array}$$"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "54f0350e",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "284fbe792a769647bd6ea78d94ede7ec",
     "grade": false,
     "grade_id": "cell-e629d5ca1d1bc784",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "1. Écrire et documenter une fonction `mue` qui prend en argument un tableau de booléens et construit un nouveau tableau en utilisant la transformation décrite au-dessus (le tableau passé en paramètre ne doit pas être modifié). Vous pouvez utiliser :\n",
    "\n",
    "* la fonction `reversed` qui permet d'inverser les éléments d'une liste,\n",
    "* la méthode `extend` qui s'utilise comme `append` mais permet d'étendre une liste avec les éléments d'une autre liste, ainsi après la séquence :\n",
    "\n",
    "```python\n",
    "L = [1, 2, 3]\n",
    "L.extend([9, 8, 7])\n",
    "```\n",
    "\n",
    "`L` vaut `[1, 2, 3, 9, 8, 7]`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c247d056",
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "d0c17bb25efc98a6f564b3a9e34fc15c",
     "grade": false,
     "grade_id": "cell-cb0c073dd359a3a2",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# Écrire votre code ici\n",
    "raise NotImplementedError # effacer cette ligne une fois le code écrit"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4b635623",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "72de94f0f3d380f70e2db730dc15b00c",
     "grade": true,
     "grade_id": "cell-fd314902c7df1e25",
     "locked": true,
     "points": 2,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "dragon = [ False ]\n",
    "assert(mue(dragon) == [False, False, True] and dragon == [False])\n",
    "\n",
    "assert(mue(mue(dragon)) == [False, False, True, False, False, True, True] and dragon == [False])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8b4d7163",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "e9a4ca729f56618d56804181997f955a",
     "grade": false,
     "grade_id": "cell-86c60b85ba1a49d4",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "2. Écrire et documenter une fonction `courbe` qui calcule la $n$-ème courbe du dragon."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ad5c6e33",
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "ea6d1ed2f420eee2af1f66b4b5a59a9f",
     "grade": false,
     "grade_id": "cell-5c152af8e73bbffb",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# Écrire votre code ici\n",
    "raise NotImplementedError # effacer cette ligne une fois le code écrit"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8b4016ee",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "9af42a7835dae78b9ac800cfa09f3219",
     "grade": true,
     "grade_id": "cell-4306e044694ff0d3",
     "locked": true,
     "points": 2,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "assert(courbe(0) == [False])\n",
    "assert(courbe(1) == [False, False, True])\n",
    "assert(courbe(5) == [False, False, True, False, False, True, True, False, False, False, True, True, False, True, True, False, False, False, True, False, False, True, True, True, False, False, True, True, False, True, True, False, False, False, True, False, False, True, True, False, False, False, True, True, False, True, True, True, False, False, True, False, False, True, True, True, False, False, True, True, False, True, True])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b189b9f9",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "a494f0955cb3a27691b266409446a536",
     "grade": false,
     "grade_id": "cell-19e002549614d477",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "3. Pour dessiner la courbe du dragon $C_n$, on part d'un segment unitaire ($((0,0), (u,0))$ par exemple) et on parcourt le tableau obtenu précédemment : à chaque `False`, on tourne à droite (de 90°) et à chaque `True` on tourne à gauche (de 90°), et on avance d'une unité. (La courbe présentée en début d'exercice est $C_{10}$.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d7ad9aa0",
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "7e8584cd33abb528f33472f26d3647b4",
     "grade": false,
     "grade_id": "cell-f2a6393815628455",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# Écrire votre code ici\n",
    "raise NotImplementedError # effacer cette ligne une fois le code écrit"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "75ccfd63",
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "86bf3951c7c71de6ba04f378f734f8c2",
     "grade": true,
     "grade_id": "cell-1155b873f96a29a9",
     "locked": false,
     "points": 2,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# Écrire votre code ici\n",
    "raise NotImplementedError # effacer cette ligne une fois le code écrit"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ebba13b3",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "2e46d0a2cc5ae1ed060e23d92a790134",
     "grade": false,
     "grade_id": "cell-04cd104c53edbfc9",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "dessin(courbe(8), 10)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6f803354",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "47d2b808aafcad606b9312581835b86b",
     "grade": false,
     "grade_id": "cell-464e6ac94e299e55",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "<div class=\"alert alert-success\">\n",
    "    <h2>Les points à retenir</h2>\n",
    "    \n",
    "* comment importer un module (`import module`) puis utiliser une fonction du module (`module.fonction`)\n",
    "* comment importer une fonction spécifique d'un module (`from module import fonction`)\n",
    "* `extend` pour étendre une liste (et comment s'en servir)\n",
    "* utilisation de `help` pour avoir de la documentation sur une fonction\n",
    "</div>"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}