conditions1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Instructions conditionnelles et expressions booléennes\n",
    "\n",
    "Dans l'exemple du calcul de vitesse d'un coureur, on a automatisé une séquence de calculs assez simples, et dont le déroulement est *toujours le même*.\n",
    "\n",
    "Il y a d'autres problèmes, où le processus de résolution sera différent selon les données d'entrée. Par exemple, pour calculer la valeur absolue d'un nombre, le processus est différent selon si le nombre est positif ou négatif.\n",
    "\n",
    "Afin de pouvoir sélectionner des opérations différentes selon la valeur des données, on utilise des **branchements conditionnels**: le terme *branchement* suggère qu'on arrive à une intersection et on décide de tourner à droite ou à gauche en utilisant un mécanisme de décision. En Java ce mécanisme se matérialise par les instructions conditionnnelles ```if``` et ```switch```.\n",
    "\n",
    "## Instructions conditionnelles avec ```if```\n",
    "\n",
    "L'instruction conditionnelle ```if``` permet d'évaluer une condition logique, et selon le résultat, d'exécuter ou non une instruction.\n",
    "\n",
    "Par exemple, si on a une variable ```x```, on peut évaluer si sa valeur est positive, et dans ce cas afficher l'information à la console: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x est positif\n"
     ]
    }
   ],
   "source": [
    "int x =8;\n",
    "\n",
    "if (x >=0)\n",
    "    System.out.println(\"x est positif\");\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Étant donné que ```x``` vaut 8, la condition est vraie, alors l'instruction ```System.out.println()``` est exécutée.\n",
    "Si la condition est fausse, il ne se passe rien, ou plus précisément, on saute l'instruction qui suit la condition.\n",
    "\n",
    "On peut le voir dans l'exemple suivant, avec une condition maintenant fausse:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Affichage avant le if....\n",
      "Nous voici après le if.\n"
     ]
    }
   ],
   "source": [
    "System.out.println(\"Affichage avant le if....\");\n",
    "\n",
    "if (x<0)\n",
    "  System.out.println(\"x est négatif\");\n",
    "\n",
    "System.out.println(\"Nous voici après le if.\");"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Remarquer qu'on a décalé vers la droite l'instruction suivant le ```if``` (celle qui est exécutée de façon conditionnelle): ceci ne fait aucune différence pour l'interpréteur Java, mais l'indentation rend le code plus lisible: on voit du premier coup d'oeil la structure de l'instruction conditionnelle.\n",
    "\n",
    "### Blocs de code\n",
    "\n",
    "Dans l'exemple précédent, on exécute *une seule* instruction de manière conditionnelle: celle immédiatement après la condition. Souvent il est utile d'exécuter de manière conditionnelle une *séquence* d'instructions. Pour ceci on peut former un bloc d'instructions délimité par des accolades ```{``` ```}```:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Affichage avant le if....\n",
      "Nous voici après le if.\n"
     ]
    }
   ],
   "source": [
    "System.out.println(\"Affichage avant le if....\");\n",
    "\n",
    "if (x<0){\n",
    "  System.out.println(\"x est négatif\");\n",
    "  x = -x;\n",
    "  System.out.println(\"x vaut maintenant:\"+x);\n",
    "}\n",
    "\n",
    "System.out.println(\"Nous voici après le if.\");"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On voit ici que comme la condition était fausse, les trois lignes entre les accolades ont été sautées.\n",
    "\n",
    "En général, il est recommandé de mettre systématiquement les accolades, même si le bloc contient une seule instruction: ça aide à la lisbilité, et ça peut éviter des erreurs si on vient ultérieurement modifier le code pour rajouter des instructions à la partie conditionnelle.\n",
    "\n",
    "### la clause ```else```\n",
    "\n",
    "Avec un ```if``` simple, le programme choisit entre *exécuter l'instruction conditionnelle*, et *ne rien faire*.\n",
    "On peut avoir une logique un peu plus complexe en permettant de choisir entre deux instructions ou blocs d'instructions: si la condition est vraie, exécuter l'instruction A, et si elle est fausse, exécuter l'instruction B.\n",
    "\n",
    "Exemple:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x est positif\n"
     ]
    }
   ],
   "source": [
    "if (x>0){\n",
    "  System.out.println(\"x est positif\");\n",
    "} else {\n",
    "  System.out.println(\"x est négatif\");\n",
    "  x = -x;\n",
    "  System.out.println(\"x vaut maintenant:\"+x);\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La condition était vraie, et on a donc exécuté l'instruction conditionnelle suivant la condition, puis sauté le bloc après ```else```."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Résumé\n",
    "En résumé, la syntaxe de l'instruction conditionnelle ```if``` est la suivante:\n",
    "```\n",
    "if (condition) {\n",
    "    bloc d'instructions 1\n",
    "} else {\n",
    "    bloc d'instructions 2\n",
    "}\n",
    "```\n",
    "La sémantique de cette structure conditionnelle est la suivante:\n",
    "\n",
    "Si la condition est *vraie*, alors le bloc d'instructions 1 est exécuté, et le bloc 2 est sauté. Si, en revanche, la condition est *fausse*, alors le bloc 1 est sauté et le bloc 2 est exécuté. \n",
    "\n",
    "Les éléments clés d'une instruction conditionnelle:\n",
    "* la ```condition``` est une **expression booléenne**, c'est-à-dire une expression dont le résultat peut prendre seulement les valeurs *vrai* ou *faux*. Par exemple: ```nombre >= 0```.\n",
    "* la clause ```else``` est optionnelle: on peut écrire simplement:\n",
    "```\n",
    "instruction 1\n",
    "if (condition) {\n",
    "    bloc d'instructions 2\n",
    "}\n",
    "instruction 3\n",
    "```\n",
    "Si la ```condition``` est vraie, alors les instructions sont exécutées dans l'ordre:\n",
    "```\n",
    "instruction 1\n",
    "instructions du bloc 2\n",
    "instruction 3\n",
    "``` \n",
    "Si la ```condition``` est fausse, on saute le bloc d'instructions 2 et on exécute simplement :\n",
    "```\n",
    "instruction 1\n",
    "instruction 3\n",
    "``` \n",
    "* Il est recommandé d'utiliser systématiquement des accolades pour délimiter les blocs ```if``` et ```else```, et d'indenter le code avec des tabulations. Les éditeurs de code maintiennent habituellement l'indentation quand on revient à la ligne, et permettent aussi d'indenter automatiquement le code: par exemple, sous eclipse on peut sélectionner les lignes de code qu'on veut indenter, et taper *ctrl+I* (*cmd + I* sur mac) pour indenter automatiquement ces lignes."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Un programme avec des branchements conditionnels\n",
    "\n",
    "Dans tous les exemples précédents, on connaissait par avance la valeur de ```x```, qui avait été entrée au départ. On savait donc à l'avance quelles instructions seraient exécutées et lesquelles ne le seraient pas. \n",
    " \n",
    "Ce type de branchement conditionnel permet d'écrire une séquence de calculs une seule fois sans connaître la valeur des données d'entrée, et de considérer toutes les possibilités. On aura de nombreuses situations où un calcul doit être effectué différemment selon la valeur des données.\n",
    "\n",
    "#### Exemple 1:  valeur absolue\n",
    "Un exemple simple est le concept de la valeur absolue. La valeur absolue d'un nombre se calcule différemment selon si le nombre est positif ou négatif: pour un nombre positif, sa valeur absolue est le nombre lui-même, alors que s'il est négatif, sa valeur absolue est son opposé.\n",
    "\n",
    "Écrivons un programme pour lire un nombre au clavier, puis calculer et afficher la valeur absolue du nombre.\n",
    "\n",
    "Commençons par lire le nombre au clavier. On va utiliser le type ```double``` pour que l'utilisateur puisse entrer un entier ou un décimal:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Entrer un nombre quelconque:\n",
      "32.5\n"
     ]
    }
   ],
   "source": [
    "import java.util.Scanner;\n",
    "Scanner clavier = new Scanner(System.in);\n",
    "\n",
    "System.out.println(\"Entrer un nombre quelconque:\");\n",
    "double nombre = clavier.nextDouble();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On arrive au processus conditionnel: \n",
    "\n",
    "* **si** (le nombre est positif ou nul) **alors**:\n",
    "<br/>    on affiche le nombre lui-même.\n",
    "\n",
    "* **sinon**:\n",
    "<br/>    on affiche l'opposé du nombre.\n",
    "\n",
    "En Java on écrit:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "La valeur absolue du nombre est: 32.500000"
     ]
    }
   ],
   "source": [
    "if (nombre >=0) {\n",
    "    System.out.printf(\"La valeur absolue du nombre est: %f\", nombre);\n",
    "} else {\n",
    "    System.out.printf(\"La valeur absolue du nombre est: %f\", -nombre);\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On peut re-exécuter le programme avec un nombre négatif en entrée, et on verra que la valeur absolue du nombre est affiché correctement.\n",
    "\n",
    "Comme souvent, il y aurait d'autres solutions possibles pour ce programme. On aurait par exemple pu utiliser une seule instruction ```System.out.println``` pour afficher toujours la valeur de la variable ```nombre```, qu'on aurait auparavant modifié dans le cas où le nombre était négatif:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Entrer un nombre quelconque:\n",
      "-7.43\n",
      "La valeur absolue du nombre est:7.43\n"
     ]
    }
   ],
   "source": [
    "System.out.println(\"Entrer un nombre quelconque:\");\n",
    "nombre = clavier.nextDouble();\n",
    "if (nombre<0){             // si le nombre est négatif, alors\n",
    "    nombre = -nombre;      // on remplace le nombre par son opposé \n",
    "}\n",
    "System.out.println(\"La valeur absolue du nombre est:\"+ nombre);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pour un nombre positif, on aurait simplement sauté l'instruction qui remplace ```nombre``` par son opposé. Remarquer que la condition évalue cette fois si ```nombre``` est *négatif*, puisque dans le cas où ```nombre``` est positif on n'a rien à faire.\n",
    "\n",
    "On aurait pu aussi écrire:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "if (nombre>=0){ \n",
    "    \n",
    "} else {\n",
    "    nombre = -nombre;\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ici après le ```if``` on a une instruction vide (c'est à dire rien entre les accolades), et donc si la condition est vraie on ne fait rien. Cela dit, cette écriture est un peu maladroite et il est plus \"propre\" d'écrire un ```if``` utilisant la condition contraire, et sans ```else```.\n",
    "\n",
    "Autre remarque: Ici on utilise la même variable pour la donnée d'entrée et la donnée de sortie du problème: ceci est correct du point de vue purement Java, mais dans l'optique générale de formuler un programme qui résoud un problème, il est préférable de distinguer les deux, en utilisant des variables séparées. Cela permet de mieux représenter le processus logique de résoudre le problème (ici, on de change pas une donnée, on calcule sa valeur absolue).\n",
    "\n",
    "Cependant, par rapport à la première solution, il est utile de séparer le programme en trois parties: collecter les données d'entrée, faire le calcul, et afficher la solution. Une bonne solution est donc d'ajouter une nouvelle variable pour recevoir le résultat:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Entrer un nombre quelconque:\n",
      "-4.1\n",
      "La valeur absolue du nombre est:4.1\n"
     ]
    }
   ],
   "source": [
    "// lire les données:\n",
    "System.out.println(\"Entrer un nombre quelconque:\");\n",
    "nombre = clavier.nextDouble();\n",
    "\n",
    "double valeurAbsolue;         // variable pour le résultat\n",
    "\n",
    "if (nombre>0){             // si le nombre est négatif, alors\n",
    "    valeurAbsolue = nombre;      // on remplace le nombre par son opposé \n",
    "} else {\n",
    "    valeurAbsolue = -nombre;\n",
    "}\n",
    "\n",
    "//affichage du résultat\n",
    "System.out.println(\"La valeur absolue du nombre est:\"+ valeurAbsolue);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercice 1\n",
    "\n",
    "Le code suivant permet à l'utilisateur d'entrer deux nombres. Ajouter une instruction conditionnelle ```if``` pour que le programme affiche ensuite **le plus grand des deux nombres**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Entrer deux nombres séparés d'un espace:\n",
      "3.4 61\n",
      "Le plus grand des deux nombres est: 0.0\n"
     ]
    }
   ],
   "source": [
    "System.out.println(\"Entrer deux nombres séparés d'un espace:\");\n",
    "double n1 = clavier.nextDouble();\n",
    "double n2 = clavier.nextDouble();\n",
    "double max = 0;\n",
    "\n",
    "// if ici\n",
    "\n",
    "System.out.println(\"Le plus grand des deux nombres est: \" + max);\n"
   ]
  },
  {
   "attachments": {
    "Screen%20Shot%202020-06-29%20at%202.44.11%20PM.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exemple 2: Hydro-Québec\n",
    "On va détailler ici un autre calcul un peu complexe, où le besoin d'une branchement conditionnel est moins évident: calculer une facture hydro-québec.\n",
    "\n",
    "On veut automatiquement calculer le montant à payer à Hydro-Québec pour une certaine consommation d'électricité.\n",
    "Ce montant est calculé comme indiqué sur le site d'Hydro-Québec:\n",
    "![Screen%20Shot%202020-06-29%20at%202.44.11%20PM.png](attachment:Screen%20Shot%202020-06-29%20at%202.44.11%20PM.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Le fait que deux tarifs existent, et qu'un des tarifs ne s'applique qu'à partir d'une certaine consommation, implique que le calcul peut se faire de deux manières différentes, selon si la consommation est basse ou plus élevée.\n",
    "\n",
    "On va d'abord détailler les étapes du calcul sur un exemple, puis reprendre ces étapes dans un programme qui automatise ce calcul, avec une instruction conditionnelle.\n",
    "\n",
    "\n",
    "Supposons qu'on a consommé **2850 kWh** sur une période de **56 jours**. On va stocker ces données d'entrée dans des variables:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "double conso = 2850;\n",
    "int jours = 56;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Calculons les frais d'accès au réseau:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "double frais = 0.4064 * jours;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pour calculer le montant à payer pour l'*énergie consommée*, on calcule déjà le maximum d'énergie qui constitue la \"première tranche\": 40 kWh multiplié par le nombre de jours:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "max premiere tranche:2240.0\n"
     ]
    }
   ],
   "source": [
    "double maxT1 = 40 * jours;\n",
    "\n",
    "System.out.println(\"max premiere tranche:\" + maxT1);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ici on doit regarder le résultat, et prendre une décision: si notre consommation est en-dessous de cette limite, on payerait toute notre consommation au tarif bas. Si notre consommation dépasse la limite, on doit séparer notre consommation en deux tranches: on paye le tarif bas pour la première, et le tarif plus élevé pour la deuxième. \n",
    "\n",
    "Ici, on est dans le deuxième cas: notre consommation (2850 kWh) dépasse le montant alloué pour la première tranche (2240 kWh).\n",
    "\n",
    "Le calcul est donc:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Tranche 1: 136.192\n",
      " tranche 2: 57.217999999999996\n"
     ]
    }
   ],
   "source": [
    "double tranche1 = maxT1 * 0.0608;\n",
    "\n",
    "double tranche2 = (conso - maxT1) * 0.0938;\n",
    "\n",
    "System.out.println(\" Tranche 1: \" + tranche1 + \"\\n tranche 2: \" + tranche2);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On paye \\\\$136.19 pour la première tranche (2240 kWh à \\\\$0.0608 par kWh) et \\\\$57.22 pour la deuxième tranche (610 kWh à \\\\0.0938 par kWh)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Il faut enfin ajouter les taxes (14.975%, non indiqué sur l'image ci-dessus). Le total à payer est donc:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "248.5396179"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(frais + tranche1 + tranche2)*1.14975"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notre facture totale sera donc de $248.54.\n",
    "\n",
    "Comment ferait-on le calcul si la consommation était faible et n'utilisait que le tarif bas?\n",
    "\n",
    "Prenons un autre exemple. Toujours sur 56 jours, on a cette fois utilisé seulement **1100 kwh**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "double conso = 1100;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Les frais restent les mêmes, mais les montants pour les deux tranches sont différents: comme on est en-dessous du maximum de la première tranche, on paye toute notre consommation au tarif bas:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "tranche1 = conso * 0.0608;\n",
    "tranche2 = 0;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On recalcule le montant final après taxes:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "103.0617504"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(frais + tranche1 + tranche2)*1.14975"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On va maintenant automatiser ce calcul dans un petit programme, dans lequel on aura une **instruction conditionnelle** qui nous permettra de calculer la facture comme dans le premier cas ou comme dans le deuxième.\n",
    "\n",
    "Cette fois on va permettre à l'utilisateur de donner les données d'entrée au clavier:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Calcul d'une facture Hydro-Québec:\n",
      "Entrer l'énergie consommée:\n",
      "1100\n",
      "Entrer le nombre de jours:\n",
      "54\n"
     ]
    }
   ],
   "source": [
    "System.out.println(\"Calcul d'une facture Hydro-Québec:\");\n",
    "System.out.println(\"Entrer l'énergie consommée:\");\n",
    "conso = clavier.nextDouble();\n",
    "System.out.println(\"Entrer le nombre de jours:\");\n",
    "jours = clavier.nextInt();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Les premiers calculs:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "frais = 0.4064 * jours;\n",
    "maxT1 = 40* jours;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On doit maintenant déterminer si la consommation dépasse le montant alloué pour la première tranche, à l'aide d'une expression conditionnelle, et déterminer les montants à payer pour la première tranche (```tranche1```) et pouyr la deuxième (```conso2```):\n",
    "\n",
    "**Si** la consommation (```conso```) dépasse ```maxT1``` **alors** on va calculer le montant à payer comme ceci:\n",
    "```\n",
    "tranche1 = maxT1 * 0.0608\n",
    "tranche2 = (conso - maxT1) * 0.0938\n",
    "```\n",
    "**Sinon** on va calculer le montant à payer simplement comme cela:\n",
    "```\n",
    "tranche1 = conso * 0.0608\n",
    "tranche2 = 0\n",
    "```\n",
    "\n",
    "En Java on écrit donc:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "double conso1;\n",
    "if (conso > maxT1){\n",
    "    tranche1 = maxT1 * 0.0608;\n",
    "    tranche2 = (conso - maxT1) * 0.0938;\n",
    "} else {\n",
    "    tranche1 = conso * 0.0608;\n",
    "    tranche2 = 0;\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On termine par le montant total après taxes, qui se calcule de la même façon dans les deux cas:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Le montant de la facture sera de $102.13"
     ]
    },
    {
     "data": {
      "text/plain": [
       "java.io.PrintStream@184b6847"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "double facture = (frais + tranche1 + tranche2) * 1.14975;\n",
    "\n",
    "System.out.printf(\"Le montant de la facture sera de $%.2f\", facture);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On obtient bien le même résultat.\n",
    "Le même programme peut être utilisé pour calculer les montants de factures pour d'autres consommations et périodes de jours. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercice 2\n",
    "\n",
    "Supposons qu'un autobus passe toutes les heures dans une certaine rue, 12 minutes après l'heure: 0h12, 1h12, 2h12, etc. \n",
    "\n",
    "Modifier le programme ci-dessous qui demande l'heure à l'utilisateur, puis affiche le nombre de minutes à attendre pour l'autobus.\n",
    "\n",
    "Indication: le calcul est différent selon si il est plus ou moins de 12 minutes après l'heure. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Quelle heure est-il? (heures puis minutes)\n",
      "8 01\n",
      "L'autobus arrive dans 24 minutes."
     ]
    },
    {
     "data": {
      "text/plain": [
       "java.io.PrintStream@184b6847"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "System.out.println(\"Quelle heure est-il? (heures puis minutes)\");\n",
    "int heures = clavier.nextInt();\n",
    "int minutes = clavier.nextInt();\n",
    "int temps = 24;\n",
    "\n",
    "System.out.printf(\"L'autobus arrive dans %d minutes.\", temps);"
   ]
  }
 ],
 "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
}