2022-2023/1NSI/09_Recherche_par_dichotomie_et_complexite/Temps d'exécution.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "6e073068",
   "metadata": {},
   "source": [
    "# Temps d'exécution et complexité\n",
    "\n",
    "Dans ce TP, vous allez chercher à évaluer la rapidité d'exécution de différents programmes.\n",
    "\n",
    "## Recherche d'élément\n",
    "\n",
    "1. Programmer et tester la fonction `chercher` qui prend en argument une liste de nombres et un nombre et qui renvoie si ce nombre est dans la liste"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3a77b4e6",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Tests"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "50901256",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Fonction\n",
    "def chercher(liste, nombre):\n",
    "    pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bf3ab537",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "40a8b167",
   "metadata": {},
   "source": [
    "On voudra tester votre fonction sur des grandes listes de nombre construites aléatoirements avec le module `random`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6e6e62eb",
   "metadata": {},
   "outputs": [],
   "source": [
    "from random import randint\n",
    "# import de la fonction randint dans le module random"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6e64bfac",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(randint(1, 10))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "28f0fdac",
   "metadata": {},
   "source": [
    "Le résultat est un nombre aléatoire entre 1 et 10.\n",
    "\n",
    "Les listes seront construites de la manière suivante"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "58200552",
   "metadata": {},
   "outputs": [],
   "source": [
    "liste_aleatoire = [randint(0, 200) for i in range(1000)]\n",
    "print(liste_aleatoire)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fc9b3bf3",
   "metadata": {},
   "source": [
    "2. Vérifier que votre fonction `chercher` fonctionne avec des listes aléatoires à 10, 100, 1000 et 1000 nombres entre 0 et 100."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ebf2bbc5",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 10 nombres"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1b3b40c9",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 100 nombres"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1c5b634f",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 1000 nombres"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e2ad8221",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 10000 nombres"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "26a61e11",
   "metadata": {},
   "source": [
    "On cherche maintenant à évaluer la rapidité d'exécution de votre fonction. Pour cela on utilisera le module `time` qui permet d'accéder au temps."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bb9f1569",
   "metadata": {},
   "outputs": [],
   "source": [
    "from time import time\n",
    "# import de la fonction time dans le module time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6502ae21",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(time())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8d97d48f",
   "metadata": {},
   "source": [
    "le résultat est le nombre de secondes écoulée depuis le 1 janvier 1970.\n",
    "\n",
    "3. Pour mesurer le temps d'exécution, on enregistre le temps avant l'exécution de la fonction puis on faire la différente avec le temps après l'exécution.\n",
    "\n",
    "Combien de temps prend la commande `cherche([1, 7, 8, 3, 9, 3], 9)` à s'exécuter?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "eab8639d",
   "metadata": {},
   "outputs": [],
   "source": [
    "t = time()\n",
    "chercher([1, 7, 8, 3, 9, 3], 9)\n",
    "print(time() - t)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a053fc3b",
   "metadata": {},
   "source": [
    "4. Combien de temps met votre fonction pour chercher un nombre dans une liste de 10 nombres? 100 nombres? 1000nombres? 10 000 nombres?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "17f17db3",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 10 nombres"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "98444ddb",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 100 nombres"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "be9d12d2",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 1000 nombres"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b9621131",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 10000 nombres"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "57840abf",
   "metadata": {},
   "source": [
    "5. Le soucis de cette méthode est que l'on est pas à l'abris d'une liste \"facile\". Vous devez faire la même chose en calculant 5 fois le temps pour 5 listes différentes puis faire la moyenne des temps d'exécution. *(je vous encourage à programmer une fonction `moyenne` pour calculer cette moyenne)*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b67b8fea",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "531e00f3",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 10 nombres"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "16502cac",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 100 nombres"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e2ea7281",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 1000 nombres"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "370f6d59",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 10000 nombres"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6c13e06b",
   "metadata": {},
   "source": [
    "On va maintenant tracer le temps d'exécution en fonction de la taille de la liste.\n",
    "\n",
    "Pour cela, vous allez utiliser la librairy graphique `matplotlib`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "10e8f28a",
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4318058e",
   "metadata": {},
   "outputs": [],
   "source": [
    "# taille des listes\n",
    "x = [10, 100, 1000, 10000]\n",
    "# Temps\n",
    "t = [1, 2, 3, 4]\n",
    "# le graphique\n",
    "fig, ax = plt.subplots()\n",
    "ax.plot(x, t)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7818c04e",
   "metadata": {},
   "source": [
    "6. Tracer le graphique des temps d'exécution de votre fonction `chercher`. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a312000a",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "846b0e02",
   "metadata": {},
   "source": [
    "7. Comparer les temps "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0bc4af7b",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "4e3e4ace",
   "metadata": {},
   "source": [
    "## Fonction max\n",
    "\n",
    "On souhaite étudier le temps d'exécution d'une fonction `maximum`.\n",
    "\n",
    "1. Progammer et tester la fonction `maximum` qui prend en argument une liste de liste de nombres et qui renvoie le plus grand élément parmi toutes les listes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0e5424b5",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Tests\n",
    "assert maximum([[1, 2, 3], [7, 3, 1]]) == 7"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a0562579",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Fonction"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fee2f5da",
   "metadata": {},
   "source": [
    "2. Mesurer le temps d'exécution de votre fonction sur des listes avec 10, 100, 1000, 10000 et 100000 nombres."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9004c51c",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3d16cef9",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f1914122",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "91d57e06",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b83b39b1",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "4e4324ba",
   "metadata": {},
   "source": [
    "3. Reprendre la question précédente en faisant la moyenne des temps d'exécution sur 5 listes pour chaque taille."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "30d640cd",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bb771796",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3a36f920",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "79e54764",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "530204ee",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "ef7c19a2",
   "metadata": {},
   "source": [
    "4. Tracer le graphique de la moyenne de temps d'exécution en fonction de la taille des listes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fff676a4",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "deb97308",
   "metadata": {},
   "source": [
    "## Recherche par dichotomie.\n",
    "\n",
    "La recherche par dichotomie permet de grandement améliorer la vitesse de recherche d'un élément dans un liste. **À condition que cette liste soit triée en ordre croissant**.\n",
    "\n",
    "1. Chercher et expliquer la meilleur stratégie pour gagner [au jeu du plus ou moins](https://raw.opytex.org/1NSI/09_Recherche_par_dichotomie_et_complexite/plus_moins/plus_moins.html)"
   ]
  },
  {
   "cell_type": "raw",
   "id": "c78246e0",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "65cf15cd",
   "metadata": {},
   "source": [
    "La résolution du jeux précédent est très similaire à la situation de recherche par dichotomie.\n",
    "\n",
    "2. Pour vous entrainé à la recherche par dichotomie, établir un algorithme qui permet de trouver en le moins de coup possible (en moyenne) un élément dans une liste triée. Pour tester votre stratégie vous pouvez utiliser [ce jeu]()."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a8b722a9",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "73ccf876",
   "metadata": {},
   "source": [
    "3. On suppose maintenant que la liste `L = [x0, x1, . . . , x]` est triée en ordre croissant, c'est\n",
    "à dire :\n",
    "    \n",
    "            x0 ⩽ x1 ⩽ · · · ⩽ xn\n",
    "            \n",
    "On cherche parmi les éléments de `L` l'élément x.\n",
    "            \n",
    "On désigne par `L[i..j]` les éléments de L dont les indices sont compris entre i (inclu) et j\n",
    "(inclu). \n",
    "\n",
    "On suppose que parmi les éléments de `L[g..d]`, il y a un élément x. Et on considère un\n",
    "indice m tel que g ⩽ m ⩽ d.\n",
    "\n",
    "Si L[m]<x, dans quelle nouvelle zone est-on sûr que x se trouve ?"
   ]
  },
  {
   "cell_type": "raw",
   "id": "bf3961fa",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "645c4300",
   "metadata": {},
   "source": [
    "Si L[m]>x, dans quelle nouvelle zone est-on sûr que x se trouve ?"
   ]
  },
  {
   "cell_type": "raw",
   "id": "fb42b270",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "7c6f53e5",
   "metadata": {},
   "source": [
    "Que peut-on affirmer si aucune des deux conditions précédentes n'est valide ?"
   ]
  },
  {
   "cell_type": "raw",
   "id": "d8cf7292",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "6d046b52",
   "metadata": {},
   "source": [
    "4. Compléter le fonction suivante en respectant la spécification de la docstring"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "0afedcb2",
   "metadata": {},
   "outputs": [],
   "source": [
    "def dichotomie(L, x):\n",
    "    \"\"\" Renvoie un indice de l'élément x dans L si x est dedans, et renvoie None sinon\n",
    "    \n",
    "    On supposera que la liste L est triée en ordre croissant.\n",
    "    \"\"\"\n",
    "    g = 0\n",
    "    d = len(L)-1\n",
    "    while g <= l:\n",
    "        m = (g + d) // 2\n",
    "        if L[m] < x:\n",
    "            ...\n",
    "        elif L[m] > x:\n",
    "            ...\n",
    "        else:\n",
    "            ...\n",
    "    return None"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5e3bde1e",
   "metadata": {},
   "source": [
    "5. Mesurer le temps d'exécution de votre fonction sur des listes avec 10, 100, 1000, 10000 et 100000 nombres."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "603757b0",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6959bcfb",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9a834ec6",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f3e9a104",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6093b13a",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "db5d9f35",
   "metadata": {},
   "source": [
    "6. Reprendre la question précédente en faisant la moyenne des temps d'exécution sur 5 listes pour chaque taille."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "906ce312",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "69213d32",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "51e69361",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d8d068cb",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b3628a5f",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "a6966564",
   "metadata": {},
   "source": [
    "7. Tracer le graphique de la moyenne de temps d'exécution en fonction de la taille des listes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "96687215",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.10.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}