ajout d'une partie 2 sur la récursivité

recursivite/recursivite2.ipynb

+{"cells":[{"metadata":{},"cell_type":"markdown","source":"<h1 class=\"alert alert-success\">Complément sur la récursivité en programmation</h2>"},{"metadata":{},"cell_type":"markdown","source":"## <h2 class=\"alert alert-info\"> 1. Introduction à la récursivité</h2>\nUn algorithme récursif est un algorithme qui résout un problème en calculant des solutions d'instances plus petites du même problème. "},{"metadata":{},"cell_type":"markdown","source":"<h2 class=\"alert alert-success\"> Rappel : Algorithme pour implémenter une fonction récursive</h2>\n\n- Etape 1 - Définir le cas de base : Identifier le cas le plus simple pour lequel une solution est connue.\n\n- Etape 2 - Définir la récursion : Définir le problème en termes de plus petits sous-problèmes et appeler la fonction pour les résoudre.\n\n- Etape 3 - Définir la fin : S'assurer que la récursion va bien arriver au cas de base pour éviter d'avoir une boucle infinie."},{"metadata":{},"cell_type":"markdown","source":"<h2 class = \"alert alert-success\"> Structure d'un code récursif en python :</h2>"},{"metadata":{},"cell_type":"raw","source":"def fonction(n, ...):\n    if n==0 :\n        # code pour le cas de base\n    else :\n        # votre code où apparaîtra fonction(n-1,...)"},{"metadata":{},"cell_type":"markdown","source":"### <h2 class=\"alert alert-info\">2. Fractales : courbe de Koch Correction</h2>\n\nLa courbe de Koch est une fractale reposant sur la construction récursive suviante :\n1. Étape 1 : Tracer un segment de longueur a. \n\n![Image de losange](https://githepia.hesge.ch/info_sismondi/3AM.OS/-/raw/main/recursivite/koch_0.png)\n\n2. Étape 2 : Diviser le segment en 3 parties de même longueur. Construire un triangle équilatéral ayant pour base le segment médian de la première étape, et en supprimer la base.\n![Image de losange](https://githepia.hesge.ch/info_sismondi/3AM.OS/-/raw/main/recursivite/koch_1.png)\n\n3. Étape 3 : Reprendre l'étape 2 sur chacun des segments créés.\n![Image de losange](https://githepia.hesge.ch/info_sismondi/3AM.OS/-/raw/main/recursivite/koch_2.png)\n\n4. Et ainsi de suite...\n![Image de losange](https://githepia.hesge.ch/info_sismondi/3AM.OS/-/raw/main/recursivite/koch_3.png)"},{"metadata":{},"cell_type":"markdown","source":"On peut construire récursivement cette courbe. \n\nLa fonction de tracer prend deux paramètres en entrée :\n* la longeur $a$ du segment.\n* l'étape $n$ de \"profondeur\" de récursivité. \n\nPar exemple, à la profondeur $n=0$, on trace un simple segment : ceci constituera le cas de base et la condition d'arrêt des appels récursifs. À la profondeur $n=1$, le tracé donne la figure de l'étape 2."},{"metadata":{},"cell_type":"markdown","source":"<h2 class=\"alert alert-warning\">Courbe de Koch : fonction récursive.</h2>\n\nEn vous inspirant de la logique du code de la fonction précédente (en la \"rendant récursive\"), écrire une fonction koch(a, n) récursive qui :\n\n- prend comme paramètres un nombre entier a représentant la longueur du segment et un entier n égal au nombre de récursions souhaité.\n- construit la courbe de Koch en divisant récursivement chacun des segments\n\n*Rappel* : si n=0, le tracé est un simplement segment de longueur a."},{"metadata":{},"cell_type":"markdown","source":"<div class = \"alert alert-block alert-success\"> \n\n### Solution\n</div>"},{"metadata":{"trusted":true},"cell_type":"code","source":"import turtle as tt # import du module turtle\n\ntt.speed(10)\ntt.penup()\ntt.setposition(-300, 0) \ntt.pendown()\n\ndef koch(a, n):\n    if n == 0:\n        tt.forward(a)\n    else:\n        koch(a/3, n-1)\n        tt.left(60)\n        koch(a/3, n-1)\n        tt.right(120)\n        koch(a/3, n-1)\n        tt.left(60)\n        koch(a/3, n-1)\n\nkoch(360, 3)\n\ntt.done()","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"<h2 class=\"alert alert-warning\">Flocon de Koch : fonction récursive</h2>\n\n\nPour obtenir le flocon de Koch:\n\n<figure> \n    <img title='Koch snowflake' \n         src=\"https://isquared.digital/assets/images/koch_snowflake.png\"\n         width='600px' >\n    <figcaption>Etapes 0, 1, 2, 3 et 4</figcaption>\n</figure>\n\nIl suffit d'écrire une fonction `floconkoch(a,n)` qui va itérer  `koch(a,n)` avec la bonne rotation."},{"metadata":{"trusted":true},"cell_type":"code","source":"a = 180\n\ntt.speed(10)\ntt.penup()\ntt.setposition(-a/2, a/3) \ntt.pendown()\n\n\ndef floconkoch(a, n):\n    for i in range(3):\n        koch(a, n)\n        tt.right(120)\n\n# test pour afficher l'étape 3\nflocon(a, 3)\n\ntt.penup()\ntt.home()\n\ntt.done()","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"### <h2 class=\"alert alert-info\">2. Fractales de Koch et perimètres </h2>\n\n1. Complétez ce code récursif pour donner le perimètre du Flocon de Koch à l'étape n.\n\n*Aidez vous de la figure ci-dessous pour comprendre l'évolution de l'aire entre deux itérations*\n![Image du triangle de sierpinski](http://img.over-blog-kiwi.com/1/93/65/56/20160116/ob_804ca5_flcon-iteration.png)"},{"metadata":{"trusted":true},"cell_type":"code","source":"def perimetreKoch(a,n):\n    if n==0 :\n        # code pour le cas de base \n        \n    else :\n        # votre code où apparaîtra fonction(n-1,...)\n        \n\n","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"# test pour a=50, n=3\nperimetreKoch(50,3)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"# test pour a=50, n=100\nperimetreKoch(50,100)","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"**Question:** Que peut-on déduire du périmètre du Flocon de Koch (lorsque n tend vers l'infini) ?\n\n**Réponse:** "},{"metadata":{},"cell_type":"raw","source":""},{"metadata":{},"cell_type":"markdown","source":"Pour calculer l'aire il est plus facile d'utiliser une boucle avec des variables qui comptes le nombres de triangles qu'on rajoute à chaque étape et la largeur de leur base.\n\n2. Complétez le code de la fonction pour donner l'aire du Flocon de Koch à l'étape n."},{"metadata":{"trusted":true},"cell_type":"code","source":"def aireKoch(a,n):\n    A = ...\n    l = ...\n    c = ... # le nombre de carré\n    for i in range(n):\n        A = ...\n        l = ...\n        c = ...\n        \n    return A","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"# test pour a=50, n=3\naireKoch(50,3)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"# test pour a=50, n=100\naireKoch(50,100)","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"**Question:**  Que peut-on déduire de l'aire du Flocon de Koch (lorsque n tend vers l'infini) ?\n\n**Réponse:** "},{"metadata":{"trusted":true},"cell_type":"raw","source":""},{"metadata":{},"cell_type":"markdown","source":"### <h2 class=\"alert alert-info\">3. une autre images fractale: le triangle de Sierpinski</h2>\n\nLa courbe de Koch est une fractale reposant sur la construction récursive suviante :\n\n![Image du triangle de sierpinski](https://githepia.hesge.ch/info_sismondi/3AM.OS/-/raw/main/recursivite/images/triangle_de_sierpinski.png)\n\n1. Écrire une fonction `triangle(a)` qui permet de dessiner un triangle de longeur `a`, puis une fonction `etape2(a)` qui permet de dessiner (pas de récursivité ici) la figure correspondant à l'étape 2 en utilisant la fonction `triangle(a)`.\n"},{"metadata":{"trusted":true},"cell_type":"code","source":"import turtle as tt\n\ndef triangle(a):\n    ...\n\ndef etape2(a) :\n    ...\n\n\netape2(200)\ntt.done()","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"2. En vous inspirant de la logique du code de la fonction précédente (en la \"rendant récursive\"), écrire une fonction `triangle_sierpinski(a, n)` récursive qui :\n\n    - remplace les appels à triangle par des appels récursifs pour n>=1\n    - trace un simple triangle lorsque n=0\n"},{"metadata":{"trusted":true},"cell_type":"code","source":"import turtle as tt\n\n\ndef triangle_sierpinski(a, n) :\n    ...\n    \n\ntt.hideturtle()  # on cache la tortue\ntt.speed(0) # tortue rapide\n\ntriangle_sierpinski( 200 , 7)\ntt.done()","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"### <h2 class=\"alert alert-info\">4. Décomposition d'un entier positif en somme d'au plus quatre carrés</h2>\n\nLe théorème des quatre carrés de Lagrange affirme que tout nombre entier positif `n` peut s'écrire comme la somme d'au plus quatre carrés.\n\nPar exemple, $1871 = 1 + 25 + 81 + 1764 = 1^2 + 5^2 + 9^2 + 42^2$.\n\nPour afficher une possibilité on peut donner l'algorithme suivant qui permet de décomposer un entier positif `n` en une somme d'au plus quatre carrés.\n"},{"metadata":{},"cell_type":"markdown","source":"<div style='background-color: #f7bd83;\n    border-radius: 0.5em;\n    padding: 1em;\n    margin: 0em 2em 0em 2em'>\n\n<p><b>Algorithme de décomposition de l'entier positif <code>n</code> en une somme d'au plus quatre carrés</b></p>\n<p><b>Début</b></p>\n<p STYLE=\"padding:0 0 0 40px;\">Si <code>n</code> est le carré d'un entier alors</p>\n<p STYLE=\"padding:0 0 0 80px;\">Retourner un tableau contenant uniquement l'élément <code>n</code></p>\n    <p STYLE=\"padding:0 0 0 40px;\">Sinon</p>\n    <p STYLE=\"padding:0 0 0 80px;\"><code>liste_carres</code> ← tableau contenant la liste décroissante des nombres compris entre 1 et <code>n</code> qui sont des carrés d'entiers</p>\n<p STYLE=\"padding:0 0 0 80px;\">Pour chaque élément <code>carre</code> de <code>liste_carres</code> faire</p>\n<p STYLE=\"padding:0 0 0 120px;\"><code>decompo</code> ← liste renvoyé par <code>decomposition_carres(n - carre)</code> auquel on ajoute l'élément <code>carre</code> à la fin</p>\n<p STYLE=\"padding:0 0 0 120px;\">Si longueur(<code>decompo</code>) $\\leq$ 4 alors</p>\n<p STYLE=\"padding:0 0 0 160px;\">Retourner <code>decompo</code></p>\n    <p><b>Fin</b></p>\n        \n</div>"},{"metadata":{},"cell_type":"markdown","source":"**(1)** 💻 Définir une fonction `est_carre` qui prend en paramètre d'entrée un entier positif `n` et qui renvoie `True` si `n` est le carré d'un entier et `False` sinon."},{"metadata":{"trusted":true},"cell_type":"code","source":"def est_carre(n):\n    if ...:\n        return ...\n    else:\n        return ...","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"# Test\nnb = 9\nprint(nb, \"est-il un carre ? \", est_carre(nb))\nnb = 10\nprint(nb, \"est-il un carre ? \", est_carre(nb))","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"**(2)** 💻 Définir une fonction `liste_carres_entiers` qui prend en paramètre d'entrée un entier positif `n` et qui renvoie la liste décroissante des entiers compris entre 1 et `n` et qui sont des carrés d'entiers."},{"metadata":{"trusted":true},"cell_type":"code","source":"def liste_carres_entiers(n):\n    L = ...\n    for k in reversed(...):\n        if ...:\n            ...\n    return L","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"# Test\nlistes_carres = liste_carres_entiers(100)\nprint(listes_carres) # doit afficher [100, 81, 64, 49, 36, 25, 16, 9, 4, 1]","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"**(3)** 💻 Implémenter la fonction `decomposition_carres` qui prend en paramètre d'entrée un entier positif `n` et qui renvoie, sous forme de tableau de longueur inférieure ou égale à 4, une décomposition de `n` en somme de carrés d'entiers."},{"metadata":{"trusted":true},"cell_type":"code","source":"def decomposition_carres(n):\n    ...","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"# Test\nnb = 1871\nprint(\"La décomposition de \",nb, \"est : \", decomposition_carres(nb))","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"**(4)** ✏️ Donner une décomposition en somme d'au plus quatre carrés pour les entiers $300$, $1789$, $2021$ et $12345$."},{"metadata":{"trusted":true},"cell_type":"code","source":"","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"**(5)** ✏️ Proposer une fonction non récursive `decomposition_carres2(n)` qui permet de calculer la décomposition et tester la fonction"},{"metadata":{"trusted":true},"cell_type":"code","source":"def decomposition_carres2(n):\n    listes_carres = ...\n    for ...:\n        for ...:\n            for ...:\n                for ...:\n                    if ... :\n                        return ...","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"# Test\nnb = 1871\nprint(\"La décomposition de \",nb, \"est : \", decomposition_carres2(nb))","execution_count":null,"outputs":[]}],"metadata":{"kernelspec":{"display_name":"Python 3.8.1 64-bit ('python38': conda)","language":"python","name":"python38164bitpython38conda56991d5ad1414e06a4dcd344400cf456"}},"nbformat":4,"nbformat_minor":2}
\ No newline at end of file

recursivite/recursivite2_corrige.ipynb

+{"cells":[{"metadata":{},"cell_type":"markdown","source":"<h1 class=\"alert alert-success\">Complément sur la récursivité en programmation</h2>"},{"metadata":{},"cell_type":"markdown","source":"## <h2 class=\"alert alert-info\"> 1. Introduction à la récursivité</h2>\nUn algorithme récursif est un algorithme qui résout un problème en calculant des solutions d'instances plus petites du même problème. "},{"metadata":{},"cell_type":"markdown","source":"<h2 class=\"alert alert-success\"> Rappel : Algorithme pour implémenter une fonction récursive</h2>\n\n- Etape 1 - Définir le cas de base : Identifier le cas le plus simple pour lequel une solution est connue.\n\n- Etape 2 - Définir la récursion : Définir le problème en termes de plus petits sous-problèmes et appeler la fonction pour les résoudre.\n\n- Etape 3 - Définir la fin : S'assurer que la récursion va bien arriver au cas de base pour éviter d'avoir une boucle infinie."},{"metadata":{},"cell_type":"markdown","source":"<h2 class = \"alert alert-success\"> Structure d'un code récursif en python :</h2>"},{"metadata":{},"cell_type":"raw","source":"def fonction(n, ...):\n    if n==0 :\n        # code pour le cas de base\n    else :\n        # votre code où apparaîtra fonction(n-1,...)"},{"metadata":{},"cell_type":"markdown","source":"### <h2 class=\"alert alert-info\">2. Fractales : courbe de Koch Correction</h2>\n\nLa courbe de Koch est une fractale reposant sur la construction récursive suviante :\n1. Étape 1 : Tracer un segment de longueur a. \n\n![Image de losange](https://githepia.hesge.ch/info_sismondi/3AM.OS/-/raw/main/recursivite/koch_0.png)\n\n2. Étape 2 : Diviser le segment en 3 parties de même longueur. Construire un triangle équilatéral ayant pour base le segment médian de la première étape, et en supprimer la base.\n![Image de losange](https://githepia.hesge.ch/info_sismondi/3AM.OS/-/raw/main/recursivite/koch_1.png)\n\n3. Étape 3 : Reprendre l'étape 2 sur chacun des segments créés.\n![Image de losange](https://githepia.hesge.ch/info_sismondi/3AM.OS/-/raw/main/recursivite/koch_2.png)\n\n4. Et ainsi de suite...\n![Image de losange](https://githepia.hesge.ch/info_sismondi/3AM.OS/-/raw/main/recursivite/koch_3.png)"},{"metadata":{},"cell_type":"markdown","source":"On peut construire récursivement cette courbe. \n\nLa fonction de tracer prend deux paramètres en entrée :\n* la longeur $a$ du segment.\n* l'étape $n$ de \"profondeur\" de récursivité. \n\nPar exemple, à la profondeur $n=0$, on trace un simple segment : ceci constituera le cas de base et la condition d'arrêt des appels récursifs. À la profondeur $n=1$, le tracé donne la figure de l'étape 2."},{"metadata":{},"cell_type":"markdown","source":"<h2 class=\"alert alert-warning\">Courbe de Koch : fonction récursive.</h2>\n\nEn vous inspirant de la logique du code de la fonction précédente (en la \"rendant récursive\"), écrire une fonction koch(a, n) récursive qui :\n\n- prend comme paramètres un nombre entier a représentant la longueur du segment et un entier n égal au nombre de récursions souhaité.\n- construit la courbe de Koch en divisant récursivement chacun des segments\n\n*Rappel* : si n=0, le tracé est un simplement segment de longueur a."},{"metadata":{},"cell_type":"markdown","source":"<div class = \"alert alert-block alert-success\"> \n\n### Solution\n</div>"},{"metadata":{"trusted":true},"cell_type":"code","source":"import turtle as tt # import du module turtle\n\ntt.speed(10)\ntt.penup()\ntt.setposition(-300, 0) \ntt.pendown()\n\ndef koch(a, n):\n    if n == 0:\n        tt.forward(a)\n    else:\n        koch(a/3, n-1)\n        tt.left(60)\n        koch(a/3, n-1)\n        tt.right(120)\n        koch(a/3, n-1)\n        tt.left(60)\n        koch(a/3, n-1)\n\nkoch(360, 3)\n\ntt.done()","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"<h2 class=\"alert alert-warning\">Flocon de Koch : fonction récursive</h2>\n\n\nPour obtenir le flocon de Koch:\n\n<figure> \n    <img title='Koch snowflake' \n         src=\"https://isquared.digital/assets/images/koch_snowflake.png\"\n         width='600px' >\n    <figcaption>Etapes 0, 1, 2, 3 et 4</figcaption>\n</figure>\n\nIl suffit d'écrire une fonction `floconkoch(a,n)` qui va itérer  `koch(a,n)` avec la bonne rotation."},{"metadata":{"trusted":true},"cell_type":"code","source":"a = 180\n\ntt.speed(10)\ntt.penup()\ntt.setposition(-a/2, a/3) \ntt.pendown()\n\n\ndef floconkoch(a, n):\n    for i in range(3):\n        koch(a, n)\n        tt.right(120)\n\n# test pour afficher l'étape 3\nflocon(a, 3)\n\ntt.penup()\ntt.home()\n\ntt.done()","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"### <h2 class=\"alert alert-info\">2. Fractales de Koch et perimètres </h2>\n\n1. Complétez ce code récursif pour donner le perimètre du Flocon de Koch à l'étape n.\n\n*Aidez vous de la figure ci-dessous pour comprendre l'évolution de l'aire entre deux itérations*\n![Image du triangle de sierpinski](http://img.over-blog-kiwi.com/1/93/65/56/20160116/ob_804ca5_flcon-iteration.png)"},{"metadata":{"trusted":true},"cell_type":"code","source":"def perimetreKoch(a,n):\n    if n==0 :\n        # code pour le cas de base \n        return 3*a\n    else :\n        # votre code où apparaîtra fonction(n-1,...)\n        return (4/3)*perimetreKoch(a,n-1)\n\n","execution_count":51,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"# test pour a=50, n=3\nperimetreKoch(50,3)","execution_count":52,"outputs":[{"output_type":"execute_result","execution_count":52,"data":{"text/plain":"355.5555555555555"},"metadata":{}}]},{"metadata":{"trusted":true},"cell_type":"code","source":"# test pour a=50, n=100\nperimetreKoch(50,100)","execution_count":53,"outputs":[{"output_type":"execute_result","execution_count":53,"data":{"text/plain":"467697361531188.8"},"metadata":{}}]},{"metadata":{},"cell_type":"markdown","source":"**Question:** Que peut-on déduire du périmètre du Flocon de Koch (lorsque n tend vers l'infini) ?\n\n**Réponse:** "},{"metadata":{},"cell_type":"raw","source":""},{"metadata":{},"cell_type":"markdown","source":"Pour calculer l'aire il est plus facile d'utiliser une boucle avec des variables qui comptes le nombres de triangles qu'on rajoute à chaque étape et la largeur de leur base.\n\n2. Complétez le code de la fonction pour donner l'aire du Flocon de Koch à l'étape n."},{"metadata":{"trusted":true},"cell_type":"code","source":"def aireKoch(a,n):\n    A = (3**0.5 / 4 * a**2)\n    l = a / 3\n    c = 3 # le nombre de carré\n    for i in range(n):\n        A = A + c * (3**0.5 / 4 * l**2)\n        l = l / 3\n        c = c * 3\n        \n    return A","execution_count":55,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"# test pour a=50, n=3\naireKoch(50,3)","execution_count":56,"outputs":[{"output_type":"execute_result","execution_count":56,"data":{"text/plain":"1603.7507477489605"},"metadata":{}}]},{"metadata":{"trusted":true},"cell_type":"code","source":"# test pour a=50, n=100\naireKoch(50,100)","execution_count":57,"outputs":[{"output_type":"execute_result","execution_count":57,"data":{"text/plain":"1623.7976320958232"},"metadata":{}}]},{"metadata":{},"cell_type":"markdown","source":"**Question:**  Que peut-on déduire de l'aire du Flocon de Koch (lorsque n tend vers l'infini) ?\n\n**Réponse:** "},{"metadata":{"trusted":true},"cell_type":"raw","source":""},{"metadata":{},"cell_type":"markdown","source":"### <h2 class=\"alert alert-info\">3. une autre images fractale: le triangle de Sierpinski</h2>\n\nLa courbe de Koch est une fractale reposant sur la construction récursive suviante :\n\n![Image du triangle de sierpinski](https://githepia.hesge.ch/info_sismondi/3AM.OS/-/raw/main/recursivite/images/triangle_de_sierpinski.png)\n\n1. Écrire une fonction `triangle(a)` qui permet de dessiner un triangle de longeur `a`, puis une fonction `etape2(a)` qui permet de dessiner (pas de récursivité ici) la figure correspondant à l'étape 2 en utilisant la fonction `triangle(a)`.\n"},{"metadata":{"trusted":true},"cell_type":"code","source":"import turtle as tt\n\ndef triangle(a):\n    for _ in range(3) :\n        tt.forward(a)\n        tt.left(120)\n\ndef etape2(a) :\n    for _ in range(3) :\n        triangle(a/2)\n        tt.forward(a)\n        tt.left(120)\n\n\netape2(200)\ntt.done()","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"2. En vous inspirant de la logique du code de la fonction précédente (en la \"rendant récursive\"), écrire une fonction `triangle_sierpinski(a, n)` récursive qui :\n\n    - remplace les appels à triangle par des appels récursifs pour n>=1\n    - trace un simple triangle lorsque n=0\n"},{"metadata":{"trusted":true},"cell_type":"code","source":"import turtle as tt\n\n\ndef triangle_sierpinski(a, n) :\n    if n > 0 :\n        for _ in range(3) :\n            triangle_sierpinski(a/2, n-1)\n            tt.forward(a)\n            tt.left(120)\n\ntt.hideturtle()  # on cache la tortue\ntt.speed(0) # tortue rapide\n\ntriangle_sierpinski( 200 , 7)\ntt.done()","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"### <h2 class=\"alert alert-info\">4. Décomposition d'un entier positif en somme d'au plus quatre carrés</h2>\n\nLe théorème des quatre carrés de Lagrange affirme que tout nombre entier positif `n` peut s'écrire comme la somme d'au plus quatre carrés.\n\nPar exemple, $1871 = 1 + 25 + 81 + 1764 = 1^2 + 5^2 + 9^2 + 42^2$.\n\nPour afficher une possibilité on peut donner l'algorithme suivant qui permet de décomposer un entier positif `n` en une somme d'au plus quatre carrés.\n"},{"metadata":{},"cell_type":"markdown","source":"<div style='background-color: #f7bd83;\n    border-radius: 0.5em;\n    padding: 1em;\n    margin: 0em 2em 0em 2em'>\n\n<p><b>Algorithme de décomposition de l'entier positif <code>n</code> en une somme d'au plus quatre carrés</b></p>\n<p><b>Début</b></p>\n<p STYLE=\"padding:0 0 0 40px;\">Si <code>n</code> est le carré d'un entier alors</p>\n<p STYLE=\"padding:0 0 0 80px;\">Retourner un tableau contenant uniquement l'élément <code>n</code></p>\n    <p STYLE=\"padding:0 0 0 40px;\">Sinon</p>\n    <p STYLE=\"padding:0 0 0 80px;\"><code>liste_carres</code> ← tableau contenant la liste décroissante des nombres compris entre 1 et <code>n</code> qui sont des carrés d'entiers</p>\n<p STYLE=\"padding:0 0 0 80px;\">Pour chaque élément <code>carre</code> de <code>liste_carres</code> faire</p>\n<p STYLE=\"padding:0 0 0 120px;\"><code>decompo</code> ← liste renvoyé par <code>decomposition_carres(n - carre)</code> auquel on ajoute l'élément <code>carre</code> à la fin</p>\n<p STYLE=\"padding:0 0 0 120px;\">Si longueur(<code>decompo</code>) $\\leq$ 4 alors</p>\n<p STYLE=\"padding:0 0 0 160px;\">Retourner <code>decompo</code></p>\n    <p><b>Fin</b></p>\n        \n</div>"},{"metadata":{},"cell_type":"markdown","source":"**(1)** 💻 Définir une fonction `est_carre` qui prend en paramètre d'entrée un entier positif `n` et qui renvoie `True` si `n` est le carré d'un entier et `False` sinon."},{"metadata":{"trusted":true},"cell_type":"code","source":"def est_carre(n):\n    if round(n**0.5)**2 == n:\n        return True\n    else:\n        return False","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"# Test\nnb = 9\nprint(nb, \"est-il un carre ? \", est_carre(nb))\nnb = 10\nprint(nb, \"est-il un carre ? \", est_carre(nb))","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"**(2)** 💻 Définir une fonction `liste_carres_entiers` qui prend en paramètre d'entrée un entier positif `n` et qui renvoie la liste décroissante des entiers compris entre 1 et `n` et qui sont des carrés d'entiers."},{"metadata":{"trusted":true},"cell_type":"code","source":"def liste_carres_entiers(n):\n    L = []\n    for k in reversed(range(1, n+1)):\n        if est_carre(k):\n            L.append(k)\n    return L","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"# Test\nlistes_carres = liste_carres_entiers(100)\nprint(listes_carres) # doit afficher [100, 81, 64, 49, 36, 25, 16, 9, 4, 1]","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"**(3)** 💻 Implémenter la fonction `decomposition_carres` qui prend en paramètre d'entrée un entier positif `n` et qui renvoie, sous forme de tableau de longueur inférieure ou égale à 4, une décomposition de `n` en somme de carrés d'entiers."},{"metadata":{"trusted":true},"cell_type":"code","source":"def decomposition_carres(n):\n    if est_carre(n):\n        return [n]\n    else:\n        listes_carres = liste_carres_entiers(n)\n        for carre in listes_carres:\n            decompo = decomposition_carres(n - carre) + [carre]\n            if len(decompo) <= 4:\n                return decompo","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"# Test\nnb = 1871\nprint(\"La décomposition de \",nb, \"est : \", decomposition_carres(nb))","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"**(4)** ✏️ Donner une décomposition en somme d'au plus quatre carrés pour les entiers $300$, $1789$, $2021$ et $12345$."},{"metadata":{"trusted":true},"cell_type":"code","source":"def print_decompoision(n, decompo):\n    s = str(n)+ \" = \"\n    for n in decompo:\n        s = s + str(int(n**0.5))+\"² + \"\n    s = s[:-3]\n    print(s)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"nb = 1871\nprint_decompoision(nb, decomposition_carres(nb))\nnb = 300\nprint_decompoision(nb, decomposition_carres(nb))\nnb = 1789\nprint_decompoision(nb, decomposition_carres(nb))\nnb = 2021\nprint_decompoision(nb, decomposition_carres(nb))\nnb = 12345\nprint_decompoision(nb, decomposition_carres(nb))","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"**(5)** ✏️ Proposer une fonction non récursive `decomposition_carres2(n)` qui permet de calculer la décomposition et tester la fonction"},{"metadata":{"trusted":true},"cell_type":"code","source":"def decomposition_carres2(n):\n    listes_carres = liste_carres_entiers(n)\n    listes_carres = listes_carres + [0]\n    for carre1 in listes_carres:\n        for carre2 in listes_carres:\n            for carre3 in listes_carres:\n                for carre4 in listes_carres:\n                    if carre1 + carre2 +carre3 +carre4 ==n :\n                        return [carre1, carre2, carre3, carre4]","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"nb = 1871\nprint_decompoision(nb, decomposition_carres2(nb))\nnb = 300\nprint_decompoision(nb, decomposition_carres2(nb))\nnb = 1789\nprint_decompoision(nb, decomposition_carres2(nb))\nnb = 2021\nprint_decompoision(nb, decomposition_carres2(nb))\nnb = 12345\nprint_decompoision(nb, decomposition_carres2(nb))","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"","execution_count":null,"outputs":[]}],"metadata":{"kernelspec":{"display_name":"Python 3.8.1 64-bit ('python38': conda)","language":"python","name":"python38164bitpython38conda56991d5ad1414e06a4dcd344400cf456"}},"nbformat":4,"nbformat_minor":2}
\ No newline at end of file