{"cells":[{"metadata":{},"cell_type":"markdown","source":"<div style=\"padding:20px;background-color:papayawhip;\" > \n<h3 style=\"color:chocolate\"> <i class=\"fa fa-info\" aria-hidden=\"true\"> </i> Remarque introductive <i class=\"fa fa-info\" aria-hidden=\"true\"></h3> \n<p> Ce fichier est fait pour être lu sur le site <a href=\"https://notebook.basthon.fr/\"><img src='https://notebook.basthon.fr/assets/efede5218c9087496f16.png' style=\"border: 0; display:inline; margin: 0 5px; height:30px\" alt=\"Basthon\"/></a>. <br>\n \nSi vous l'avez ouvert avec un autre programme, comme Jupyter notebook, vous riquez de rencontrer quelques bugs. <br>\nVeuillez cliquez sur <a href=\"https://notebook.basthon.fr/\">ce lien</a> et y charger ce fichier à l'aide du bouton \"Ouvrir\" <i class=\"fa fa-folder\" aria-hidden=\"true\"> </i>\n</p> </div> "},{"metadata":{},"cell_type":"markdown","source":"# 7 - Boucle `while`\n\nDans ce chapitre, nous découvrons un deuxième type de boucle, la boucle `while`. Elle est souvent utilisée pour attendre quelque chose. Nous allons voir que :\n\n- la boucle `while` répète aussi longtemps qu'une condition est vraie,\n- le mot-clé `break` permet de sortir de la boucle.\n\n## Boucles « tant que »\nNous avons déjà rencontré d'une part la structure de la boucle `for`, qui permet d'effectuer un nombre prédéfini d'itérations d'un bloc d'instructions, et d'autre part le branchement conditionnel `if`, qui permet d'exécuter ou non un bloc d'instructions en fonction d'un test effectué sur le moment.\n\nLes boucles « tant que », ou boucle `while`, combinent ces deux principes d'une nouvelle manière en conditionnant la poursuite des itérations à un test effectué préalablement à chaque tour de boucle."},{"metadata":{},"cell_type":"markdown","source":"<h3 style=\"color:chocolate;background-color:papayawhip;\" > <i class=\"fa fa-question\" aria-hidden=\"true\"> </i> Quizz </h3> \n \n```\nEn Python, while permet de réaliser :\n\nA) une fonction\nB) une condition\nC) une boucle\nD) aucune des réponses précédentes\n```"},{"metadata":{},"cell_type":"raw","source":"Ma réponse: "},{"metadata":{},"cell_type":"markdown","source":"<details>\n<summary style=\"border-left:3px solid #3c763d; border-radius:2pt; width:100%; color:#3c763d; padding:6px; background-color: #dff0d8\"> \nRéponse\n</summary> \n\n<div style=\"border-left:3px solid #3c763d; border-radius:2pt; color:#3c763d; padding:6px; background-color: #eff0e8\">C) une boucle\n</div>\n</details>\n \n"},{"metadata":{},"cell_type":"markdown","source":"## Boucles « tant que » en Python\n\nLa syntaxe de la boucle while est :\n\n\noù `condition` a pour valeur `True` ou `False`.\n\n\n## Lien avec les boucle `for`\n\nIl est toujours possible de remplacer une boucle `for` par une boucle `while` comme ceci est illustré dans l'exemple suivant.\n"},{"metadata":{},"cell_type":"markdown","source":"### Exemple 1 : Compteur trivial\n\nL'exemple suivant permet d'afficher un compteur allant de 1 à 10. À chaque début\nde boucle, le programme va évaluer la condition `compteur <= 10` puis exécuter le\nbloc d'instruction si elle vaut `True` et sortir de la boucle si elle vaut `False`."},{"metadata":{"trusted":true},"cell_type":"code","source":"compteur = 1\n\nwhile compteur <= 10:\n print(compteur)\n compteur = compteur + 1","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"Avec une boucle `for`, on pourrait réécrire le programme comme "},{"metadata":{"trusted":true,"scrolled":true},"cell_type":"code","source":"compteur = 1\nfor _ in range(10):\n print(compteur)\n compteur = compteur + 1","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"Ou plus simplement en utilisant l'indice"},{"metadata":{"trusted":true,"scrolled":true},"cell_type":"code","source":"for i in range(10):\n print(i+1)","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"<h3 style=\"color:teal;background-color:azure;\" > <i class=\"fa fa-pencil\" aria-hidden=\"true\"> </i> Exercice 1: Compteur </h3> \n\nÉcrire un programme avec une boucle `while` qui affiche les nombres de 0 à 50."},{"metadata":{"trusted":true},"cell_type":"code","source":"# votre programme\n","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"<h3 style=\"color:teal;background-color:azure;\" > <i class=\"fa fa-pencil\" aria-hidden=\"true\"> </i> Exercice 2: Compteur pair </h3> \n\nTester ci-dessous le programme suivant:\n```python\nx = 0\nfor _ in range(26):\n print(x)\n x = x + 2\n```\nPuis réécrire ce programme en remplaçant la boucle `for` par une boucle `while`."},{"metadata":{"trusted":true},"cell_type":"code","source":"# votre programme\n","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"<h3 style=\"color:teal;background-color:azure;\" > <i class=\"fa fa-pencil\" aria-hidden=\"true\"> </i> Exercice 3: Compteur décroissant </h3> \n\nÉcrire un programme qui affiche une compte à rebour de 20 à 0"},{"metadata":{"trusted":true},"cell_type":"code","source":"# votre programme\n","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"## Quand utiliser une boucle `while`\n\n!!! info Utilisation\n\nBien qu'il est possible d'utiliser une boucle `while` à la place d'une boucle `for`, il est recommendé d'utiliser systématiquement la boucle `for` lorsqu'elle est suffisante et de limiter l'usage de la boucle `while` aux cas dans lesquels on ne connait pas à l'avance le nombre d'itérations ou les valeurs de la variable de la boucle.\n\nLa boucle while est typiquement utilisée pour traiter des problèmes tels que :\n\n👉 Faire quelque chose tant qu'une condition est vraie\n!!!"},{"metadata":{},"cell_type":"markdown","source":"<h3 > Exemple 2: Faire une somme</h3>\n\nNous utilisons une boucle `while` pour demander des nombres à l'utilisateur-trice.\nOn ne peut pas savoir à l'avance combien de nombres il y aura, et donc nous ne pouvons pas utiliser la boucle `for`. Nous prenons comme condition de terminaison une réponse avec le nombre 0.\n\nEntrez les frais de vos 3 derniers achats.\n"},{"metadata":{"trusted":true},"cell_type":"code","source":"somme = 0\nnombre = float(input('Entrez un nombre: '))\n\nwhile nombre != 0:\n somme = somme + nombre \n nombre = float(input('Entrez un nombre: '))\n\nprint('somme =', somme)\n","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"\n<h3 style=\"color:teal;background-color:azure;\" > <i class=\"fa fa-pencil\" aria-hidden=\"true\"> </i> Exercice 4: Faire une moyenne</h3> \n\n1. En utilisant l'exemple du programme précédent, compléter le programme suivant en remplaçant les ... afin d'avoir un programme qui permet de calculer des moyennes.\n\n2. Utiliser le programme pour calculer votre moyenne générale au premier semestre."},{"metadata":{"trusted":true},"cell_type":"code","source":"somme = 0\nnombre_de_note = 0\nnote = float(input('Entrez une note: '))\n\nwhile note != 0:\n # compléter le code à la place des ...\n somme = ...\n nombre_de_note = ...\n note = float(input('Entrez un nombre: '))\n\nprint('moyenne =', somme/nombre_de_note)\n","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"raw","source":"Votre moyenne générale au premier semestre est :\n Réponse : "},{"metadata":{},"cell_type":"markdown","source":"<h3 style=\"color:teal;background-color:azure;\" > <i class=\"fa fa-pencil\" aria-hidden=\"true\"> </i> Exercice 5: Les interêts </h3> \n\nOn place un capital de 500CHF sur un compte rémunéré à 3% par an. \n\nLe programme ci-dessous a pour but de calculer le nombre d'années au bout desquelles le capital\nsera doublé (plus grand que 1000CHF).\n\n```Python\nS = 500\nannee = 0\nwhile S < 1000 :\n S = S + (3/100) * S\nannee = annee + 1\n\nprint(\"Le capital sera doublé après \",annee, \" ans\")\n```\nLe problème est que le programme contient une erreur !\n\n1. Corriger le programme afin qu’il atteigne le but espéré, puis le tester."},{"metadata":{"trusted":true},"cell_type":"code","source":"# version à corriger du programme\nS = 500\nannee = 0\nwhile S < 1000 :\n S = S + (3/100) * S\nannee = annee + 1\n\nprint(\"Le capital sera doublé après \",annee, \" ans\")","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"raw","source":"Après combien d'année le capital aura doublé?\n Réponse: "},{"metadata":{},"cell_type":"markdown","source":"2. Modifier le programme précédent de telle sorte que le capital et le taux de rémunération soient saisis en entrée (instruction `input`). Tester le programme pour savoir au bout de combien d'année un capital de 5 CHF aura doublé si il est rémunéré à 4% par an."},{"metadata":{"trusted":true},"cell_type":"code","source":"# version du programme avec des input\n","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"raw","source":"Après combien d'année un capital de 5 CHF rémunéré à 4% aura doublé?\n Réponse: "},{"metadata":{"trusted":true},"cell_type":"code","source":"","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"## Les pièges\n\n### Piège 1: oublier d'initialiser les variables présenta dans la condition du `while`\n\nOn veut un programme qui demande un mot de passe qui reste bloqué tant que le bon mot de passe n'est par fourni. On serait tenter d'écrire"},{"metadata":{"trusted":true},"cell_type":"code","source":"while mot_de_passe != \"123456\" :\n mot_de_passe = input(\"Entrez le mot de passe : \")","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"Le programme génère une erreur car pour tester la condition `mot_de_passe != \"123456\"` il faut en premier attribuer une valeur à la variable `mot_de_passe` comme cela est fait dans le programme suivant:"},{"metadata":{"trusted":true},"cell_type":"code","source":"mot_de_passe = \"\" # Initialisation de la variable\nwhile mot_de_passe != \"123456\" :\n mot_de_passe = input(\"Entrez le mot de passe : \")","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"<h3 style=\"color:teal;background-color:azure;\" > <i class=\"fa fa-pencil\" aria-hidden=\"true\"> </i> Exercice 5: Saisie sécurisée </h3> \n\nEcrire une programme qui demande une note. Tant que la note n'est pas valable (c'est-à-dire entre 0 et 6), le programme repose la question (`input`)."},{"metadata":{"trusted":true},"cell_type":"code","source":"# mon programme\n","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"### Piège 2: tomber dans une boucle infinie\n\nIl est fréquent d'oublier une ligne de code, et d'écrire une boucle while qui ne se termine pas.\n\nPar exemple, dans le programme\n\n```python\nn = 0\nwhile n < 10 :\n print(n)\n```\nLa condition `n < 10` sera toujours vraie car on a oublié d'incrémenter la variable. Il aurait fallut écrire\n```python\nn = 0\nwhile n < 10 :\n print(n)\n n = n + 1\n```"},{"metadata":{},"cell_type":"markdown","source":"<h3 style=\"color:chocolate;background-color:papayawhip;\" > <i class=\"fa fa-question\" aria-hidden=\"true\"> </i> Quizz </h3> \n \nParmi les programme suivant choisi celui qui part en boucle infini.\n\n <input type=\"checkbox\" > **Programme A**\n```python\ni = A - 1\nwhile i < A :\n i = i - 1\n```\n <input type=\"checkbox\" > **Programme B**\n```python\ni = A + 1\nwhile i < A :\n i = i - 1\n```\n\n <input type=\"checkbox\" > **Programme C**\n```python\ni = A + 1\nwhile i < A :\n i = i + 1\n```\n\n <input type=\"checkbox\" > **Programme D**\n```python\ni = A - 1\nwhile i < A :\n i = i + 1\n```"},{"metadata":{},"cell_type":"markdown","source":"<details>\n<summary style=\"border-left:3px solid #3c763d; border-radius:2pt; width:100%; color:#3c763d; padding:6px; background-color: #dff0d8\"> \nRéponse\n</summary> \n\n<div style=\"border-left:3px solid #3c763d; border-radius:2pt; color:#3c763d; padding:6px; background-color: #eff0e8\">Programme A) car i est décrémenté, donc il devient de plus en plus petit et il ne dépassera jamais A et la condition i < A sera toujours vraie\n</div>\n</details>\n "},{"metadata":{},"cell_type":"markdown","source":"## Simuler l'exécution d'une boucle while\n\nIl est parfois difficile de debugger un programme avec une boucle `while`. Dans cette optique, il est utile de simuler l'exécution de la boucle en notant l'évolution des variables et de la condition d'arrêt dans un tableau.\n\n<h3 > Exemple 3: Simuler l'exécution d'un programme</h3>\n\nLe programme suivant\n\n```python\nn = 100\np = 1\nwhile p < n:\n p = 2 * p\n print(p)\n```\ncherche la première puissance de 2 plus grande qu’un entier `n` donné. La boucle fait prendre à `p` les valeurs 2, 4, 8, 16,. . . Elle s’arrête dès que la puissance de 2 est supérieure ou égale à `n`, donc ici ce programme affiche toutes les puissante jusqu'à 128 (compris). Le détail de l’exécution du programme est résumé dans le tableau ci-dessous:\n\n| `p` | `n` | `p < n ` |\n| :---: |:-------:| :-------:|\n| 1 | 100 | `True` |\n| 2 | 100 | `True` |\n| 4 | 100 | `True` |\n| 8 | 100 | `True` |\n| 16 | 100 | `True` |\n| 32 | 100 | `True` |\n| 64 | 100 | `True` |\n| 128 | 100 | `False` |\n\nDans les notebook, on peut toujours vérifier l'exécution d'un programme avec le module `tutor`. \n\n!!! info Utilisation de tutor\n\nPou exécuter un programme \"pas à pas\", il suffit d'importer le module `tutor` au début de votre programme avec l'instruction `from tutor import tutor` puis de terminer le programme avec l'instruction `tutor()`\n!!!\n\n**A faire:**\nVérifier que le tableau ci-dessus est correct en éxécutant le programme ci-dessous:"},{"metadata":{"trusted":true},"cell_type":"code","source":"from tutor import tutor\n\nn = 100\np = 1\nwhile p < n:\n p = 2 * p\n print(p)\n\ntutor()","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"<h3 style=\"color:chocolate;background-color:papayawhip;\" > <i class=\"fa fa-question\" aria-hidden=\"true\"> </i> Quizz </h3> \n \nQuelle est la valeur affichée par le programme ci-dessous ?\n\n```python\nu = 5\nn = 0\nwhile u != 656:\n u = 5 * u + 1\n n = n + 1\nprint ( n )\n```"},{"metadata":{},"cell_type":"raw","source":"Réponse: "},{"metadata":{},"cell_type":"markdown","source":"<details>\n<summary style=\"border-left:3px solid #3c763d; border-radius:2pt; width:100%; color:#3c763d; padding:6px; background-color: #dff0d8\"> \nRéponse\n</summary> \n\n<div style=\"border-left:3px solid #3c763d; border-radius:2pt; color:#3c763d; padding:6px; background-color: #eff0e8\">C'est 3 car après 3 itérations u vaut 656\n</div>\n</details>\n "},{"metadata":{},"cell_type":"markdown","source":"<h3 style=\"color:chocolate;background-color:papayawhip;\" > <i class=\"fa fa-question\" aria-hidden=\"true\"> </i> Quizz </h3> \n \nQuelle est la valeur affichée par le programme ci-dessous ?\n\n\n```python\nu = 5\nv = 12\ni = 1\nwhile u < v:\n u = 3 * u + 2\n v = 2 * v + 3\n i = i + 1\nprint ( i )\n```"},{"metadata":{},"cell_type":"raw","source":"Réponse: "},{"metadata":{},"cell_type":"markdown","source":"<details>\n<summary style=\"border-left:3px solid #3c763d; border-radius:2pt; width:100%; color:#3c763d; padding:6px; background-color: #dff0d8\"> \nRéponse\n</summary> \n\n<div style=\"border-left:3px solid #3c763d; border-radius:2pt; color:#3c763d; padding:6px; background-color: #eff0e8\">C'est 3 car après 3 itérations u vaut 656\n</div>\n</details>\n "},{"metadata":{},"cell_type":"markdown","source":"<h3 style=\"color:chocolate;background-color:papayawhip;\" > <i class=\"fa fa-question\" aria-hidden=\"true\"> </i> Quizz </h3> \n \nQuelle valeur faut-il donner à la variable `k` pour que le programme ci-dessous affiche 7?\n\n\n```python\nk = int(input(\"Quel valeur pour k ? \"))\nn = 0\nwhile k != 1:\n n = n + 1\n k = k / 2\nprint ( n )\n```"},{"metadata":{},"cell_type":"raw","source":"Réponse: "},{"metadata":{},"cell_type":"markdown","source":"<details>\n<summary style=\"border-left:3px solid #3c763d; border-radius:2pt; width:100%; color:#3c763d; padding:6px; background-color: #dff0d8\"> \nRéponse\n</summary> \n\n<div style=\"border-left:3px solid #3c763d; border-radius:2pt; color:#3c763d; padding:6px; background-color: #eff0e8\">C'est 128. En effet il faut diviser 7 fois 128 par 2 pour avoir 1.\n \n</div>\n</details>\n "},{"metadata":{},"cell_type":"markdown","source":"---\n\n# 🎯 **Conclusion : Quand utiliser `while` ?**\n\n| Situation | `for` | `while` |\n|-----------|-------|---------|\n| Nombre d'itérations connu à l'avance | ✅ Oui | ❌ Non |\n| Nombre d'itérations inconnu (dépend d'une condition) | ❌ Non | ✅ Oui |\n| Répéter une action jusqu'à un événement spécifique | ❌ Non | ✅ Oui |\n| Interaction utilisateur (ex: attendre une entrée correcte) | ❌ Non | ✅ Oui |\n| Boucles infinies avec condition d’arrêt | ❌ Risqué | ✅ Plus adapté |\n\n## 📌 **À retenir** \n- **Utilise `for`** lorsque **le nombre d'itérations est fixé** (ex: parcourir une liste, boucle de comptage).\n- **Utilise `while`** lorsque **la boucle dépend d’une condition** qui peut varier (ex: entrée utilisateur, événement aléatoire, suivi d'une valeur dynamique).\n- **Attention aux boucles infinies !** Toujours s'assurer que la condition de sortie est bien définie.\n\n🚀 **Exercez-vous** en adaptant les exercices et en créant vos propres scénarios d'utilisation de `while` ! \n\n---\n"},{"metadata":{},"cell_type":"markdown","source":"## Pour aller plus loin..."},{"metadata":{},"cell_type":"markdown","source":"<h3> Exemple 4: Décomposer en facteurs premiers</h3>\n\nLe programme suivant réalise la décomposition en facteurs premiers d'un nombre donné par l'utilisateur-trice.\n"},{"metadata":{"trusted":true},"cell_type":"code","source":"nombre = int(input('Entrez un entier: '))\ni = 2\n\nprint(nombre, \"=\", end=\" \")\n\nwhile i < nombre:\n if nombre % i == 0: # % est le reste de la division entière\n print(i, \"·\", end=\" \")\n nombre = nombre // i # // correspond à la division entière\n else:\n i = i + 1\n\nprint(nombre)\n","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"<h3 > Exemple 5: En code binaire</h3>\n\nLe programme transforme l'entier en code binaire.\n\n"},{"metadata":{"trusted":true},"cell_type":"code","source":"n = int(input('Entrez un entier: '))\n\ncode = ''\nwhile n > 0:\n if n % 2 == 1:\n code = '1' + code\n else:\n code = '0' + code\n n = n // 2\n\nprint(code)\n","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"## Sortir avec `break`\n\nLe mot-clé `break`, seul sur une ligne, permet de sortir d'une boucle.\nSouvent cette méthode est utilisée pour avoir une boucle où la condition est testée à la fin.\n\n"},{"metadata":{"trusted":true},"cell_type":"code","source":"while True:\n mot_de_passe = input(\"Entrez le mot de passe : \")\n if mot_de_passe == \"123456\":\n print(\"Mot de passe valide\")\n break\n print(\"Mot de passe invalide\")","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"markdown","source":"<h3 style=\"color:teal;background-color:azure;\" > <i class=\"fa fa-pencil\" aria-hidden=\"true\"> </i> Exercice 7: nombre de chiffre d'un nombre </h3> \n\nEcrire un programme qui demande un nombre à l'utilisateur puis affiche le combien de chiffre sont nécessaires pour écrire ce nombre. Par exemple, le nombre 74613 s'écrit avec 5 chiffres\n\n*Indication : Faites des divisions entières par 10 successivement*\n"},{"metadata":{"trusted":true},"cell_type":"code","source":"","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"<h3 style=\"color:teal;background-color:azure;\" > <i class=\"fa fa-pencil\" aria-hidden=\"true\"> </i> Exercice 8: Le trait qui tourne </h3> \n\n💡 **Objectif** : En répétant plusieurs fois je dessine un trait et je tourne d'un angle, je dessine une figure.\n\nSuivre les indications suivantes:\n- le stylo de couleur bleu avance sur un segment droit de longueur 5;\n- puis tourne de 70° vers la droite. \n- Ensuite, la longueur du segment est incrémentée (augmentée de 0.5).\n- Répéter ces étapes tant que la longueur du segment est inférieure à 150.\n\nTester ensuite le programme avec une rotation de 89° au lieu de 70°.\n\nDessinez une usine avec un toit en dents de scie.\n"},{"metadata":{"trusted":true},"cell_type":"code","source":"","execution_count":null,"outputs":[]},{"metadata":{"trusted":false},"cell_type":"markdown","source":"<h3 style=\"color:teal;background-color:azure;\" > <i class=\"fa fa-pencil\" aria-hidden=\"true\"> </i> Exercice 9: Ratrapper la tortue </h3> \n\n\nUne tortue s'élance sur une piste de 10 mètres de long. Le jour, elle parcourt 1 mètre, la nuit, elle\nse repose.\n\nSeulement, voilà, la piste, en caoutchouc, s'étire toutes les nuits de 10 mètres. Ainsi, au deuxième\nmatin, la tortue se retrouve à deux mètres du début de la piste, mais à 18 mètres de son extrémité.\n\nLorsqu'elle s'endort le soir, il lui reste encore 17 mètres à parcourir. Et lorsqu'elle se réveille le matin suivant, la piste a 30 mètres de long, dont plus de 25 mètres sont\ndevant elle!\n\n a) La tortue arrivera-t-elle au bout de la piste?\n b) Si oui, en combien de temps?\n c) Rédiger un script qui détermine le nombre de jours.\n \n*Indication : calculer la fraction de la piste que la tortue parcours chaque jour.*"},{"metadata":{"trusted":true},"cell_type":"code","source":"","execution_count":null,"outputs":[]},{"metadata":{"trusted":false},"cell_type":"markdown","source":"<h3 style=\"color:teal;background-color:azure;\" > <i class=\"fa fa-pencil\" aria-hidden=\"true\"> </i> Exercice 10: La balle rebondissante </h3> \n\n\nUne balle rebondissante est lâchée du haut d'un immeuble de 10 mètres. A chaque rebond la hauteur diminue d'un tiers. Combien de fois la personne du premier niveau dont la fenêtre est située à 1 mètre 50 du sol verra elle passer la balle ?"},{"metadata":{"trusted":true},"cell_type":"code","source":"","execution_count":null,"outputs":[]},{"metadata":{"trusted":false},"cell_type":"markdown","source":"<h3 style=\"color:teal;background-color:azure;\" > <i class=\"fa fa-pencil\" aria-hidden=\"true\"> </i> Exercice 11: La suite de Syracuse </h3> \n\nOn définit une suite $u_n$ de la manière suivante : \n\n- $u_0 = 1000$\n- si $u_n = 1$, alors la suite est finie et u n est son dernier élément (on arrête de calculer d’autres\néléments)\n- si $u_n$ est pair, alors $u_{n+1} = u_n / 2$\n- si $u_n$ est impair et distinct de 1, alors $u_{n+1} = 3 u_n + 1$\n\nÉcrire un programme qui affiche les termes de la suite u.\n\nCette suite est-elle finie ?\n\nPour aller plus loin, aller vous renseigner sur la Conjecture de Syracuse https://fr.wikipedia.org/wiki/Conjecture_de_Syracuse."},{"metadata":{},"cell_type":"markdown","source":"---\n\n#### Remarque générale\n\nCe document est une adaptation d'un ressource pédagogique tiré du catalogue modulo https://modulo-info.ch/. Il est sous license Creative Commons [BY-NC-SA](https://creativecommons.org/licenses/?lang=fr)\n\n\n "}],"metadata":{"kernelspec":{"display_name":"Python 3 (ipykernel)","language":"python","name":"python3"}},"nbformat":4,"nbformat_minor":2}
\ No newline at end of file
{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": "<div style=\"padding:20px;background-color:papayawhip;\" > \n<h3 style=\"color:chocolate\"> <i class=\"fa fa-info\" aria-hidden=\"true\"> </i> Remarque introductive <i class=\"fa fa-info\" aria-hidden=\"true\"></h3> \n<p> Ce fichier est fait pour être lu sur le site <a href=\"https://notebook.basthon.fr/\"><img src='https://notebook.basthon.fr/assets/efede5218c9087496f16.png' style=\"border: 0; display:inline; margin: 0 5px; height:30px\" alt=\"Basthon\"/></a>. <br>\n \nSi vous l'avez ouvert avec un autre programme, comme Jupyter notebook, vous riquez de rencontrer quelques bugs. <br>\nVeuillez cliquez sur <a href=\"https://notebook.basthon.fr/\">ce lien</a> et y charger ce fichier à l'aide du bouton \"Ouvrir\" <i class=\"fa fa-folder\" aria-hidden=\"true\"> </i>\n</p> </div> "
},
{
"cell_type": "markdown",
"metadata": {},
"source": "# 7 - Boucle `while`, partie 1\n\nDans ce chapitre, nous découvrons un deuxième type de boucle, la boucle `while`. \n\n## Boucles « tant que »\nNous avons déjà rencontré d'une part la structure de la boucle `for`, qui permet d'effectuer un nombre prédéfini d'itérations d'un bloc d'instructions, et d'autre part le branchement conditionnel `if`, qui permet d'exécuter ou non un bloc d'instructions en fonction d'un test effectué sur le moment.\n\nLes boucles « tant que », ou boucle `while`, combinent ces deux principes d'une nouvelle manière en conditionnant la poursuite des itérations à un test effectué préalablement à chaque tour de boucle."
},
{
"cell_type": "markdown",
"metadata": {},
"source": "<h3 style=\"color:chocolate;background-color:papayawhip;\" > <i class=\"fa fa-question\" aria-hidden=\"true\"> </i> Quizz </h3> \n \n```\nEn Python, while permet de réaliser :\n\nA) une fonction\nB) une condition\nC) une boucle\nD) aucune des réponses précédentes\n```"
"source": "## Boucles « tant que » en Python\n\nLa syntaxe de la boucle while est :\n\n\noù `condition` a pour valeur `True` ou `False`.\n\n\n## Lien avec les boucle `for`\n\nIl est toujours possible de remplacer une boucle `for` par une boucle `while` comme ceci est illustré dans l'exemple suivant.\n"
},
{
"cell_type": "markdown",
"metadata": {},
"source": "### Exemple 1 : Compteur trivial\n\nL'exemple suivant permet d'afficher un compteur allant de 1 à 10. À chaque début\nde boucle, le programme va évaluer la condition `compteur <= 10` puis exécuter le\nbloc d'instruction si elle vaut `True` et sortir de la boucle si elle vaut `False`."
"source": "Ou plus simplement en utilisant l'indice"
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"scrolled": true,
"trusted": false
},
"outputs": [],
"source": "for i in range(10):\n print(i+1)"
},
{
"cell_type": "markdown",
"metadata": {},
"source": "<h3 style=\"color:teal;background-color:azure;\" > <i class=\"fa fa-pencil\" aria-hidden=\"true\"> </i> Exercice 1: Compteur </h3> \n\nÉcrire un programme avec une boucle `while` qui affiche les nombres de 0 à 50."
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"trusted": false
},
"outputs": [],
"source": "# votre programme\n"
},
{
"cell_type": "markdown",
"metadata": {},
"source": "<h3 style=\"color:teal;background-color:azure;\" > <i class=\"fa fa-pencil\" aria-hidden=\"true\"> </i> Exercice 2: Compteur pair </h3> \n\nTester ci-dessous le programme suivant:\n```python\nx = 0\nfor _ in range(26):\n print(x)\n x = x + 2\n```\nPuis réécrire ce programme en remplaçant la boucle `for` par une boucle `while`."
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"trusted": false
},
"outputs": [],
"source": "# votre programme\n"
},
{
"cell_type": "markdown",
"metadata": {},
"source": "<h3 style=\"color:teal;background-color:azure;\" > <i class=\"fa fa-pencil\" aria-hidden=\"true\"> </i> Exercice 3: Compteur décroissant </h3> \n\nÉcrire un programme qui affiche une compte à rebour de 20 à 0"
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"trusted": false
},
"outputs": [],
"source": "# votre programme\n"
},
{
"cell_type": "markdown",
"metadata": {},
"source": "## Quand utiliser une boucle `while`\n\n!!! info Utilisation\n\nBien qu'il est possible d'utiliser une boucle `while` à la place d'une boucle `for`, il est recommendé d'utiliser systématiquement la boucle `for` lorsqu'elle est suffisante et de limiter l'usage de la boucle `while` aux cas dans lesquels on ne connait pas à l'avance le nombre d'itérations ou les valeurs de la variable de la boucle.\n\nLa boucle while est typiquement utilisée pour traiter des problèmes tels que :\n\n👉 Faire quelque chose tant qu'une condition est vraie\n!!!"
},
{
"cell_type": "markdown",
"metadata": {},
"source": "<h3 > Exemple 2: Faire une somme</h3>\n\nNous utilisons une boucle `while` pour demander des nombres à l'utilisateur-trice.\nOn ne peut pas savoir à l'avance combien de nombres il y aura, et donc nous ne pouvons pas utiliser la boucle `for`. Nous prenons comme condition de terminaison une réponse avec le nombre 0.\n\nEntrez les frais de vos 3 derniers achats.\n"
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"trusted": false
},
"outputs": [],
"source": "somme = 0\nnombre = float(input('Entrez un nombre: '))\n\nwhile nombre != 0:\n somme = somme + nombre \n nombre = float(input('Entrez un nombre: '))\n\nprint('somme =', somme)\n"
},
{
"cell_type": "markdown",
"metadata": {},
"source": "\n<h3 style=\"color:teal;background-color:azure;\" > <i class=\"fa fa-pencil\" aria-hidden=\"true\"> </i> Exercice 4: Faire une moyenne</h3> \n\n1. En utilisant l'exemple du programme précédent, compléter le programme suivant en remplaçant les ... afin d'avoir un programme qui permet de calculer des moyennes.\n\n2. Utiliser le programme pour calculer votre moyenne générale au premier semestre."
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"trusted": false
},
"outputs": [],
"source": "somme = 0\nnombre_de_note = 0\nnote = float(input('Entrez une note: '))\n\nwhile note != 0:\n # compléter le code à la place des ...\n somme = ...\n nombre_de_note = ...\n note = float(input('Entrez un nombre: '))\n\nprint('moyenne =', somme/nombre_de_note)\n"
},
{
"cell_type": "raw",
"metadata": {},
"source": "Votre moyenne générale au premier semestre est :\n Réponse : "
},
{
"cell_type": "markdown",
"metadata": {},
"source": "<h3 style=\"color:teal;background-color:azure;\" > <i class=\"fa fa-pencil\" aria-hidden=\"true\"> </i> Exercice 5: Les interêts </h3> \n\nOn place un capital de 500CHF sur un compte rémunéré à 3% par an. \n\nLe programme ci-dessous a pour but de calculer le nombre d'années au bout desquelles le capital\nsera doublé (plus grand que 1000CHF).\n\n```Python\nS = 500\nannee = 0\nwhile S < 1000 :\n S = S + (3/100) * S\nannee = annee + 1\n\nprint(\"Le capital sera doublé après \",annee, \" ans\")\n```\nLe problème est que le programme contient une erreur !\n\n1. Corriger le programme afin qu’il atteigne le but espéré, puis le tester."
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"trusted": false
},
"outputs": [],
"source": "# version à corriger du programme\nS = 500\nannee = 0\nwhile S < 1000 :\n S = S + (3/100) * S\nannee = annee + 1\n\nprint(\"Le capital sera doublé après \",annee, \" ans\")"
},
{
"cell_type": "raw",
"metadata": {},
"source": "Après combien d'année le capital aura doublé?\n Réponse: "
},
{
"cell_type": "markdown",
"metadata": {},
"source": "2. Modifier le programme précédent de telle sorte que le capital et le taux de rémunération soient saisis en entrée (instruction `input`). Tester le programme pour savoir au bout de combien d'année un capital de 5 CHF aura doublé si il est rémunéré à 4% par an."
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"trusted": false
},
"outputs": [],
"source": "# version du programme avec des input\n"
},
{
"cell_type": "raw",
"metadata": {},
"source": "Après combien d'année un capital de 5 CHF rémunéré à 4% aura doublé?\n Réponse: "
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"trusted": false
},
"outputs": [],
"source": ""
},
{
"cell_type": "markdown",
"metadata": {},
"source": "---\n\n#### Remarque générale\n\nCe document est une adaptation d'un ressource pédagogique tiré du catalogue modulo https://modulo-info.ch/. Il est sous license Creative Commons [BY-NC-SA](https://creativecommons.org/licenses/?lang=fr)\n\n\n "
<p> Ce fichier est fait pour être lu sur le site <ahref="https://notebook.basthon.fr/"><imgsrc='https://notebook.basthon.fr/assets/efede5218c9087496f16.png'style="border: 0; display:inline; margin: 0 5px; height:30px"alt="Basthon"/></a>. <br>
Si vous l'avez ouvert avec un autre programme, comme Jupyter notebook, vous riquez de rencontrer quelques bugs. <br>
Veuillez cliquez sur <ahref="https://notebook.basthon.fr/">ce lien</a> et y charger ce fichier à l'aide du bouton "Ouvrir" <iclass="fa fa-folder"aria-hidden="true"></i>
</p></div>
%% Cell type:markdown id: tags:
# 7 - Boucle `while`
# 7 - Boucle `while`, partie 1
Dans ce chapitre, nous découvrons un deuxième type de boucle, la boucle `while`. Elle est souvent utilisée pour attendre quelque chose. Nous allons voir que :
- la boucle `while` répète aussi longtemps qu'une condition est vraie,
- le mot-clé `break` permet de sortir de la boucle.
Dans ce chapitre, nous découvrons un deuxième type de boucle, la boucle `while`.
## Boucles « tant que »
Nous avons déjà rencontré d'une part la structure de la boucle `for`, qui permet d'effectuer un nombre prédéfini d'itérations d'un bloc d'instructions, et d'autre part le branchement conditionnel `if`, qui permet d'exécuter ou non un bloc d'instructions en fonction d'un test effectué sur le moment.
Les boucles « tant que », ou boucle `while`, combinent ces deux principes d'une nouvelle manière en conditionnant la poursuite des itérations à un test effectué préalablement à chaque tour de boucle.
Écrire un programme qui affiche une compte à rebour de 20 à 0
%% Cell type:code id: tags:
``` python
# votre programme
```
%% Cell type:markdown id: tags:
## Quand utiliser une boucle `while`
!!! info Utilisation
Bien qu'il est possible d'utiliser une boucle `while` à la place d'une boucle `for`, il est recommendé d'utiliser systématiquement la boucle `for` lorsqu'elle est suffisante et de limiter l'usage de la boucle `while` aux cas dans lesquels on ne connait pas à l'avance le nombre d'itérations ou les valeurs de la variable de la boucle.
La boucle while est typiquement utilisée pour traiter des problèmes tels que :
👉 Faire quelque chose tant qu'une condition est vraie
!!!
%% Cell type:markdown id: tags:
<h3> Exemple 2: Faire une somme</h3>
Nous utilisons une boucle `while` pour demander des nombres à l'utilisateur-trice.
On ne peut pas savoir à l'avance combien de nombres il y aura, et donc nous ne pouvons pas utiliser la boucle `for`. Nous prenons comme condition de terminaison une réponse avec le nombre 0.
Entrez les frais de vos 3 derniers achats.
%% Cell type:code id: tags:
``` python
somme=0
nombre=float(input('Entrez un nombre: '))
whilenombre!=0:
somme=somme+nombre
nombre=float(input('Entrez un nombre: '))
print('somme =',somme)
```
%% Cell type:markdown id: tags:
<h3style="color:teal;background-color:azure;"><iclass="fa fa-pencil"aria-hidden="true"></i> Exercice 4: Faire une moyenne</h3>
1. En utilisant l'exemple du programme précédent, compléter le programme suivant en remplaçant les ... afin d'avoir un programme qui permet de calculer des moyennes.
2. Utiliser le programme pour calculer votre moyenne générale au premier semestre.
%% Cell type:code id: tags:
``` python
somme=0
nombre_de_note=0
note=float(input('Entrez une note: '))
whilenote!=0:
# compléter le code à la place des ...
somme=...
nombre_de_note=...
note=float(input('Entrez un nombre: '))
print('moyenne =',somme/nombre_de_note)
```
%% Cell type:raw id: tags:
Votre moyenne générale au premier semestre est :
Réponse :
%% Cell type:markdown id: tags:
<h3style="color:teal;background-color:azure;"><iclass="fa fa-pencil"aria-hidden="true"></i> Exercice 5: Les interêts </h3>
On place un capital de 500CHF sur un compte rémunéré à 3% par an.
Le programme ci-dessous a pour but de calculer le nombre d'années au bout desquelles le capital
sera doublé (plus grand que 1000CHF).
```Python
S = 500
annee = 0
while S < 1000 :
S = S + (3/100) * S
annee = annee + 1
print("Le capital sera doublé après ",annee, " ans")
```
Le problème est que le programme contient une erreur !
1. Corriger le programme afin qu’il atteigne le but espéré, puis le tester.
%% Cell type:code id: tags:
``` python
# version à corriger du programme
S=500
annee=0
whileS<1000:
S=S+(3/100)*S
annee=annee+1
print("Le capital sera doublé après ",annee," ans")
```
%% Cell type:raw id: tags:
Après combien d'année le capital aura doublé?
Réponse:
%% Cell type:markdown id: tags:
2. Modifier le programme précédent de telle sorte que le capital et le taux de rémunération soient saisis en entrée (instruction `input`). Tester le programme pour savoir au bout de combien d'année un capital de 5 CHF aura doublé si il est rémunéré à 4% par an.
%% Cell type:code id: tags:
``` python
# version du programme avec des input
```
%% Cell type:raw id: tags:
Après combien d'année un capital de 5 CHF rémunéré à 4% aura doublé?
Réponse:
%% Cell type:code id: tags:
``` python
```
%% Cell type:markdown id: tags:
## Les pièges
### Piège 1: oublier d'initialiser les variables présenta dans la condition du `while`
Onveutunprogrammequidemandeunmotdepassequirestebloquétantquelebonmotdepassen'est par fourni. On serait tenter d'écrire
%%Celltype:codeid:tags:
``` python
while mot_de_passe != "123456" :
mot_de_passe = input("Entrez le mot de passe : ")
```
%% Cell type:markdown id: tags:
Le programme génère une erreur car pour tester la condition `mot_de_passe != "123456"` il faut en premier attribuer une valeur à la variable `mot_de_passe` comme cela est fait dans le programme suivant:
<div style="border-left:3px solid #3c763d; border-radius:2pt; color:#3c763d; padding:6px; background-color: #eff0e8">Programme A) car i est décrémenté, donc il devient de plus en plus petit et il ne dépassera jamais A et la condition i < A sera toujours vraie
</div>
</details>
%% Cell type:markdown id: tags:
## Simuler l'exécution d'une boucle while
Il est parfois difficile de debugger un programme avec une boucle `while`. Dans cette optique, il est utile de simuler l'exécution de la boucle en notant l'évolution des variables et de la condition d'arrêt dans un tableau.
<h3 > Exemple 3: Simuler l'exécution d'un programme</h3>
Le programme suivant
```python
n = 100
p = 1
while p < n:
p = 2 * p
print(p)
```
cherche la première puissance de 2 plus grande qu’un entier `n` donné. La boucle fait prendre à `p` les valeurs 2, 4, 8, 16,. . . Elle s’arrête dès que la puissance de 2 est supérieure ou égale à `n`, donc ici ce programme affiche toutes les puissante jusqu'à 128 (compris). Le détail de l’exécution du programme est résumé dans le tableau ci-dessous:
| `p` | `n` | `p < n ` |
| :---: |:-------:| :-------:|
| 1 | 100 | `True` |
| 2 | 100 | `True` |
| 4 | 100 | `True` |
| 8 | 100 | `True` |
| 16 | 100 | `True` |
| 32 | 100 | `True` |
| 64 | 100 | `True` |
| 128 | 100 | `False` |
Dans les notebook, on peut toujours vérifier l'exécution d'un programme avec le module `tutor`.
!!! info Utilisation de tutor
Pou exécuter un programme "pas à pas", il suffit d'importer le module `tutor` au début de votre programme avec l'instruction `from tutor import tutor` puis de terminer le programme avec l'instruction `tutor()`
!!!
**A faire:**
Vérifier que le tableau ci-dessus est correct en éxécutant le programme ci-dessous:
<div style="border-left:3px solid #3c763d; border-radius:2pt; color:#3c763d; padding:6px; background-color: #eff0e8">C'est 128. En effet il faut diviser 7 fois 128 par 2 pour avoir 1.
</div>
</details>
%% Cell type:markdown id: tags:
---
# 🎯 **Conclusion : Quand utiliser `while` ?**
| Situation | `for` | `while` |
|-----------|-------|---------|
| Nombre d'itérations connu à l'avance | ✅ Oui | ❌ Non |
| Nombre d'itérations inconnu (dépend d'une condition) | ❌ Non | ✅ Oui |
| Répéter une action jusqu'à un événement spécifique | ❌ Non | ✅ Oui |
| Interaction utilisateur (ex: attendre une entrée correcte) | ❌ Non | ✅ Oui |
| Boucles infinies avec condition d’arrêt | ❌ Risqué | ✅ Plus adapté |
## 📌 **À retenir**
- **Utilise `for`** lorsque **le nombre d'itérations est fixé** (ex: parcourir une liste, boucle de comptage).
- **Utilise `while`** lorsque **la boucle dépend d’une condition** qui peut varier (ex: entrée utilisateur, événement aléatoire, suivi d'une valeur dynamique).
- **Attention aux boucles infinies !** Toujours s'assurer que la condition de sortie est bien définie.
🚀 **Exercez-vous** en adaptant les exercices et en créant vos propres scénarios d'utilisation de `while` !
---
%% Cell type:markdown id: tags:
## Pour aller plus loin...
%% Cell type:markdown id: tags:
<h3> Exemple 4: Décomposer en facteurs premiers</h3>
Le programme suivant réalise la décomposition en facteurs premiers d'un nombre donné par l'utilisateur-trice.
%% Cell type:code id: tags:
``` python
nombre = int(input('Entrez un entier: '))
i = 2
print(nombre, "=", end=" ")
while i < nombre:
if nombre % i == 0: # % est le reste de la division entière
print(i, "·", end=" ")
nombre = nombre // i # // correspond à la division entière
else:
i = i + 1
print(nombre)
```
%% Cell type:markdown id: tags:
<h3 > Exemple 5: En code binaire</h3>
Le programme transforme l'entier en code binaire.
%% Cell type:code id: tags:
``` python
n = int(input('Entrez un entier: '))
code = ''
while n > 0:
if n % 2 == 1:
code = '1' + code
else:
code = '0' + code
n = n // 2
print(code)
```
%% Cell type:markdown id: tags:
## Sortir avec `break`
Le mot-clé `break`, seul sur une ligne, permet de sortir d'une boucle.
Souvent cette méthode est utilisée pour avoir une boucle où la condition est testée à la fin.
%% Cell type:code id: tags:
``` python
while True:
mot_de_passe = input("Entrez le mot de passe : ")
if mot_de_passe == "123456":
print("Mot de passe valide")
break
print("Mot de passe invalide")
```
%% Cell type:markdown id: tags:
<h3 style="color:teal;background-color:azure;" > <i class="fa fa-pencil" aria-hidden="true"> </i> Exercice 7: nombre de chiffre d'un nombre </h3>
Ecrire un programme qui demande un nombre à l'utilisateur puis affiche le combien de chiffre sont nécessaires pour écrire ce nombre. Par exemple, le nombre 74613 s'écrit avec 5 chiffres
*Indication : Faites des divisions entières par 10 successivement*
%% Cell type:code id: tags:
``` python
```
%% Cell type:markdown id: tags:
<h3 style="color:teal;background-color:azure;" > <i class="fa fa-pencil" aria-hidden="true"> </i> Exercice 8: Le trait qui tourne </h3>
💡 **Objectif** : En répétant plusieurs fois je dessine un trait et je tourne d'un angle, je dessine une figure.
Suivre les indications suivantes:
- le stylo de couleur bleu avance sur un segment droit de longueur 5;
- puis tourne de 70° vers la droite.
- Ensuite, la longueur du segment est incrémentée (augmentée de 0.5).
- Répéter ces étapes tant que la longueur du segment est inférieure à 150.
Tester ensuite le programme avec une rotation de 89° au lieu de 70°.
Dessinez une usine avec un toit en dents de scie.
Une tortue s'élance sur une piste de 10 mètres de long. Le jour, elle parcourt 1 mètre, la nuit, elle
se repose.
Seulement, voilà, la piste, en caoutchouc, s'étire toutes les nuits de 10 mètres. Ainsi, au deuxième
matin, la tortue se retrouve à deux mètres du début de la piste, mais à 18 mètres de son extrémité.
Lorsqu'elle s'endort le soir, il lui reste encore 17 mètres à parcourir. Et lorsqu'elle se réveille le matin suivant, la piste a 30 mètres de long, dont plus de 25 mètres sont
devant elle!
a) La tortue arrivera-t-elle au bout de la piste?
b) Si oui, en combien de temps?
c) Rédiger un script qui détermine le nombre de jours.
*Indication : calculer la fraction de la piste que la tortue parcours chaque jour.*
Une balle rebondissante est lâchée du haut d'un immeuble de 10 mètres. A chaque rebond la hauteur diminue d'un tiers. Combien de fois la personne du premier niveau dont la fenêtre est située à 1 mètre 50 du sol verra elle passer la balle ?
%% Cell type:code id: tags:
``` python
```
%% Cell type:markdown id: tags:
<h3 style="color:teal;background-color:azure;" > <i class="fa fa-pencil" aria-hidden="true"> </i> Exercice 11: La suite de Syracuse </h3>
On définit une suite $u_n$ de la manière suivante :
- $u_0 = 1000$
- si $u_n = 1$, alors la suite est finie et u n est son dernier élément (on arrête de calculer d’autres
éléments)
- si $u_n$ est pair, alors $u_{n+1} = u_n / 2$
- si $u_n$ est impair et distinct de 1, alors $u_{n+1} = 3 u_n + 1$
Écrire un programme qui affiche les termes de la suite u.
Cette suite est-elle finie ?
Pour aller plus loin, aller vous renseigner sur la Conjecture de Syracuse https://fr.wikipedia.org/wiki/Conjecture_de_Syracuse.
%% Cell type:markdown id: tags:
---
#### Remarque générale
Ce document est une adaptation d'un ressource pédagogique tiré du catalogue modulo https://modulo-info.ch/. Il est sous license Creative Commons [BY-NC-SA](https://creativecommons.org/licenses/?lang=fr)
