boucles2.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Boucles: Algorithmique de base\n",
    "\n",
    "Dans le notebook précédent on a vu comment parcourir un intervalle de nombres, et afficher les nombres. On a aussi vu des boucles conditionnelles très simples.\n",
    "\n",
    "Ici on va voir des cas d'utilisation plus pratiques des boucles inconditionnelles: trouver un élément, compter des éléments, faire une somme ou un produit.\n",
    "\n",
    "## Trouver un élément dans une liste\n",
    "\n",
    "Le problème général de trouver un élément dans une liste est très répandu, et sujet à une erreur très classique.\n",
    "\n",
    "Pour l'instant, comme \"liste\" on va simplement prendre un intervalle de nombres, qu'on sait maintenant parcourir avec une boucle ```for```.\n",
    "\n",
    "#### Exemple 6: trouver un multiple de 41\n",
    "**Question** : Y a-t-il un multiple de 41 dans l'intervalle \\[191, 207\\]?\n",
    "\n",
    "Pour répondre à cette question, on va parcourir l'intervalle et chercher un nombre qui répond à cette condition.\n",
    "\n",
    "La boucle for pour parcourir l'intervalle (on va juste afficher les nombres):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "191\n",
      "192\n",
      "193\n",
      "194\n",
      "195\n",
      "196\n",
      "197\n",
      "198\n",
      "199\n",
      "200\n",
      "201\n",
      "202\n",
      "203\n",
      "204\n",
      "205\n",
      "206\n",
      "207\n"
     ]
    }
   ],
   "source": [
    "for (int i=191; i<=207; i++){\n",
    "    System.out.println(i);\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ok, on a maintenant la liste de nombres. Maintenant dans cette liste on va voir s'il y a un multiple de 41. Pour savoir si un nombre est multiple de 41, on utilise l'opérateur modulo: si on divise un nombre par 41 et que le reste est zéro, alors le nombre est multiple de 41. \n",
    "\n",
    "Voici le code pour lire un nombre au clavier et tester si il est multiple de 41:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import java.util.Scanner;\n",
    "Scanner clavier = new Scanner(System.in);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Entrer un nombre:\n",
      "534\n",
      "534 n'est pas multiple de 41\n"
     ]
    }
   ],
   "source": [
    "System.out.println(\"Entrer un nombre:\");\n",
    "int nombre = clavier.nextInt();\n",
    "if (nombre%41==0){\n",
    "    System.out.println(nombre +\" est multiple de 41\");\n",
    "} else {\n",
    "    System.out.println(nombre +\" n'est pas multiple de 41\");\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pour savoir si un nombre dans la liste au dessus est multiple de 41, on peut tous les tester. Pour cela, on place le test à l'intérieur de la boucle, et on remplace le ```nombre``` dans le test par ```i```, qui prend successivement toutes les valeurs qu'on veut tester:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "191 n'est pas multiple de 41\n",
      "192 n'est pas multiple de 41\n",
      "193 n'est pas multiple de 41\n",
      "194 n'est pas multiple de 41\n",
      "195 n'est pas multiple de 41\n",
      "196 n'est pas multiple de 41\n",
      "197 n'est pas multiple de 41\n",
      "198 n'est pas multiple de 41\n",
      "199 n'est pas multiple de 41\n",
      "200 n'est pas multiple de 41\n",
      "201 n'est pas multiple de 41\n",
      "202 n'est pas multiple de 41\n",
      "203 n'est pas multiple de 41\n",
      "204 n'est pas multiple de 41\n",
      "205 est multiple de 41\n",
      "206 n'est pas multiple de 41\n",
      "207 n'est pas multiple de 41\n"
     ]
    }
   ],
   "source": [
    "for (int i=191; i<=207; i++){\n",
    "    if (i%41==0){\n",
    "        System.out.println(i +\" est multiple de 41\");\n",
    "    } else {\n",
    "        System.out.println(i +\" n'est pas multiple de 41\");\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En lisant ces résultats à l'écran, on peut voir qu'un nombre dans l'intervalle (205) est multiple de 41. Mais dans le contexte d'un programme plus long, on voudrait pouvoir faire d'autres calculs en utilisant ces informations: soit l'information que oui, l'intervalle contient bien un multiple de 41 (information de type booléenne) ou bien l'information que l'élément de la liste qui correspond à la condition est le nombre 205 (information de type numérique).\n",
    "\n",
    "La première est celle qui a tendance a causer des erreurs.  On définit donc une variable booléenne ```trouvé```, et on voudrait qu'après la boucle ```trouvé``` soit ```true``` si l'intervalle contient un multiple de 41. La première intuition est d'assigner le résultat du \"test\" dans la boucle à la variable:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "L'intervalle ne contient pas de multiple de 41!\n"
     ]
    }
   ],
   "source": [
    "boolean trouvé;\n",
    "for (int i=191; i<=207; i++){\n",
    "    if (i%41==0){\n",
    "        trouvé=true;\n",
    "    } else {\n",
    "        trouvé=false;\n",
    "    }\n",
    "}\n",
    "\n",
    "if (trouvé){\n",
    "    System.out.println(\"L'intervalle contient bien un multiple de 41!\");\n",
    "} else {\n",
    "    System.out.println(\"L'intervalle ne contient pas de multiple de 41!\");\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Que se passe-t-il?\n",
    "\n",
    "En fait si on détaille bien ce qui se passe, pour chaque valeur de i on effectue le test et on assigne un valeur à ```trouvé```. La valeur de ```trouvé``` après la boucle est donc la valeur obtenue lors du *dernier* test (pour ```i = 207```. Et comme 207 n'est pas multiple de 41, la valeur de ```trouvé``` est ```false```.\n",
    "\n",
    "La solution ici est la suivante:\n",
    "Il faut initialiser ```trouvé``` à ```false``` (avant la boucle) et seulement modifier ```trouvé``` *si on trouve ce qu'on cherche*, c'est à dire ici, si un des nombres de l'intervalle est multiple de 41.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "L'intervalle contient bien un multiple de 41!\n"
     ]
    }
   ],
   "source": [
    "boolean trouvé=false;\n",
    "for (int i=191; i<=207; i++){\n",
    "    if (i%41==0){\n",
    "        trouvé=true;\n",
    "    } \n",
    "    // on ne met pas de clause else!\n",
    "}\n",
    "\n",
    "if (trouvé){\n",
    "    System.out.println(\"L'intervalle contient bien un multiple de 41!\");\n",
    "} else {\n",
    "    System.out.println(\"L'intervalle ne contient pas de multiple de 41!\");\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Cette fois, ça fonctionne correctement. Par souci d'efficacité, on peut aussi quitter la boucle une fois que le nombre est trouvé: continuer à parcourir l'intervalle ne changera rien. \n",
    "\n",
    "Note: Ceci serait surtout utile si on parcourait une liste très longue; ici on ne verra pas de différence. \n",
    "\n",
    "Pour quitter la boucle, on utilise une instruction ```break```:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "L'intervalle contient bien un multiple de 41!\n"
     ]
    }
   ],
   "source": [
    "boolean trouvé=false;\n",
    "for (int i=191; i<=207; i++){\n",
    "    if (i%41==0){\n",
    "        trouvé=true;\n",
    "        break; // ça y est, on l'a trouvé! on peut quitter la boucle.\n",
    "    } \n",
    "    // on ne met pas de clause else!\n",
    "}\n",
    "\n",
    "if (trouvé){\n",
    "    System.out.println(\"L'intervalle contient bien un multiple de 41!\");\n",
    "} else {\n",
    "    System.out.println(\"L'intervalle ne contient pas de multiple de 41!\");\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Quelques erreurs classiques:\n",
    "    * la clause ```else```, comme montré au dessus\n",
    "    * mettre le ```break``` en dehors du ```if```: on quitte alors la boucle dès le premier passage dans la boucle."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercice 6: Déterminer si un nombre est premier\n",
    "\n",
    "Comment détermine-t-on un si un nombre *n* est premier? On cherche dans l'intervalle \\[2, *n*/2 \\] un diviseur de *n*. Si on en trouve un, alors on sait que *n* n'est pas premier. Si on en trouve un, alors on sait que *n* est premier. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Scanner clavier = new Scanner(System.in);\n",
    "int nombre;\n",
    "do {\n",
    "    System.out.println(\"Entrer un entier supérieur à 2 pour déterminer s'il est premier:\");\n",
    "    nombre = clavier.nextInt();\n",
    "} while (...); // pour s'assurer que le nombre est supérieur à 2\n",
    "\n",
    "boolean trouvéDiviseur = ...;\n",
    "for ( ... ){ // boucle pour chercher des diviseurs dans l'intervalle [2, nombre/2]\n",
    "    \n",
    "}\n",
    "\n",
    "if (...){\n",
    "    System.out.println(nombre + \" est premier\");\n",
    "} else {\n",
    "    System.out.println(nombre + \" n'est pas premier\");\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exemple 7 : trouver un multiple de 41 (suite)\n",
    "\n",
    "Dans l'exemple précédent on cherchait un multiple de 41 dans un certain intervalle, et l'information qui nous intéressait était: y a-t-il un tel nombre dans l'intervalle? À présent on voudrait non seulement savoir s'il existe, mais s'il existe on veut récupérer sa valeur. \n",
    "\n",
    "Comme pour l'information \"trouvé\", on va créer une variable pour la recevoir (cette fois un entier), et lui donner une valeur dans la condition ```if``` qui indique qu'une valeur appropriée a été trouvée. Ici on nomme cette variable ```multiple```. La seule difficulté est de donner une valeur initiale à ```multiple```: si on ne trouve pas de multiple, alors la variable ne veut rien dire. Ici on l'initialise à 0. Comme on garde aussi la variable ```trouvé```, on n'aura pas de difficulté à interpréter la variable ```multiple```."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "L'intervalle contient bien un multiple de 41: 205\n"
     ]
    }
   ],
   "source": [
    "boolean trouvé=false;\n",
    "int multiple =0;\n",
    "for (int i=191; i<=207; i++){\n",
    "    if (i%41==0){\n",
    "        trouvé = true;\n",
    "        multiple = i;\n",
    "        break; // ça y est, on l'a trouvé! on peut quitter la boucle.\n",
    "    } \n",
    "    // on ne met pas de clause else!\n",
    "}\n",
    "\n",
    "if (trouvé){\n",
    "    System.out.println(\"L'intervalle contient bien un multiple de 41: \"+ multiple);\n",
    "} else {\n",
    "    System.out.println(\"L'intervalle ne contient pas de multiple de 41!\");\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Parfois, pour simplifier le code (ou dans le contexte d'une fonction, qu'on verra plus tard), on utilise une seule variable pour obtenir la valeur de l'élément cherché, et on utilise une valeur particulière pour le cas où on ne trouve pas d'élément:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "L'intervalle contient bien un multiple de 41: 205\n"
     ]
    }
   ],
   "source": [
    "int multiple =0;\n",
    "for (int i=191; i<=207; i++){\n",
    "    if (i%41==0){\n",
    "        multiple = i;\n",
    "        break; // ça y est, on l'a trouvé! on peut quitter la boucle.\n",
    "    } \n",
    "    // on ne met pas de clause else!\n",
    "}\n",
    "\n",
    "if (multiple!=0){\n",
    "    System.out.println(\"L'intervalle contient bien un multiple de 41: \"+ multiple);\n",
    "} else {\n",
    "    System.out.println(\"L'intervalle ne contient pas de multiple de 41!\");\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ici on initialise ```multiple``` à zéro, et si cette valeur n'a pas changé on suppose que l'élément cherché n'a pas été trouvé. Mais il faut faire attention: 0 est en fait multiple de 41, et si on cherchait des multiples de 41 dans l'intervalle \\[-10, 10\\], la valeur 0 serait la valeur du multiple trouvé, et non pas une indication qu'on l'a trouvé. Il faudrait alors utiliser une autre valeur initiale, ou simplement utiliser une deuxième variable comme au-dessus."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercice 7: trouver la racine entière d'un nombre\n",
    "\n",
    "On veut trouver la racine carrée d'un nombre *n*, si elle est entière. Pour ceci, on va simplement parcourir l'intervalle \\[0, n\\] et tester chaque nombre pour voir si il donne *n* quand on l'élève au carré. Si et quand on trouve la racine, il faut garder cette valeur pour l'afficher à la fin, comme dans l'exemple 7 quand on trouve le multiple de 41. Si on ne trouve pas de racine entière, on affichera un message indiquant cela. Utiliser le squelette de code suivant comme point de départ:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Scanner clavier = new Scanner(System.in);\n",
    "int nombre;\n",
    "do {\n",
    "    System.out.println(\"Entrer un entier positif pour obtenir sa racine carrée:\");\n",
    "    nombre = clavier.nextInt();\n",
    "} while (...); // pour s'assurer que le nombre est positif\n",
    "\n",
    "int racine = ...;\n",
    "for ( ... ){ // boucle pour chercher la racine dans l'intervalle [0, nombre]\n",
    "    \n",
    "}\n",
    "\n",
    "if (racine == ...){\n",
    "    System.out.println(\"La racine du nombre n'est pas entière\");\n",
    "} else {\n",
    "    System.out.println(\"La racine du nombre est \"+ racine);\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Compter des éléments\n",
    "\n",
    "Dans les exemples précédents le but était de trouver un élément dans une liste (un intervalle de nombres, mais ça se généralise à un ensemble quelconque qu'on puisse énumérer). Une extension immédiate est de *compter* le nombre d'élements correspondant à une specification.\n",
    "\n",
    "Par exemple, au lieu de se demander *si* un intervalle contient un ou plusieurs multiples de 41, on peut se demander *combien* de multiples de 41 l'intervalle contient. \n",
    "\n",
    "Comme dans le cas précédent on va introduire une variable pour enregistrer l'information; cette fois le compte sera stocké dans un entier. On appelle ce type de variable un *accumulateur*. Ensuite on parcourt l'intervalle, et le mécanisme pour effectivement compter les éléments sera d'ajouter 1 à la variable à chaque fois qu'on rencontre un élément: c'est comme une façon de compter sur ses doigts ou de faire des traits sur un papier. Enfin, il est clair qu'après avoir trouvé un élément on ne peut pas quitter la boucle.\n",
    "\n",
    "#### Exemple 8: Compter les multiples de 41 \n",
    "Comptons les multiples de 41 dans l'intervalle \\[128, 305\\] (dans l'intervalle précédent, il y en avait un seul):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "L'intervalle contient 4 multiples de 41!\n"
     ]
    }
   ],
   "source": [
    "int compte =0;\n",
    "for (int i=128; i<=305; i++){\n",
    "    if (i%41==0){\n",
    "        compte = compte+1;\n",
    "    } \n",
    "    // on ne met pas de clause else!\n",
    "}\n",
    "\n",
    "System.out.println(\"L'intervalle contient \" + compte + \" multiples de 41!\");\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercice 8: les multiples de 3 qui se terminent par 1\n",
    "\n",
    "On considère tous les multiples de 3 inférieurs à 10000. Combien d'entre eux se terminent par le chiffre 1?\n",
    "Pour le savoir, énumérer les multiples de 3 à l'aide d'une boucle (commencer à zéro et aller de 3 en 3) et compter ceux qui se terminent par le chiffre 1. Pour connaitre le chiffre des unités, utiliser l'opération modulo. Exemple: 438 % 10 = 8."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercice 9: les multiples de 3 qui se terminent par 1 (bis)\n",
    "On considère toujours les multiples de 3 inférieurs à 10000. On voudrait savoir quelle *proportion* de ces nombres se termine par 1. Il faut maintenant compter les multiples de 3 et, à part, ceux qui se terminent par 1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Faire une somme\n",
    "\n",
    "Faire la somme de quelques nombres est facile: on écrit ```a + b + c + d``` par exemple. Mais comment faire quand il y a beaucoup de nombres à additionner? Comment, par exemple, faire la somme des nombres de 1 à 100? ou la somme des multiples de 7 (inférieurs à 100)? ou la somme des carrés parfaits (inférieurs à 100)?\n",
    "\n",
    "La technique est très similaire à celle pour compter des éléments: on les énumère, on définit une variable pour garder la somme, et chaque fois qu'on rencontre un élément, au lieu d'ajouter un au compte, on ajoute la valeur de l'élément à la somme.\n",
    "\n",
    "#### Exemple 9: La somme des entiers jusqu'à 100:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Somme=5050\n"
     ]
    }
   ],
   "source": [
    "int somme =0;\n",
    "for (int i=1; i<=100; i++){\n",
    "    somme = somme + i;\n",
    "}\n",
    "System.out.println(\"Somme=\"+somme);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ici on a additionné tous les nombres de l'intervalle. Si on additionne seulement des nombres particuliers de cet intervalle (par exemple les multiples de 3 se terminant par le chiffre 1), on peut rajouter une condition pour identifier les éléments à additionner, comme on faisait pour les compter.\n",
    "\n",
    "#### Exemple 10: Somme des multiples de 3 inférieurs à 100 se terminant par le chiffre 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Somme des multiples de 3 finissant par 1 = 153\n"
     ]
    }
   ],
   "source": [
    "int somme3 = 0;\n",
    "for (int i=0;i<100;i=i+3){\n",
    "    if(i%10==1){\n",
    "        somme3 = somme3 + i;\n",
    "    }\n",
    "}\n",
    "System.out.println(\"Somme des multiples de 3 finissant par 1 = \" + somme3);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercice 10: Nombres parfaits\n",
    "Un nombre est dit *parfait* s'il est égal à la somme de ses diviseurs propres (propres = le nombre lui-même exclu). \n",
    "Par exemple, 6 est parfait: ses diviseurs propres sont 1,2, et 3, et 1+2+3=6.\n",
    "Remarquer qu'on inclut 1 comme diviseur.\n",
    "\n",
    "Comment déterminer si un nombre est parfait? On fait la somme de ses diviseurs et on compare avec le nombre lui-même.\n",
    "Pour cet exercice, on pourra adapter le code de l'exercice 6: au lieu de chercher un diviseur de *n*, cette fois on veut les lister tous et en faire la somme.\n",
    "\n",
    "Attention: pour un nombre parfait, on inclut 1 dans la somme, il faut donc commencer la boucle à 1 et non pas à 2."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Faire un produit\n",
    "\n",
    "Maintenant qu'on sait faire une somme, est-ce qu'on peut utiliser une technique similaire pour faire un produit? Comme pour une somme, il est facile de faire le produit d'un petit nombre de facteurs: on écrit ```a * b * c * d```.\n",
    "\n",
    "La réponse est oui: on peut utiliser la même technique. La seule différence est qu'il faut initialiser l'accumulateur à 1 au lieu de l'initialiser à zéro. \n",
    "\n",
    "#### Exemple 11: Factorielle\n",
    "La factorielle d'un nombre *n* est le produit de tous les nombres jusqu'à *n*: *n*! = 1 * 2 * 3 ... * n."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Entrer un nombre:\n",
      "7\n",
      "7! = 5040\n"
     ]
    }
   ],
   "source": [
    "Scanner clavier = new Scanner(System.in);\n",
    "System.out.println(\"Entrer un nombre:\");\n",
    "int n = clavier.nextInt();\n",
    "int produit = 1;\n",
    "for (int i = 1; i<=n;i++){ \n",
    "    produit = produit * i;\n",
    "}\n",
    "\n",
    "System.out.println(n + \"! = \"+produit);\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On vérifie:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5040"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1*2*3*4*5*6*7"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercice 11: Produit des diviseurs\n",
    "Sur le modèle de l'exercice 10, écrire du code pour calculer le *produit*  des diviseurs propres d'un nombre (lu au clavier). \n",
    "\n",
    "\n",
    "Note: ceci ne donne pas, en général, la décomposition du nombre en facteurs premiers.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Java",
   "language": "java",
   "name": "java"
  },
  "language_info": {
   "codemirror_mode": "java",
   "file_extension": ".jshell",
   "mimetype": "text/x-java-source",
   "name": "Java",
   "pygments_lexer": "java",
   "version": "14.0.1+7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}