{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exercices du livre - Chapitre 5\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercice 1 ✓\n",
    "\n",
    "  Écrire une fonction qui reçoit une liste en paramètre et qui retourne une liste de toutes les sous-listes possibles.  \n",
    "Par exemple, les sous-listes de `[1, 2, 3]` sont : `[[], [1], [2], [3], [1, 2], [2, 3], [1, 2, 3]]`  \n",
    "Le programme principal vérifiera les sous-listes de l’exemple ci-dessus."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Exercice 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercice 2 ✓✓\n",
    "\n",
    "  Écrire un programme qui approxime par défaut la valeur de la constante mathématique $e$, pour un ordre $n$ assez grand, en utilisant la formule d’Euler :\n",
    "  $$e\\approx\\sum_{i=0}^n\\frac{1}{i!}$$\n",
    "  Pour cela, définissez la fonction `factorielle()` et, dans votre programme principal, saisissez l’ordre $n$ et affichez l’approximation correspondante du nombre d'Euler $e$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Exercice 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercice 3 ✓\n",
    "\n",
    "  Écrire un module contenant une fonction qui reçoit un mot de passe en paramètre et qui retourne `True` si le mot de passe :\n",
    "\n",
    "- comporte au moins 8 caractères ;\n",
    "- contient au moins une majuscule ;\n",
    "- contient au moins une minuscule ;\n",
    "- contient au moins un chiffre.\n",
    "\n",
    "Dans le cas contraire, la fonction retourne `False`.  \n",
    "Écrire un programme principal qui saisit un mot de passe et le teste."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Exercice 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercice 4 ✓✓\n",
    "\n",
    "  Le code Morse permet de transmettre un texte à l’aide de séries d’impulsions courtes et\n",
    "longues. Inventé en 1832 pour la télégraphie, ce codage de caractères assigne à chaque lettre\n",
    "et chiffre un code unique.\n",
    "\n",
    "![morse](../data/morse_40.png)\n",
    "\n",
    "Écrire un programme qui :\n",
    "\n",
    "- définit un dictionnaire ayant pour clé les lettres de l’alphabet et pour valeur leur code correspondant ;\n",
    "- définit une fonction qui reçoit un message en clair et retourne le message en Morse ;\n",
    "- valide cette fonction en affichant le code Morse de `SOS` ;\n",
    "- entre un message tant que la saisie n’est pas vide et affiche son code Morse."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercice 4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercice 5 ✓✓✓\n",
    "\n",
    "  La **droite des moindres carrés** est la droite qui approxime au mieux un nuage de points allongé.\n",
    "\n",
    "L'équation de cette droite est $y = m \\times x + b$, où $m$, le coefficient directeur, et $b$, le terme constant sont donnés par :\n",
    "\n",
    "$$m = \\frac{\\sum x \\times y - \\frac{(\\sum x)\\times(\\sum y)}{n}}{\\sum x^2 - \\frac{(\\sum x)^2}{n}}$$\n",
    "\n",
    "$$b = \\overline{y} - m \\times \\overline{x}$$\n",
    "\n",
    "Les symboles $\\overline{x}$ et $\\overline{y}$ représentent les valeurs moyennes des abscisses et des ordonnées, et $n$ le nombre de points du nuage.  \n",
    "\n",
    "Écrire un programme principal qui saisit une liste de points. Chaque entrée doit saisir deux flottants, abscisse et ordonnée, séparés par un espace, jusqu'à l'entrée d'une ligne vide qui interrompt les saisies. Pour rendre le source plus lisible, on pourra coder un point $p = (x, y)$ par un type `namedtuple` du module standard `collections`. Cela permet d'écrire simplement :\n",
    "\n",
    "```python\n",
    ">>> from collections import namedtuple\n",
    ">>> Point = namedtuple('Point', ['x', 'y'])  # définition du type Point\n",
    ">>> p = Point(1.2, 3.4)                      # affectation d'un point\n",
    ">>> nuage = []                               # affectation d'une liste\n",
    ">>> p.x, p.y                                 # utilisation des composantes\n",
    "(1.2, 3.4)\n",
    ">>> nuage.append(p)                          # à faire dans une boucle de saisie\n",
    "```\n",
    "Écrire une fonction qui reçoit le nuage et retourne le coefficient directeur, et une fonction qui reçoit le nuage et le coefficient directeur et retourne le coefficient constant.  \n",
    "Dans le programme principal, afficher la droite des moindres carrés trouvée. Par exemple, si l'utilisateur entre les trois points : $[(1, 1), (2, 2.1), (3, 2.9)]$, le programme doit afficher :\n",
    "$$y = 0.95x + 0.1$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercice 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercice 6 ✓✓\n",
    "\n",
    "  On veut classer les rationnels suivant leur *ordre* (où l'*ordre* est un entier qui vaut : `numérateur + dénominateur`) dans une liste de tuples `(num, den)`. On initialise la liste à l’ordre 1 : `[(0, 1)]`, puis à l’ordre 2 on ajoute `(1, 1)` , etc. On n’a pas mis (0, 2) déjà inclus sous la forme (0, 1). **On n’ajoute donc que les tuples sous leur forme réduite**. Pensez à utiliser la fonction `math.gcd()` pour réduire les fractions rationnelles.  \n",
    "  \n",
    "Écrire un module contenant deux fonctions : `maj(couple, liste)` qui met à jour la liste ordonnée des rationnels, et `ajout_ordre_suivant(liste)` qui enrichit la liste de l’ordre suivant.  \n",
    "\n",
    "Écrire un programme principal qui, en utilisant les fonctions du module, répond aux questions :\n",
    "- Quel est le 62<sup>e</sup> terme de la liste ?\n",
    "- Quel est le rang du rationnel `9/5` ?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercice 6"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
