02b - Booléens et instructions conditionnelles - Exercices.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#  Booléens et instructions conditionnelles - Exercices\n",
    "Exercices pour maîtriser la programmation conditionnelle ainsi qu'un premier pas vers les fonctions\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercice 1 - Les multiplications\n",
    "On souhaite faire un programme qui demande le produit de deux nombres entiers pris au hasard entre 0 et 10. Il devra afficher **`Bravo`** ou **`C'est faux`** suivant le cas.\n",
    "\n",
    "\n",
    "Le début du programme est donné (tirage de nombres aléatoires)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from random import randrange as alea  # Importation de la fonction 'alea' qui renvoie un nombre entier entre 0 et n-1\n",
    "\n",
    "premier = alea(11)\n",
    "deuxieme = alea(11)\n",
    "\n",
    "message = \"Combien font \"+str(premier)+\"×\"+str(deuxieme)+\" ? \"\n",
    "reponse = int(input(message))   # Cette ligne est susceptible de produire des erreurs d'exécution\n",
    "                                # si on fournit autre chose qu'un entier\n",
    "\n",
    "#~~ Taper le code manquant ci-dessous, puis exécuter le programme avec 'Maj-Entrée' ~~#\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "<!-- Solution\n",
    "\n",
    "\n",
    "from random import randrange as alea\n",
    "premier = alea(11)\n",
    "deuxieme = alea(11)\n",
    "message = \"Combien font \"+str(premier)+\"×\"+str(deuxieme)+\" ? \"\n",
    "reponse = int(input(message))\n",
    "if reponse == premier * deuxieme:\n",
    "    print(\"Bravo\")\n",
    "else:\n",
    "    print(\"C'est faux\")\n",
    "\n",
    "\n",
    "\n",
    "-->"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercice 2 - Manèges\n",
    "On souhaite faire un programme qui permet de savoir si un enfant peut monter dans un manège à Nigloland.\n",
    "\n",
    "Il existe plusieurs type de manèges :\n",
    "* T1 : Les manèges familiaux accessibles à tous (les moins d'1 m devant être accompagnés),\n",
    "* T2 : Les manèges pour les plus jeunes, accessibles aux enfants mesurant plus de 1 m,\n",
    "* T3 : les manèges à sensations pour les enfants mesurant plus de 1,20 m,\n",
    "* T4 : les manèges à sensations fortes pour les enfants mesurant plus de 1,40 m.\n",
    "\n",
    "Le programme doit demander la taille de l'enfant et afficher quel type de manège il peut faire.\n",
    "(Les données seront de type **`float`**.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# On va définir plusieurs variables qui auront un rôle de constante.\n",
    "T1, T2, T3, T4 = 0.0, 1.0, 1.2, 1.4\n",
    "# On utilisera T1, T2, T3 et T4 au lieu de leur valeur dans le code.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "<!-- Solution\n",
    "\n",
    "\n",
    "T1, T2, T3, T4 = 0.0, 1.0, 1.2, 1.4\n",
    "taille = float(input(\"Taille de l'enfant ?\"))\n",
    "if taille >= T4:\n",
    "    print(\"Tous les manèges sont accessibles.\")\n",
    "elif taille >= T3:\n",
    "    print(\"Les manèges à sensations fortes ne sont pas autorisés.\")\n",
    "elif taille >= T2:\n",
    "    print(\"Tous les manèges à sensations sont interdits.\")\n",
    "else:\n",
    "    print(\"L'enfant n'a accès qu'aux manèges familiaux et il doit être accompagné.\")\n",
    "\n",
    "\n",
    "-->"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercice 3 - Couleurs\n",
    "Compléter le programme suivant qui renvoie le message **`RGB`** ou **`CMYK`** en fonction d'une couleur choisie.\n",
    "<br>Dans le cas d'une réponse non attendue, afficher une erreur.\n",
    "\n",
    "Pour **`RGB`** sont valables :\n",
    "* rouge, red,\n",
    "* vert, green,\n",
    "* bleu, blue.\n",
    "\n",
    "\n",
    "Pour **`CMYK`** sont valables :\n",
    "* cyan, bleu_ciel,\n",
    "* magenta, rose,\n",
    "* jaune, yellow,\n",
    "* noir, black.\n",
    "\n",
    "Note : RGB représente la synthèse additive des couleurs (écrans) et CYMK la synthèse soustractive (imprimantes)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "coul = input(\"Quelle couleur avez-vous sélectionné ? \")\n",
    "if coul in ['rouge',\n",
    "            'red',\n",
    "            # liste à compléter #\n",
    "           ]:\n",
    "    print('RGB')\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "<!--\n",
    "\n",
    "\n",
    "coul = input(\"Quelle couleur avez-vous sélectionné ? \")\n",
    "if coul in ['rouge', 'red', 'vert', 'green', 'bleu', 'blue']:\n",
    "    print('RGB')\n",
    "elif coul in ['cyan', 'bleu_ciel', 'magenta', 'rose', 'jaune', 'yellow', 'noir' , 'black']:\n",
    "    print('CMYK')\n",
    "else:\n",
    "    print(\"Erreur, la couleur\", coul, \"n'est pas correcte\")\n",
    "\n",
    "\n",
    "-->"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercice 4 - Remise\n",
    "Écrire et tester un programme qui demande en entrée à un client le montant total de ses achats.\n",
    "En fonction de la somme dépensée, le programme affiche en sortie le prix à payer :\n",
    "* Si la somme dépensée est strictement inférieure à 75 €, il obtient 5 % de remise.\n",
    "* Si la somme dépensée est supérieure à 75 €, il obtient 8 % de remise.\n",
    "\n",
    "Tester le programme avec des valeurs simples comme 0, 10, 50, 100, 200."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "montant = float(input(\"#~Poser la question ici~#\"))\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "<!-- Solution\n",
    "\n",
    "\n",
    "montant = float(input(\"Quel est le montant des achats ?\"))\n",
    "if montant < 75:\n",
    "    reduction = 5\n",
    "else:\n",
    "    reduction = 8\n",
    "prix = montant * (1 - reduction/100)\n",
    "print(\"Prix à payer après réduction de\", reduction, \"% :\", prix)\n",
    "\n",
    "\n",
    "-->"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercice 5 - Triangles rectangles\n",
    "Faire un programme qui prend en entrées trois longueurs (flottants positifs) et qui retourne un message précisant si ces longueurs peuvent correspondre à celle d'un triangle rectangle.\n",
    "\n",
    "Rappels :\n",
    ">#### Réciproque du théorème de Pythagore :\n",
    "Dans un triangle,<br>\n",
    "**Si** le carré de la longueur du plus grand côté *est égal* à la somme des carrés des longueurs des deux autres,\n",
    "<br>**alors** ce triangle *est* rectangle et le plus grand côté en est l'hypoténuse.\n",
    "$$BC^2=BA^2+AC^2 \\Rightarrow ABC\\text{ est rectangle en }A$$\n",
    "#### Contraposée du théorème de Pythagore :\n",
    "Dans un triangle,<br>\n",
    "**Si** le carré de la longueur du plus grand côté *n'est pas égal* à la somme des carrés des longueurs des deux autres,\n",
    "<br>**alors** ce triangle *n'est pas* rectangle.\n",
    "$$BC\\text{ plus grand côté et }BC^2\\neq BA^2+AC^2 \\Rightarrow ABC\\text{ n'est rectangle}$$\n",
    "\n",
    "/!\\ L'utilisateur peut entrer les longueurs dans n'importe quel ordre. Il est nécessaire d'ordonner les valeurs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#-~-~-  Entrées   -~-~-#\n",
    "cote1 = float(input(\"1er côté=? \"))\n",
    "# Il ne faut pas avoir un nombre négatif,\n",
    "# si c'est le cas, il faut invoquer une erreur de valeur grâce à : raise ValueError\n",
    "\n",
    "cote2 = float(input(\"2e côté=? \"))\n",
    "# Tester si le nombre est positif\n",
    "\n",
    "cote3 = float(input(\"3e côté=? \"))\n",
    "# Tester si le nombre est positif\n",
    "\n",
    "#-~-~- Traitement -~-~-#\n",
    "# --> On gardera la plus grande longueur dans la variable cote1\n",
    "# Si cote2 est plus grand, échanger les 2 variables avec un instruction du type : cote1, cote2 = cote2, cote1\n",
    "\n",
    "# Faire un autre échange si c'est nécessaire\n",
    "\n",
    "## À ce point, 'cote1' contient la plus grande valeur (mais on connaît pas l'ordre des deux autres)\n",
    "# --> Calculer la condition sous la forme d'un booléen\n",
    "condition = # de la forme : une_expression == une_autre_expression\n",
    "if condition:\n",
    "    # Partie 'True' ; préciser l'hypoténuse\n",
    "else:\n",
    "    # Partie 'False'\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tester le programme précédent avec des données variées...\n",
    "<br>Des résultats positifs sont attendus :\n",
    "1. Avec $3$ ; $4$ et $5$.\n",
    "1. Avec $0,8$ ; $1$ et $0,6$.\n",
    "1. Avec `1.5e3` ; `9e2` et `120e1`\n",
    "1. Avec $0$ ; $0$ et $0$.\n",
    "\n",
    "Des résultats négatitifs sont attendus :\n",
    "1. Avec $1$ ; $2$ et $3$.\n",
    "1. Avec $9$ ; $25$ et $16$.\n",
    "1. Avec $0,8$ ; $0,8$ et $0,8$.\n",
    "1. Avec $4$ ; `4e-1` et `4e-1`.\n",
    "\n",
    "Des erreurs d'éxécutions doivent se produire :\n",
    "1. Avec $1$ ; $2$ et $-3$.\n",
    "1. Avec `trois` ; `quatre` et `cinq` (sous forme de chaînes de caractères)\n",
    "1. Avec `1.5e-3` ; `7.8e-2` et `-1.2e4`\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tester ce petit morceau de code :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "condition = False # Essayer aussi en changeant la valeur en 'True'\n",
    "\"Rectangle\" if condition else \"Pas rectangle\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Il serait préférable d'utiliser une fonction pour faire tous les tests :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def est_rectangle(cote1, cote2, cote3):          ### Le corps de la fonction est indenté de 4 espaces\n",
    "    if cote1 < 0 or cote2 < 0 or cote3 <0:\n",
    "        raise ValueError('Les 3 nombres doivent être positifs')\n",
    "\n",
    "    if cote1 < cote2:\n",
    "        cote1, cote2 = cote2, cote1\n",
    "    \n",
    "    if cote1 < cote3:\n",
    "        cote1, cote3 = cote3, cote1\n",
    "    \n",
    "    return cote1**2 == cote2**2 + cote3**2\n",
    "# rien n'est réellement exécuté jusque là, nous avons juste défini la fonction 'est_rectangle'\n",
    "\n",
    "# Grâce à ces listes, nous pourrons effectuer les tests dans une boucle\n",
    "liste_a = [3, 0.8, 1.5e3, 0, 1,  9, 0.8,    4]\n",
    "liste_b = [4, 1  ,   9e2, 0, 2, 25, 0.8, 4e-1]\n",
    "liste_c = [5, 0.6, 120e1, 0, 3, 16, 0.8, 4e-1]\n",
    "\n",
    "# La boucle 'for' va parcourir les listes en même temps (grâce à 'zip' qui permet de regrouper plusieurs listes)\n",
    "for a, b, c in zip(liste_a, liste_b, liste_c):\n",
    "    print(\"Rectangle\" if est_rectangle(a, b, c) else \"Pas rectangle\")\n",
    "\n",
    "### Les lignes suivantes provoquent des erreurs d'exécution\n",
    "#est_rectangle(1, 2, -3)\n",
    "#est_rectangle('trois', 'quatre', 'cinq')\n",
    "#est_rectangle(1.5e-3, 7.8e-2, -1.2e4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "<!-- Solution\n",
    "\n",
    "\n",
    "cote1 = float(input(\"1er côté=? \"))\n",
    "if cote1 < 0:\n",
    "    raise ValueError\n",
    "\n",
    "cote2 = float(input(\"2e côté=? \"))\n",
    "if cote2 < 0:\n",
    "    raise ValueError\n",
    "\n",
    "cote3 = float(input(\"3e côté=? \"))\n",
    "if cote3 < 0:\n",
    "    raise ValueError\n",
    "\n",
    "if cote1 < cote2:\n",
    "    cote1, cote2 = cote2, cote1\n",
    "if cote1 < cote3:\n",
    "    cote1, cote3 = cote3, cote1\n",
    "\n",
    "condition = cote1**2 == cote2**2 + cote3**2\n",
    "\n",
    "if condition:\n",
    "    print(\"Rectangle, l'hypoténuse mesure\", cote1)\n",
    "else:\n",
    "    print(\"Non rectangle\")\n",
    "\n",
    "\n",
    "\n",
    "-->"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercice 6 - Triangles *bis*\n",
    "Le but du problème est de déterminer la nature d'un triangle (isocèle, équilatéral, rectangle ou quelconque)\n",
    "<br>\n",
    "On utilisera des fonctions et les tests seront fait automatiquement comme dans le programme précédent.<br>\n",
    "/!\\ On ne fera pas de test sur la validité des données !"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "## Il est possible d'exécuter à tout moment pour voir la progression\n",
    "\n",
    "def est_isocele(a, b, c):\n",
    "    # La fonction 'est_isocèle' doit retourner 'True'\n",
    "    # si au moins deux longueurs sont égales et\n",
    "    # 'False' dans le cas contraire\n",
    "    #\n",
    "    # Calculer la condition sous la forme d'un booléen\n",
    "    # Méthode 1 :\n",
    "    # -----------\n",
    "    #\n",
    "    #if ...:\n",
    "    #    condition = ...\n",
    "    #else:\n",
    "    #    condition = ...\n",
    "    #\n",
    "    #\n",
    "    # Ou bien méthode 2 :\n",
    "    # -------------------\n",
    "    #\n",
    "    #condition = ...\n",
    "    #\n",
    "    # Dans tous les cas, finir par :\n",
    "    #return condition\n",
    "    pass # Cette ligne pourra être supprimée quand la fonction sera codée\n",
    "\n",
    "def est_equilateral(a, b, c):\n",
    "    # La fonction 'est_equilateral' doit retourner 'True'\n",
    "    # si les trois longueurs sont égales et\n",
    "    # 'False' dans le cas contraire\n",
    "    pass # Cette ligne pourra être supprimée\n",
    "\n",
    "def est_rectangle(a, b, c):\n",
    "    # La fonction 'est_rectangle' peut être adaptée\n",
    "    # de l'exercice précédent\n",
    "    pass # Cette ligne pourra être supprimée\n",
    "\n",
    "def est_quelconque(a, b, c):\n",
    "    # Retourne 'True' si le triangle n'est ni isocèle, ni rectangle\n",
    "    pass # Cette ligne pourra être supprimée\n",
    "\n",
    "\n",
    "\n",
    "#-----------------------------------------#\n",
    "# Ne plus mettre de code sous cette ligne #\n",
    "#-----------------------------------------#\n",
    "%run -i 02b-test.py"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "<!-- Solution\n",
    "\n",
    "\n",
    "def est_isocele(a, b, c):\n",
    "    return a == b or b == c or a == c\n",
    "\n",
    "def est_equilateral(a, b, c):\n",
    "    return a == b == c\n",
    "\n",
    "def est_rectangle(a, b, c):\n",
    "    if a < b: a, b = b, a\n",
    "    if a < c: a, c = c, a\n",
    "    return a**2 == b**2 + c**2\n",
    "\n",
    "def est_quelconque(a, b, c):\n",
    "    return not est_isocele(a, b, c) and not est_rectangle(a, b, c)\n",
    "\n",
    "%run -i 02b-test.py\n",
    "\n",
    "-->"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Fin des exercices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Espace de test pour aller plus loin\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}