{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "b57c9a91",
   "metadata": {},
   "source": [
    "# Feuille d'exercices 1\n",
    "\n",
    "\n",
    "```{admonition} Objectifs \n",
    "* se familiariser avec l'environnement de travail Jupyter et la syntaxe de python\n",
    "* effectuer des opérations élémentaires, sur des entiers et des valeurs logiques\n",
    "* manipuler des variables et les afficher\n",
    "* écrire des fonctions simples\n",
    "```\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "## Exercice 1 : opérations arithmétiques\n",
    "\n",
    "**Question 1 :** Donner les valeurs de sortie des calculs suivants :\n",
    "\n",
    "- le produit de $12345$ par $6789$\n",
    "- le nombre rationnel $\\frac{2}{3}$\n",
    "- le quotient et le reste de la division euclidienne de $10^{10}$ par $2023$\n",
    "\n",
    "\n",
    "Si besoin, on pourra créer une cellule pour chaque calcul (grâce au bouton **+** situé dans la barre d'outils)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e92fe921",
   "metadata": {},
   "outputs": [],
   "source": [
    "12345 * 6789"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "35ce4394",
   "metadata": {},
   "outputs": [],
   "source": [
    "2/3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d97e9e28",
   "metadata": {},
   "outputs": [],
   "source": [
    "10**10 // 2023 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8cc5d12c",
   "metadata": {},
   "outputs": [],
   "source": [
    "10**10 % 2023"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "504c289a",
   "metadata": {},
   "source": [
    "Le langage python permet de manipuler des valeurs exactes (ex: des entiers) comme des valeurs \"décimales approchées\", dites *flottantes*. Pour convertir une valeur exacte en valeur flottante, on utiliser la commande `float`.\n",
    "\n",
    "**Question 2 :** Stocker le nombre flottant associé à l'entier $5$ dans une variable `a`. Puis, afficher `a`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ff1567dd",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = float(5)\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "48ff636a",
   "metadata": {},
   "source": [
    "## Exercice 2 : valeurs logiques et tests\n",
    "\n",
    "**Question 1 :** Afficher les quatre valeurs de la table de vérité de `or`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7d72c1fc",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(True or True)\n",
    "print(True or False)\n",
    "print(False or True)\n",
    "print(False or False)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "75eb0218",
   "metadata": {},
   "source": [
    "**Question 2 :** Quel est le plus grand nombre entre\n",
    "$x = 2^{3^5} - (6 \\times 5)^{7^2 - 1}$\n",
    "et\n",
    "$y = \\frac{47^{44} - 1}{3} + 14^{63}$ ? On stockera ces deux entiers dans des variables `x` et `y` avant de les comparer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f0921613",
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 2**(3**5) - (6*5)**(7**2 - 1)\n",
    "y = (47**44 - 1)//3 + 14**63\n",
    "print(x >= y)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4e1a2ef3",
   "metadata": {},
   "source": [
    "## Exercice 3 : chaînes de caractères\n",
    "\n",
    "**Question 1 :** Écrire la concaténation des chaînes de caractères \"Calcul\" et \"formel\", en ajoutant un espace entre ces deux mots."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f89b4573",
   "metadata": {},
   "outputs": [],
   "source": [
    "\"Calcul\" + \" \" + \"formel\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b4c04264",
   "metadata": {},
   "source": [
    "**Question 2 :** Écrire une fonction `plus_longue(chaine1, chaine2)` qui prend en entrée deux chaînes de caractères `chaine1` et `chaine2`, et qui retourne la chaine la plus longue. Si les deux chaînes sont de même longueur, la fonction retournera `chaine1`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1b2c5978",
   "metadata": {},
   "outputs": [],
   "source": [
    "def plus_longue(chaine1, chaine2):\n",
    "    if len(chaine1) >= len(chaine2):\n",
    "        return chaine1\n",
    "    else:\n",
    "        return chaine2"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "717b0caa",
   "metadata": {},
   "source": [
    "**Question 3 :** Tester la fonction `plus_longue` déclarée à la question précédente, avec les chaînes \"informatique\" et \"calcul formel\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4628c3f6",
   "metadata": {},
   "outputs": [],
   "source": [
    "plus_longue(\"informatique\", \"calcul formel\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "86ce64d1",
   "metadata": {},
   "source": [
    "**Question 4 :** Comment utiliser la fonction `plus_longue` pour trouver la plus longue chaîne de caractères parmi 3 ? Donner un exemple."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "39219559",
   "metadata": {},
   "outputs": [],
   "source": [
    "plus_longue(plus_longue(\"informatique\", \"ordinateur\"), \"calcul formel\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b870df17",
   "metadata": {},
   "source": [
    "## Exercice 4 : fonctions simples\n",
    "\n",
    "**Question 1 :** Écrire une fonction `valeur_absolue(x)`, qui prend en entrée un nombre `x`, et qui retourne sa valeur absolue. Bien entendu, on n'utilisera **pas** la fonction native de python qui effectue ce calcul, mais on utilisera plutôt une structure conditionnelle **if/else** suivant le signe de `x`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "aadcc394",
   "metadata": {},
   "outputs": [],
   "source": [
    "def valeur_absolue(x):\n",
    "    if x < 0:\n",
    "        return -x\n",
    "    else:\n",
    "        return x"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "49ca9d64",
   "metadata": {},
   "source": [
    "**Question 2 :** Tester la fonction `valeur_absolue` avec deux exemples judicieux (c'est-à-dire, qui permettent de traiter les deux branches de la fonction)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cd2e99ac",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(valeur_absolue(2))\n",
    "print(valeur_absolue(-2))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "04bbd079",
   "metadata": {},
   "source": [
    ":::{admonition} Remarque\n",
    "**Tester** ses fonctions est primordial en informatique. Même si on ne vous le demande pas, entraînez-vous à le faire !\n",
    ":::\n",
    "\n",
    "\n",
    "**Question 3 :** Écrire une fonction `maximum(a, b, c)` qui retourne la valeur maximale parmi $a$, $b$ et $c$. N'oubliez pas de tester votre fonction !"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4af43321",
   "metadata": {},
   "outputs": [],
   "source": [
    "def maximum(a, b, c):\n",
    "    t = a\n",
    "    if b > t:\n",
    "        t = b\n",
    "    if c > t:\n",
    "        t = c\n",
    "    return t\n",
    "print(maximum(1, 4, 2))\n",
    "print(maximum(-7, 0, 9))\n",
    "print(maximum(12, 3, 2))\n",
    "print(maximum(0, 0, 0))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dcd4569d",
   "metadata": {},
   "source": [
    "**Question 4 :**  Écrire une fonction `nombre_de_racines(a, b, c)` qui retourne le nombre de racines réelles distinctes du polynôme à coefficients réels $a X^2 + b X + c$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d83a066a",
   "metadata": {},
   "outputs": [],
   "source": [
    "def nombre_de_racines(a, b, c):\n",
    "    delta = b**2 - 4*a*c\n",
    "    if delta > 0:\n",
    "        return 2\n",
    "    elif delta == 0:\n",
    "        return 1\n",
    "    else:\n",
    "        return 0\n",
    "     \n",
    "print(\"Nombre de racines de x^2 - 2x + 1 :\", nombre_de_racines(1, -2, 1))\n",
    "print(\"Nombre de racines de 3x^2 + 1 :\", nombre_de_racines(3, 0, 1))\n",
    "print(\"Nombre de racines de -x^2 + 6x - 2 :\", nombre_de_racines(-1, 6, -2))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3b83c84b",
   "metadata": {},
   "source": [
    "## Exercice 5 : fonctions logiques\n",
    "\n",
    "On rappelle que l'expression $A \\implies B$ a la valeur logique de $B$ **si** $A$ est vraie, et est vraie **si** $A$ est fausse.\n",
    "\n",
    "\n",
    "**Question 1 :** Écrire une fonction `implique(A, B)` qui prend en entrée deux valeurs logiques $A$ et $B$, et qui retourne la valeur logique de $A \\implies B$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8f6293c3",
   "metadata": {},
   "outputs": [],
   "source": [
    "def implique(A, B):\n",
    "    if A:\n",
    "        return B\n",
    "    else:\n",
    "        return True"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "10ea9968",
   "metadata": {},
   "source": [
    "**Question 2 :** En appelant deux fois la fonction `implique`, écrire une fonction `equivalent(A, B)` qui prend en entrée deux valeurs logiques $A$ et $B$, et qui retourne la valeur logique de $A \\iff B$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fac06586",
   "metadata": {},
   "outputs": [],
   "source": [
    "def equivalent(A, B):\n",
    "    return implique(A, B) and implique(B, A)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "90719b65",
   "metadata": {},
   "source": [
    "**Question 3 :** Vérifier, pour les $4$ valeurs possibles de $A$ et $B$,  que \n",
    "\n",
    "$$\n",
    "(A \\implies B) \\iff (\\text{non}(A) \\text{ ou } B)\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fe68327c",
   "metadata": {},
   "outputs": [],
   "source": [
    "A, B = True, True\n",
    "print(equivalent(implique(A, B), not(A) or B))\n",
    "A, B = True, False\n",
    "print(equivalent(implique(A, B), not(A) or B))\n",
    "A, B = False, True\n",
    "print(equivalent(implique(A, B), not(A) or B))\n",
    "A, B = False, False\n",
    "print(equivalent(implique(A, B), not(A) or B))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4334c584",
   "metadata": {},
   "source": [
    "**Question 4 :** Vérifier, pour les $8$ valeurs possibles de $A$, $B$ et $C$,  que \n",
    "\n",
    "$$\n",
    "((A \\implies B) \\text{ et } (B \\implies C)) \\implies (A \\implies C)\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "092bbb98",
   "metadata": {},
   "outputs": [],
   "source": [
    "A, B, C = True, True, True\n",
    "print(implique(implique(A, B) and implique(B, C), implique(A, C)))\n",
    "A, B, C = True, True, False\n",
    "print(implique(implique(A, B) and implique(B, C), implique(A, C)))\n",
    "A, B, C = True, False, True\n",
    "print(implique(implique(A, B) and implique(B, C), implique(A, C)))\n",
    "A, B, C = True, False, False\n",
    "print(implique(implique(A, B) and implique(B, C), implique(A, C)))\n",
    "A, B, C = False, True, True\n",
    "print(implique(implique(A, B) and implique(B, C), implique(A, C)))\n",
    "A, B, C = False, True, False\n",
    "print(implique(implique(A, B) and implique(B, C), implique(A, C)))\n",
    "A, B, C = False, False, True\n",
    "print(implique(implique(A, B) and implique(B, C), implique(A, C)))\n",
    "A, B, C = False, False, False\n",
    "print(implique(implique(A, B) and implique(B, C), implique(A, C)))"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "python",
   "language": "python",
   "name": "python"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}