{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "experimental-referral",
   "metadata": {},
   "source": [
    "# TD - Les boucles"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "alive-youth",
   "metadata": {},
   "source": [
    "## 1. Définition\n",
    "\n",
    "Souvent, dans un programme, il est nécessaire de répéter un certain nombre de fois une (ou des) instruction(s). Pour cela, on utilise ce qu'on appelle des __boucles__."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "romance-grounds",
   "metadata": {},
   "source": [
    "### 1.1. Exemple introductif\n",
    "\n",
    "Le nombre d'utilisateurs d'un nouveau réseau social _KILESTBIEN_ est égal à 500 000 en janvier 2020. Ce nombre augmente de 5 % par mois, donc est multiplié par 1.05 chaque mois. Si on veut connaître le nombre d'utilisateurs 10 mois plus tard, il faut effectuer 10 fois de suite le même calcul (une multiplication par 1.05)."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "controlled-construction",
   "metadata": {},
   "source": [
    "### 1.2. À Faire \n",
    "\n",
    "Compléter le programme Python suivant afin d'obtenir le nombre d'utilisateurs du réseau _KILESTBIEN_ au bout de 10 mois.\n",
    "\n",
    "```python\n",
    "nb_utilisateurs = 500000\n",
    "nb_utilisateurs = nb_utilisateurs * 1.05\n",
    "???\n",
    "print(???)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "awful-usage",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "related-harmony",
   "metadata": {},
   "source": [
    "### 1.3. Problématique\n",
    "\n",
    "Des banquiers veulent investir 1 million d'euros dans _KILESTBIEN_, mais ont une exigence. Ils souhaitent que le nombre d'utilisateurs du réseau soit au moins de 3 millions dans 3 ans.\n",
    "\n",
    "Selon le taux de croissance du nombre d'utilisateurs de 5% par mois, vont-ils investir dans _KILESTBIEN_ ? Que faut-il modifier dans le programme précédent pour répondre à cette question ?"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "representative-vertical",
   "metadata": {},
   "source": [
    "## 2. Boucle bornée\n",
    "\n",
    "Au lieu d'écrire 10 ou 36 lignes identiques il est préférable d'écrire une seule fois cette ligne et d'indiquer de l'exécuter 10 ou 36 fois : pour cela, on utilise une __boucle bornée__. En Python, au lieu d'écrire le programme du 1.2., il est possible d'écrire la suite d'instructions suivantes : \n",
    "\n",
    "```python\n",
    "nb_utilisateurs = 500000\n",
    "for i in range(10):\n",
    "    nb_utilisateurs = nb_utilisateurs * 1.05\n",
    "print(nb_utilisateurs)\n",
    "```\n",
    "\n",
    "### À Faire\n",
    "\n",
    "Modifier le code précédent pour répondre à la problématique."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "sublime-frame",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "czech-andrews",
   "metadata": {},
   "source": [
    "### 2.1. Construction d'une boucle bornée\n",
    "\n",
    "Pour écrire une boucle bornée en Python on utilise le mot-clé `for`. Les boucles bornées sont par conséquent très souvent appelées *boucles for* (ou *boucles pour* en français).\n",
    "\n",
    "```python\n",
    "for element in sequence:\n",
    "    bloc_instructions\n",
    "````\n",
    "\n",
    "__Remarques__ :\n",
    "\n",
    "- `element` est une variable créée par le `for`, ce n'est pas à vous de l'instancier. Elle prend successivement chacune des valeurs figurant dans la sequence parcourue,\n",
    "- __ne pas oublier les deux points à la fin de la ligne__ avec `for` qui permettent d'ouvrir le bloc d'instructions à exécuter (à répéter),\n",
    "- les instructions à effectuer sont indentées d'une tabulation par rapport au `for`,\n",
    "- au contraire du pseudo-code, on n'écrit pas en Python de fin pour car celui-ci est matérialisé la fin des indentations."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "olympic-winner",
   "metadata": {},
   "source": [
    "### 2.2. Utilisation de la fonction `range()`\n",
    "\n",
    "- La fonction `range` permet de générer un intervalle sous la forme d'une liste d'entiers. Par exemple, l'appel  `range(n)` génère $n$ entiers : $0, 1, 2, ..., n-1$. \n",
    "- ⚠ Attention : comme le premier entier est 0, le n-ième est numéroté $n - 1$.\n",
    "- La variable notée `i` prendra successivement (à chaque tour de boucle) les valeurs générées par la fonction `range`. Ici, `i` prendra les valeurs 0 puis 1 puis 2, ..., puis $n - 1$.\n",
    "- Le bloc d'instructions à répéter doit être indenté (d'une tabulation) et sera donc ici exécuté $n$ fois."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "searching-journal",
   "metadata": {},
   "source": [
    "#### 2.2.1. À Faire\n",
    "\n",
    "On considère le programme Python suivant.\n",
    "\n",
    "```python\n",
    "a = 2\n",
    "for i in range(4):\n",
    "    a = a + 1\n",
    "    print(a)\n",
    "```\n",
    "\n",
    "1. Quel est le bloc d'instructions répété dans la boucle `for` ?\n",
    "2. Combien de fois est-il répété ?\n",
    "3. Combien de valeurs sont affichées au cours de l'exécution de ce programme ?\n",
    "4. Quelle est la valeur finale de la variable `a` ?"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "broke-warrant",
   "metadata": {},
   "source": [
    "#### 2.2.2. À Faire\n",
    "\n",
    "On considère le programme Python suivant :\n",
    "\n",
    "```python\n",
    "a = 1\n",
    "b = 5\n",
    "for i in range(3):\n",
    "    a = 2 * a\n",
    "    b = b + a\n",
    "print(b)\n",
    "```\n",
    "\n",
    "On va commencer par analyser le code pour le comprendre.\n",
    "\n",
    "1. Quel est le bloc d'instructions répété dans la boucle `for` ? Combien de fois est-il répété ?\n",
    "2. Expliquez pourquoi il n'y a qu'une seule valeur qui s'affiche dans la console si on exécute le code ?\n",
    "3. Recopiez et complétez le tableau ci-dessous avec les valeurs des variables `i`, `a` et `b` à chaque tour de boucle.\n",
    "\n",
    "| `i`  | `a`  |  `b`  |\n",
    "| :--: | :--: | :---: |\n",
    "|      |  1   |   5   |\n",
    "|  0   | ???  | ??? |\n",
    "| ???  | ???  |  ???  |\n",
    "| ???  | ???  |  ???  |\n",
    "\n",
    "4. Quelle est la valeur finale de la variable `b` ?\n",
    "5. Exécutez ensuite le code et vérifiez ce qu'il produit."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "danish-oxide",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "informative-insulation",
   "metadata": {},
   "source": [
    "### 2.3. Boucle bornée sur une chaine de caractères\n",
    "\n",
    "Comme on l'a vu précédemment, il est possible de créer une boucle bornée en utilisant le mot-clé `in` associé au mot clé `range`. Cela permet de répéter les mêmes instructions sur un intervalle.\n",
    "\n",
    "Cette section va nous permettre de voir une autre utilisation de la boucle bornée. En effet, il est possible d'itérer sur tous les éléments de certaines variables en utilisant le mot clé `in` de la façon suivante :\n",
    "\n",
    "```python\n",
    "for element in variable:  # se traduit par \"pour chaque element de variable\"\n",
    "    bloc_instructions\n",
    "```\n",
    "\n",
    "**Remarques** :\n",
    "\n",
    "- `variable` peut être une chaîne de caractères (type `str`) ou une liste (type `list`).\n",
    "- Dans ce cas, la variable `element` prend successivement chacune des valeurs de `variable`."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "abroad-health",
   "metadata": {},
   "source": [
    "#### 2.3.1. Par ses caractères\n",
    "\n",
    "On peut parcourir une chaîne directement par ses caractères."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "acquired-reset",
   "metadata": {},
   "source": [
    "##### 2.3.1.1. À Faire\n",
    "\n",
    "1. Copier et exécuter le code suivant.\n",
    "```python\n",
    "a = \"SNT\"\n",
    "for lettre in a:\n",
    "\tprint(lettre)\n",
    "```\n",
    "2. Quel est le résultat obtenu ?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bacterial-hamburg",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "upper-adjustment",
   "metadata": {},
   "source": [
    "#### 2.3.2. Par l'indice de ses caractères\n",
    "\n",
    "On peut aussi utiliser la fonction `range()` pour parcourir les caractères par leurs indices.\n",
    "\n",
    "##### 2.3.2.1. À Faire\n",
    "\n",
    "1. Copier et exécuter le code suivant.\n",
    "```python\n",
    "a = \"SNT\"\n",
    "for i in range(len(a)):\n",
    "\tprint(a[i])\n",
    "```\n",
    "2. Quel est le résultat obtenu ?"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "strategic-mason",
   "metadata": {},
   "source": [
    "## 3. Exercices"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "artificial-water",
   "metadata": {},
   "source": [
    "### Exercice 1 - La punition\n",
    "\n",
    "L'article 2.2 Les punitions scolaires d'une circulaire ministérielle du 13 Juillet 2000 rappelle qu' « _Il convient également de distinguer soigneusement les punitions relatives au comportement des élèves de l'évaluation de leur travail personnel. Ainsi n'est-il pas permis de baisser la note d'un devoir en raison du comportement d'un élève ou d'une absence injustifiée. Les __lignes et les zéros doivent également être proscrits__._»\n",
    "\n",
    "Votre professeur était élève bien avant cette circulaire et a souvent été puni avec pour sanction le fait de devoir copier 100 fois sur une feuille la phrase suivante : \"_Je ne discuterai plus avec mon camarade de classe pendant les cours_.\"\n",
    "\n",
    "Écrire un programme Python qui permet de facilement retranscrire la punition."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "frozen-cherry",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "daily-richards",
   "metadata": {},
   "source": [
    "### Exercice 2 - Table de Multiplication\n",
    "\n",
    "1. Recopiez le programme suivant :\n",
    "\n",
    "```python\n",
    "nombre = int(input(\"De quel nombre voulez-vous la table de multiplication ? \"))\n",
    "\n",
    "for compteur in range(10):\n",
    "\tprint(nombre)\n",
    "```\n",
    "\n",
    "2. Modifiez ce programme pour qu'il affiche la table de multiplication du nombre demandé, de 0 à 10. Par exemple, si l'utilisateur donne la valeur 6, le programme devrait afficher : 0, 6, 12, 18, …, 60."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "adjustable-serum",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "derived-perfume",
   "metadata": {},
   "source": [
    "### Exercice 3 - Problème de l'échiquier de Sissa\n",
    "\n",
    "Selon [la légende](https://fr.wikipedia.org/wiki/Problème_de_l'échiquier_de_Sissa), pour remercier l'inventeur des échecs Sissa, le roi lui demanda de choisir sa récompense. Sissa demanda alors du riz : __un grain sur la première case, deux grains sur la seconde case, quatre grains sur la troisième case, huit grains sur la quatrième, et ainsi de suite jusqu'à la dernière case du jeu d'échec__. Le roi accepta.\n",
    "\n",
    "On se demande combien de grains seront posés sur la dernière case du plateau d'échecs (qui en compte 64).\n",
    "\n",
    "Pour résoudre ce problème, on peut utiliser le programme suivant :\n",
    "\n",
    "```python\n",
    "grains = 1\n",
    "\n",
    "for compteur in range(???):\n",
    "    grains = ???\n",
    "\n",
    "print(\"Nombre de grains sur la dernière case :\", grains)\n",
    "```\n",
    "\n",
    "1. Compléter ce programme, et exécutez-le.\n",
    "2. Combien de grains de riz y aura-t-il sur la dernière case de l'échiquier ?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "breeding-stack",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "north-diabetes",
   "metadata": {},
   "source": [
    "### Exercice 4 - Petite tortue qui dessine\n",
    "\n",
    "Le module `turtle` (*tortue*) permet de dessiner avec Python.\n",
    "\n",
    "Dans cet exercice on veut écrire un programme qui permet de dessiner des formes géométriques. Voici le code incomplet du programme.\n",
    "\n",
    "```python\n",
    "import turtle  # pour utiliser le module turtle\n",
    "\n",
    "\"\"\"Fonction qui dessine un carré de coté 100 pixels\"\"\"\n",
    "turtle.forward(100)  # pour avancer de 100 pixels\n",
    "turtle.left(90)  # pour tourner de 90° à gauche\n",
    "turtle.forward(100)\n",
    "turtle.left(90)\n",
    "# À Compléter\n",
    "\n",
    "turtle.done()  # pour afficher le dessin\n",
    "```\n",
    "1. Modifiez le programme afin que la tortue dessine un `carré`, en utilisant une boucle `for`.\n",
    "2. Modifiez le programme afin que la tortue dessine un `triangle`, en utilisant une boucle `for`.\n",
    "3. Modifiez le programme afin que la tortue dessine un `octogone`, en utilisant une boucle `for`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "capital-minnesota",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "human-accommodation",
   "metadata": {},
   "source": [
    "## 4. Compléments sur la fonction range\n",
    "\n",
    "Dans les paramètres de la fonction `range` il est également possible de préciser une première valeur (si on ne veut pas commencer à zéro) ainsi que le pas (si on ne veut pas que les itérations se fassent de 1 en 1).\n",
    "\n",
    "Après avoir regardé la [vidéo](https://www.youtube.com/watch?v=07IGOcpiE7o), répondez aux questions qui suivent. Vous vérifierez ensuite en utilisant un éditeur de code Python."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "phantom-presentation",
   "metadata": {},
   "source": [
    "1. Quelles sont les valeurs affichées dans la console lors de l'exécution de chacun des programmes ci-dessous ? *Attention, il faut répondre sans exécuter le code !*\n",
    "\n",
    "2. - Programme 1 :\n",
    "\n",
    "     ```python\n",
    "     for i in range(10):\n",
    "         print(i)\n",
    "     ```\n",
    "   - Programme 2 :\n",
    "\n",
    "     ```python\n",
    "     for k in range(2, 10):\n",
    "         print(k)\n",
    "     ```\n",
    "   - Programme 3 :\n",
    "\n",
    "     ```python\n",
    "     for ind in range(2, 10, 3):\n",
    "         print(ind)\n",
    "     ```\n",
    "\n",
    "3. Exécutez successivement les trois codes et vérifiez vos réponses à la question précédente."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "saving-conducting",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "brutal-password",
   "metadata": {},
   "source": [
    "## 5. Boucle non bornée\n",
    "\n",
    "## 5.1 Retour à l'exemple introductif\n",
    "\n",
    "Bien que l'exigence d'obtenir 3 millions d'utilisateurs dans 3 ans avec un taux de croissance de 5% par mois n'est pas satisfaite, les banquiers donnent une deuxième chance à _KILESTBIEN_.\n",
    "\n",
    "Ils souhaitent connaitre exactement quel sera le nombre de mois nécessaires pour que le nombre d'utilisateurs atteignent 7 millions d'utilisateurs, avec un taux de croissance à 4% par mois.\n",
    "\n",
    "Ils investirons 1 million d'euros seulement si la barre des 7000000 d'utilisateurs est atteinte dans les 5 ans.\n",
    "\n",
    "Ici, nous ne connaissons pas le nombre de mois, impossible d'utiliser une boucle bornée...par contre, il est possible de partir du premier mois et de calculer le nombre d'utilisateurs croissant...__tant qu'__il n'atteint pas 7 millions !\n",
    "\n",
    "### À Faire\n",
    "\n",
    "Modifier le code suivant pour répondre à la problématique.\n",
    "\n",
    "```\n",
    "nb_utilisateurs = 500000\n",
    "nb_mois = 0\n",
    "while nb_utilisateurs < 3000000:\n",
    "    nb_utilisateurs = nb_utilisateurs * 1.05\n",
    "    nb_mois = nb_mois + 1\n",
    "print(nb_mois)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "expensive-kenya",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "thirty-bibliography",
   "metadata": {},
   "source": [
    "## 5.2 Construction d'une boucle non bornée\n",
    "\n",
    "En Python, les boucles \"Tant que\" se codent en utilisant l'instruction while :\n",
    "\n",
    "```\n",
    "while condition:\n",
    "    bloc_instructions\n",
    "```\n",
    "\n",
    "__Remarques__ :\n",
    "\n",
    "- `condition` est une __variable booléenne__ qui est soit vraie (True) soit fausse (False),\n",
    "- Tant que `condition` vaut True les instructions du bloc sont répétées,\n",
    "- On passe à la suite du programme dès que condition vaut False. Cela signifie que si condition reste vraie tout le temps, la boucle `while` boucle à l'infini, ce qui pourra causer des problèmes plus ou moins importants,\n",
    "- Ne pas oublier les deux points à la fin de la ligne avec while qui permettent d'ouvrir le bloc d'instructions à exécuter (à répéter),\n",
    "- les instructions à effectuer sont indentées d'une tabulation par rapport au `while`."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "ethical-director",
   "metadata": {},
   "source": [
    "### 5.2.1. À Faire\n",
    "\n",
    "Copier et exécuter le code suivant.\n",
    "\n",
    "\n",
    "```python\n",
    "a = 3\n",
    "while a < 14:\n",
    "    a = a + 2\n",
    "    print(a) # pour voir l'évolution de la variable a\n",
    "```\n",
    "\n",
    "1. Quel est le résultat obtenu ?\n",
    "2. Combien d'itérations ont-elles été nécessaires pour que la boucle se termine ?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "authorized-applicant",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "adjusted-arthritis",
   "metadata": {},
   "source": [
    "## 6. Exercices"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "wrapped-compound",
   "metadata": {},
   "source": [
    "### Exercice 5 - Final Countdown\n",
    "\n",
    "Écrire un programme, utilisant une boucle non bornée et affiche un décompte. La valeur de `départ` est égale à 10. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "african-rings",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "introductory-salon",
   "metadata": {},
   "source": [
    "### Exercice 6 - Divisions successives\n",
    "\n",
    "Proposer un programme qui utilise une boucle `Tant que` qui a pour but d'afficher les restes successifs de la division entière d'un entier naturel $a$ par un entier naturel $b$.\n",
    "\n",
    "Vous pouvez tester votre programme en prenant comme valeurs :\n",
    "\n",
    "- $a$ = 21, $b$ = 10\n",
    "- $a$ = 21, $b$ = 2\n",
    "- $a$ = 64, $b$ = 2\n",
    "- $a$ = 64, $b$ = 16\n",
    "\n",
    "En lisant le résultat obtenu, que permet de faire ce programme ?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "under-nursery",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "retained-witch",
   "metadata": {},
   "source": [
    "### Exercice 7 - Indice\n",
    "\n",
    "Écrire un programme qui étant donné une variable `nom` égale au vôtre, stocke l'indice de la première voyelle dans une variable `indice`.\n",
    "\n",
    "__Exemple__ :\n",
    "```python\n",
    "nom = \"MATHIEU\"\n",
    "# \n",
    "# code du programme\n",
    "# \n",
    "indice = 1 # A est la première lettre du nom. Elle se trouve à l'indice 1\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "extraordinary-priest",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "still-joshua",
   "metadata": {},
   "source": [
    "### Exercice 8 - Retour de la tortue\n",
    "\n",
    "En reprenant les fonctions `forward`, `left`et `done` de la tortue, vus à l'exercice 4, décriver un programme permettant d'obtenir la figure suivante :\n",
    "\n",
    "La solution peut s'écrire sous la forme de l'algorithme suivant :\n",
    "\n",
    "```txt\n",
    "Tant que longueur > 0 \n",
    "\tla tortue avance sur une distance de longueur\n",
    "\tla tortue tourne de 90° à gauche\n",
    "\tlongueur diminue de 10\n",
    "Fin du tant que\n",
    "```\n",
    "\n",
    "Etes vous certain que la boucle s'arrête à un moment donné ? Pourquoi ?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "neutral-burden",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "assumed-freight",
   "metadata": {},
   "source": [
    "### Exercice 9 - Re-Retour de la tortue\n",
    "\n",
    "Ici, il s'agit de tracer une spirale, mais à la différence de l'exercice précédent, la longueur décroit de 10% à chaque itération.\n",
    "\n",
    "La solution peut s'écrire sous la forme de l'algorithme suivant :\n",
    "\n",
    "```txt\n",
    "Tant que longueur > 0 \n",
    "\tla tortue avance sur une distance de longueur\n",
    "\tla tortue tourne de 90° à droite\n",
    "\tlongueur est multipliée par 0.9 # Décroissance de 10% à chaque itération\n",
    "Fin du tant que\n",
    "```\n",
    "\n",
    "Implanter l'algorithme en Python et exécuter le.\n",
    "\n",
    "Que se passe-t-il ? Pourquoi ? Modifier le code pour y remédier."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "geological-sampling",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.9.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
