ch1-solExos.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Variables, Instructions et séquences d'instructions\n",
    "\n",
    "# Solutions des exercices\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercice 1\n",
    "Sachant qu'un pied (unité de longueur) vaut 12 pouces, convertir 41 pouces en pieds/pouces.\n",
    "(il y a deux opérations à faire)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "41/12"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "41%12"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "41 pouces = 3 pieds et 5 pouces."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercice 2\n",
    "Écrire une expression pour vérifier si 205 est multiple de 41."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "205% 41"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Oui, 205 est multiple de 41."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercice 3\n",
    "\n",
    "Écrire une expression Java équivalente à l'expression mathématique suivante:\n",
    "\n",
    "$\\frac{32 - 7}{\\frac{15}{3} \\times 5}$\n",
    "Utiliser seulement des entiers. le résultat doit être 1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(32 - 7) / ((11/3) * 5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercice 4\n",
    "\n",
    "Donner le type (```int``` ou ```double```) et la valeur des expressions suivantes:\n",
    "\n",
    "*Solution*: toutes les expressions sont de type ```double```. Les valeurs sont comme suit:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.0"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "3 - 1 + 1.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.0"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(5 + 1.0) / 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "13.0"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "3.0 + 2 * 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.0"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "3.0 * (1 / 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.5"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "4.0 / 2 / 4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercice 5\n",
    "\n",
    "Donner le type (```int``` ou ```double```) et la valeur des expressions suivantes:\n",
    "\n",
    "*Solution*: type ```double``` sauf la troisième, ```int```. Valeurs ci-dessous."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8.0"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(double) 3 + 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.0"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(double) (5/2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(int) 5.0 / 2 + 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6.0"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(int) (5.0 / 2) * 3.0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercice 6\n",
    "\n",
    "Écrire un String (un seul) qui s'affichera comme ceci, sur plusieurs lignes et avec les double quotes:\n",
    "\n",
    "```\n",
    "A - \"alpha\"\n",
    "B - \"bravo\"\n",
    "C - \"charlie\"\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       " A - \"alpha\" \n",
       " B - \"beta\" \n",
       " C - \"charlie\""
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\" A - \\\"alpha\\\" \\n B - \\\"beta\\\" \\n C - \\\"charlie\\\"\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercice 7\n",
    "\n",
    "Donner le type (```int```, ```double```, ou ```String```) et la valeur des expressions suivantes. Le cas échéant, indiquer quelles expressions sont invalides (causent une erreur).\n",
    "\n",
    "*Solutions:* types ```String``` / erreur / ```String``` / erreur / ```String```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0 pommes"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(int) 3/4 + \" pommes\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "ename": "CompilationException",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[1m\u001b[30m|   \u001b[1m\u001b[30m\u001b[0m\u001b[1m\u001b[30m\u001b[41m3 * \"a\"\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:  int\u001b[0m",
      "\u001b[1m\u001b[31m  second type: java.lang.String\u001b[0m",
      ""
     ]
    }
   ],
   "source": [
    "3 * \"a\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "63"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "3 + 3 + \"3\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "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(double) 3 / \"2\"\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:  double\u001b[0m",
      "\u001b[1m\u001b[31m  second type: java.lang.String\u001b[0m",
      ""
     ]
    }
   ],
   "source": [
    "(double) 3 / \"2\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4212"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"4\" + \"2\" + 3 * 4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercice 8\n",
    "Déclarer des variables ```nom```, ```age```, ```taille```, avec les types appropriés pour contenir les informations correspondante: l'age est une valeur entière, le nom une chaine de caractères, et la taille une valeur décimale."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "String nom;\n",
    "int age;\n",
    "double taille;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Donner à ces variables des valeurs pour représenter les informations d'Alice, qui a 35 ans et mesure 1.62m:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "nom = \"Alice\";\n",
    "age = 35;\n",
    "taille = 1.62;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercice 9\n",
    "\n",
    "Il existe une épreuve d'endurance qui consiste à courir la plus grande distance possible en 24h. Un athlète a couru à la vitesse moyenne de 11.3 km/h sur la durée de l'épreuve. On veut écrire un programme qui calcule la distance parcourue par cet athlète. \n",
    "\n",
    "Déclarer des variables des types numériques appropriés pour la durée, la vitesse et la distance:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "double vitesse, temps, distance; // on pourrait aussi déclarer un entier pour le temps."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Écrire les valeurs des données d'entrée dans les variables correspondantes:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "vitesse= 11.3;\n",
    "temps = 24;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Écrire le calcul de la donnée de sortie (distance) en utilisant ces variables:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "distance = vitesse * temps;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "271.20000000000005"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "distance"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercice 10\n",
    "Un automobiliste utilise toujours sa voiture pour se rendre sur son lieu de travail, situé à 12km de son domicile. Il travaille quatre jours par semaine, 22 semaines par an. Son véhicule consomme 8 litres d'essence au 100km, et le prix moyen de l'essence est de $1.20/L.\n",
    "\n",
    "On veut écrire un programme pour calculer ses dépenses annuelles en essence.\n",
    "\n",
    "Déclarer les variables pour les données d'entrées, en les initialisant avec les valeurs fournies:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "double distanceTravail = 12;\n",
    "int nbjours = 22*4;\n",
    "double conso = 8;\n",
    "double prixEssence =1.2;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Calculer la distance totale parcourue par année dans une nouvelle variable:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "double distanceAnnuelle = nbjours * distanceTravail * 2; // un aller-retour chaque jour de travail"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Calculer la quantité d'essence nécessaire (dans une nouvelle variable): "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "double consommation = distanceAnnuelle / 100 * conso; //conso litres pour chaque 100 km"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Calculer le coût de cette essence:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "double coutEssence = consommation * prixEssence;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "202.752"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "coutEssence"
   ]
  }
 ],
 "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
}