booleens.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Instructions Conditionnelles: suite\n",
    "\n",
    "## Expressions booléennes\n",
    "\n",
    "Dans les exemples précédents nous avons utilisé des conditions toujours très simples, portant sur une seule variable. En programmation il est souvent nécessaire de manipuler des conditions plus complexes, qui peuvent se calculer à l'aide d'expressions similaires aux expressions arithmétiques vues au tout début du cours.\n",
    "\n",
    "Pour ceci on utilise des variables, valeurs, et expressions du type ```boolean```. Dans ce notebook on va explorer ce type en détail.\n",
    "\n",
    "Tout comme les types ```int``` et ```double``` sont utilisés pour les informations numériques, le type ```boolean``` est utilisé pour des informations \"logiques\" qui peuvent être seulement vraies ou fausses.\n",
    "\n",
    "On a déjà vu des expressions booléennes, créées à partir de valeurs (ou variables) numériques, comme par exemple les suivantes:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "5 > 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "false"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "int x = 8;\n",
    "x < 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "false"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x == 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pour les trois expressions précédentes, le seul opérateur utilisé est un opérateur de *comparaison*, qui nous permet d'obtenir des informations vraies ou fausses. Comme on le voit dans les sorties, les seules valeurs correspondant au type booléen sont ```true``` et ```false```.\n",
    "\n",
    "On peut écrire des expressions plus complexes en utilisant les opérateurs arithmétiques aussi; les opérateurs de comparaison ont alors la précédence \"minimale\" : les comparaisons sont effectuées en dernier, et leur résultat est booléen: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(x + 1) == (x/2 - 1)* 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En Java les opérateurs de comparaison sont: \n",
    "* Inégalités strictes ```>``` et ```<```, \n",
    "* Inégalités larges ```>=``` et ```<=```, \n",
    "* Égalité ```==``` (remarquer la différence avec l'opéerateur d'affectation ```=```)\n",
    "* Différence ```!=``` (signifie: non-égal)\n",
    "\n",
    "Les inégalitées sont applicables seulement aux nombres, et au type ```char```, qui peut être directement converti en nombre. On ne peut pas, en revanche, les utiliser pour les ```String```:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'f' > 'b'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "ename": "CompilationException",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[1m\u001b[30m|   \u001b[1m\u001b[30m\u001b[0m\u001b[1m\u001b[30m\u001b[41m\"hamster\" < \"rhinoceros\"\u001b[0m\u001b[1m\u001b[30m\u001b[0m",
      "\u001b[1m\u001b[31mbad operand types for binary operator '<'\u001b[0m",
      "\u001b[1m\u001b[31m  first type:  java.lang.String\u001b[0m",
      "\u001b[1m\u001b[31m  second type: java.lang.String\u001b[0m",
      ""
     ]
    }
   ],
   "source": [
    "\"hamster\" < \"rhinoceros\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "les opérateurs \"égal\" et \"différent\" s'appliquent à tous les types. Dans tous les cas, quelque soit le type des opérandes, le résultat est toujours de type ```boolean```:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "false"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'f' == 'b'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"chameau\" != \"dromadaire\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Mais attention! En général, **il ne faut pas** utiliser les comparaisons ```==``` et ```!=``` avec des chaînes de caractères (même si ça compile), à cause de la façon dont celles-ci sont stockées en mémoire (ce sont des *objets*, comme on le verra plus tard). Ces comparaisons fonctionnent souvent très bien, mais le jour où une ne fonctionne pas correctement, le bug peut être assez difficile à trouver:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Entrer une valeur pour nom3\n",
      "Jane\n"
     ]
    }
   ],
   "source": [
    "import java.util.Scanner;\n",
    "Scanner clavier = new Scanner(System.in);\n",
    "\n",
    "String nom = \"Jane\";\n",
    "String nom2 = \"Ja\"+\"ne\";\n",
    "System.out.println(\"Entrer une valeur pour nom3\");\n",
    "String nom3 = clavier.next();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Voyons les valeurs de nos trois variables ```nom```, ```nom2```, ```nom3```:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Jane"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nom"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Jane"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nom2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Jane"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nom3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Et les comparaisons..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nom == nom2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "false"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nom == nom3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nom2 != nom3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Variables booléennes\n",
    "\n",
    "De même que pour les autres types, on peut enregistrer une information de type booléen dans une variable. Le type Java correspondant est ```boolean```, et comme pour les autres types, il faut déclarer les variables avant de les utiliser:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "boolean positif;\n",
    "x = 3;\n",
    "positif = (x >=0);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ici on a mis des parenthèses pour une meilleure lisibilité, et l'affectation a enregistré le résultat de la comparaison dans le variable booléenne ```positif```.\n",
    "\n",
    "On peut ensuite lire cette valeur:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "positif"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "... et l'utiliser dans un ```if```:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x est positif!\n"
     ]
    }
   ],
   "source": [
    "if (positif) {\n",
    "    System.out.println(\"x est positif!\");\n",
    "} else {\n",
    "    System.out.println(\"x est négatif!\");\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Attention**: ici on a enregistré le *résultat* de la comparaison dans la variable ```positif```,  et non pas la comparaison elle-même. Ça veut dire que si on change maintenant la valeur de ```x``` et que la nouvelle valeur est négative, la variable ```positif``` n'est pas recalculée: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = -5;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "positif"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "À noter que ce fonctionnement est exactement le même que pour les variables et expressions numériques. \n",
    "\n",
    "### Constantes booléennes\n",
    "\n",
    "Comme on l'a indiqué plus haut et vu dans les exemples, les seules valeurs possibles pour des valeurs ou expressions booléennes sont ```true``` et ```false```.\n",
    "\n",
    "Comme pour des nombres, on peut utiliser ces valeurs dans le code:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "boolean repetition = false;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On voit aussi souvent les valeurs ```true``` et ```false``` apparaitre dans les conditions:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Bonjour!\n"
     ]
    }
   ],
   "source": [
    "System.out.println(\"Bonjour!\");\n",
    "\n",
    "if (repetition==true){\n",
    "    System.out.println(\"Encore Bonjour!\");\n",
    "}\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Mais ce code est parfaitement équivalent à:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Bonjour!\n"
     ]
    }
   ],
   "source": [
    "System.out.println(\"Bonjour!\");\n",
    "\n",
    "if (repetition){\n",
    "    System.out.println(\"Encore Bonjour!\");\n",
    "}\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Il faut bien comprendre que la comparaison ```repetition==true``` est exécutée et produit comme résultat ```true``` ou ```false```, et le résultat est ```true``` si la variable ```repetition``` elle-même est ```true```... on peut donc remplacer ```repetition==true``` par ```repetition```, le résultat est parfaitement identique.\n",
    "\n",
    "On peut s'en convaincre:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "false"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "repetition"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "false"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "repetition==true"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Opérateurs booléens\n",
    "\n",
    "Jusqu'ici on a vu comment obtenir des valeurs booléennes en comparant des valeurs numériques (ou textuelles) à l'aide des opérateurs ```>```, ```<=```, etc.\n",
    "\n",
    "On va maintenant voir comment combiner des valeurs booléennes à l'aide des principaux opérateurs booléens: *ET*, *OU* et *NON*, notées en Java ```&&```, ```||``` et ```!``` respectivement.\n",
    "\n",
    "### ET\n",
    "\n",
    "L'opérateur *ET*, la *conjonction*, s'écrit en Java ```&&```. Le sens de cet opérateur est intuitif: **(A ET B)** est vrai si et seulement si (**A** est vrai) *et* (**B** est vrai):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 5;\n",
    "int y = 10;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(x > 0) && (y > 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "false"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(x > y) && (y == 10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Remarque: pour indiquer qu'une variable est dans un intervalle, comme par exemple: ```0 < x < 10```, en Java il faut écrire les deux inégalités séparément:\n",
    "\n",
    "```(0 < x) && (x < 10)```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### OU\n",
    "\n",
    "L'opérateur *OU*, la *disjonction*, s'écrit en Java ```||```. Le sens de cet opérateur est intuitif: **(A OU B)** est vrai si et seulement si (**A** est vrai) *ou* (**B** est vrai):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "false"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(x ==0) || (y==0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(x==0) || (y==10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(x>0) || (y>0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### NON\n",
    "L'opérateur *NON*, la *négation*, s'écrit en Java ```!```. C'est un opérateur unaire: il s'applique à un seul opérande et renvoie son \"inverse\" logique: si **A** est vrai, alors **NON A** est faux, et inversement:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(x>0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "false"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "!(x>0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "false"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(y==0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "!(y==0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "D'ailleurs, une fois armés de la négation, on peut aussi éviter d'écrire des conditions de la forme ```if(repetition == false)...```: on peut simplement écrire: ```if (!repetition)...```."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Expressions booléennes *(maintenant avec des opérateurs booléens !!)* \n",
    "\n",
    "La présentation des opérateurs booléens *ET*, *OU*, *NON* suggère qu'ils sont assez faciles à comprendre. Mais leur utilisation peut poser des difficultés: c'est une compétence qui demande de la pratique.\n",
    "\n",
    "En premier lieu, il faut être capable de traduire une explication informelle en Français en contraintes logiques sur des variables.\n",
    "\n",
    "#### Exemple\n",
    "On veut écrire une expression booléenne pour exprimer que l'entier ```x``` *n'est pas dans l'intervalle \\[0-10\\]* (où 0 et 10 sont dans l'intervalle):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Entrer x:\n",
      "17\n",
      "x n'est pas dans l'intervalle\n"
     ]
    }
   ],
   "source": [
    "System.out.println(\"Entrer x:\");\n",
    "int x = clavier.nextInt();\n",
    "if ( (x<0) || (x >10) ){\n",
    "    System.out.println(\"x n'est pas dans l'intervalle\");\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pour dire que x n'est pas dans l'intervalle, on a exprimé que x était soit plus petit que la borne inférieure de l'intervalle (0) soit supérieur à la borne supérieure. Ceci se traduit par un **OU**: x est négatif **OU** plus grand que 10.\n",
    "\n",
    "On aurait pu exprimer la même condition en exprimant la condition que ```x``` *est dans l'intervalle*, puis prendre la négation de cette condition:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x n'est pas dans l'intervalle\n"
     ]
    }
   ],
   "source": [
    "if ( ! (x >=0 && x <=10) ){\n",
    "    System.out.println(\"x n'est pas dans l'intervalle\");\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Remarques:\n",
    "* la valeur de ```x``` est la même que précédemment\n",
    "* comme 0 et 10 sont *dans* l'intervalle, pour écrire que ```x``` est en-dehors de l'intervalle on utilise des inégalités *strictes*, alors qu'en exprimant la condition que ```x``` est *dans* l'intervalle, il faut utiliser des inégalités *larges*. \n",
    "* Ceci est parfaitement équivalent à une expression où on écrit que ```x``` est dans l'intervalle, et on écrit que cette condition est fausse avec ```==false```:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x n'est pas dans l'intervalle\n"
     ]
    }
   ],
   "source": [
    "if ( (x >=0 && x <=10)==false ){\n",
    "    System.out.println(\"x n'est pas dans l'intervalle\");\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercice 6 \n",
    "\n",
    "Dans le programme suivant, on a deux variables entières ```x``` et ```y```. Modifier les instructions conditionnelles avec des expressions booléennes correspondant aux conditions suivantes:\n",
    "1. ```x``` vaut 3 ou 5.\n",
    "2. ```x``` est négatif, ou bien ```x``` est égal à ```y```, mais pas les deux.\n",
    "3. ```y``` ne vaut ni ```x```, ni ```-x```.\n",
    "3. ```x``` est le maximum des trois nombres ```0```, ```x```, ```y```.\n",
    "3. Le point de coordonnées ```(x, y)``` (en pixels) se trouve dans les limites d'une fenêtre graphique de taille 800 pixels (horizontalement) par 600 pixels (verticalement).\n",
    "4. Le point de coordonnées ```(x, y)``` (en pixels) se trouve dans un rectangle de 100 pixels par 100 pixels en haut et au milieu (centré horizontalement) de l'écran. L'origine (0, 0) des coordonnées est le coin supérieur gauche de l'écran, et ```x``` augmente vers la droite alors que ```y``` augmente vers le bas. On suppose toujours un écran de 800 x 600 pixels."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Entrer x, suivi d'un espace puis y\n",
      "-10 45\n",
      "La condition 1 est fausse.\n",
      "La condition 2 est fausse.\n",
      "La condition 3 est fausse.\n",
      "La condition 4 est fausse.\n",
      "La condition 5 est fausse.\n",
      "La condition 6 est fausse.\n"
     ]
    }
   ],
   "source": [
    "System.out.println(\"Entrer x, suivi d'un espace puis y\");\n",
    "x = clavier.nextInt();\n",
    "int y = clavier.nextInt();\n",
    "\n",
    "if ( false ){ // remplacer false par la condition 1\n",
    "    System.out.println(\"La condition 1 est vraie.\");\n",
    "} else {\n",
    "    System.out.println(\"La condition 1 est fausse.\");\n",
    "}\n",
    "\n",
    "if ( false ){ // condition 2\n",
    "    System.out.println(\"La condition 2 est vraie.\");\n",
    "} else {\n",
    "    System.out.println(\"La condition 2 est fausse.\");\n",
    "}\n",
    "\n",
    "if ( false ){ // condition 3\n",
    "    System.out.println(\"La condition 3 est vraie.\");\n",
    "} else {\n",
    "    System.out.println(\"La condition 3 est fausse.\");\n",
    "}\n",
    "\n",
    "if ( false ){ // condition 4\n",
    "    System.out.println(\"La condition 4 est vraie.\");\n",
    "} else {\n",
    "    System.out.println(\"La condition 4 est fausse.\");\n",
    "}\n",
    "\n",
    "if ( false ){ // condition 5\n",
    "    System.out.println(\"La condition 5 est vraie.\");\n",
    "} else {\n",
    "    System.out.println(\"La condition 5 est fausse.\");\n",
    "}\n",
    "\n",
    "if ( false ){ // condition 6\n",
    "    System.out.println(\"La condition 6 est vraie.\");\n",
    "} else {\n",
    "    System.out.println(\"La condition 6 est fausse.\");\n",
    "}\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La deuxième compétence essentielle est de pouvoir *interpréter* une condition booléenne. Ceci permet de se relire, et de trouver les erreurs quand il y en a... \n",
    "\n",
    "#### Exemple\n",
    "\n",
    "On considère le code suivant, qui définit trois variables ```condition1, condition2, condition3```:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "int x = 12, y = 9;\n",
    "\n",
    "boolean condition1 = (x > 0 && y < 10);\n",
    "\n",
    "boolean condition2 = (x < y && y < 10) || (x % 2 ==0);\n",
    "\n",
    "boolean condition3 = (condition2) && (!condition1);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Quelle est la valeur (true / false) de chaque condition?\n",
    "\n",
    "Prenons-les une à une:\n",
    "* ```condition1```: les conditions (x >0) et (y<10) sont toutes deux vraies, donc la conjonction des deux est vraie. On vérifie:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "condition1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* ```condition2```: on commence par la partie gauche de l'expression, entre parenthèses: la première des deux est fausse, donc la conjonction est fausse. Ensuite, la partie droite: cette condition est vraie: x est pair. On a donc ```false``` **OU** ```true```: il suffit qu'une des deux soit vraie. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "condition2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* ```condition3```: cette fois condition3 est définie en fonction des deux précédentes. ```condition2``` est vraie, et comme ```condition1``` est vraie aussi, sa négation ```(!condition1)``` est fausse. On a donc ```true``` **ET** ```false```: comme l'une des deux est fausse, la conjonction est fausse aussi:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "false"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "condition3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercice 7\n",
    "\n",
    "Donner les valeurs de l'expression booléenne suivante, selon les valeurs de ```x``` et ```y``` données dans le tableau (la première ligne est donnée):\n",
    "\n",
    "Expression:\n",
    "```\n",
    "((x % 10 ==0) || (y%10 == 0)) && (x + y > 100)\n",
    "```\n",
    "| ```x```     | ```y``` | Expression|\n",
    "| ----------- | ------- | ----      |\n",
    "|     100     | 100    |  ```true``` |\n",
    "|     41      | 100    |   |\n",
    "|     10      | 10     |   |\n",
    "|     66      | 72     |   |\n"
   ]
  }
 ],
 "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
}