From 02b080763f1cec508592a245433ef614d6152af9 Mon Sep 17 00:00:00 2001
From: Orestis <orestis.malaspinas@pm.me>
Date: Thu, 28 Oct 2021 15:14:19 +0200
Subject: [PATCH] removed useless slides that were integrated to cours_6
---
slides/complexite.md | 246 -------------------------------------------
1 file changed, 246 deletions(-)
delete mode 100644 slides/complexite.md
diff --git a/slides/complexite.md b/slides/complexite.md
deleted file mode 100644
index 0725e03..0000000
--- a/slides/complexite.md
+++ /dev/null
@@ -1,246 +0,0 @@
-# Efficacité d'un algorithmique
-
-Comment mesurer l'efficacité d'un algorithme?
-
-. . .
-
-* Mesurer le temps CPU,
-* Mesurer le temps d'accès à la mémoire,
-* Mesurer la place prise mémoire,
-
-. . .
-
-Dépendant du **matériel**, du **compilateur**, des **options de compilation**,
-etc!
-
-## Mesure du temps CPU
-
-```C
-#include <time.h>
-struct timespec tstart={0,0}, tend={0,0};
-clock_gettime(CLOCK_MONOTONIC, &tstart);
-// some computation
-clock_gettime(CLOCK_MONOTONIC, &tend);
-printf("computation about %.5f seconds\n",
- ((double)tend.tv_sec + 1e-9*tend.tv_nsec) -
- ((double)tstart.tv_sec + 1e-9*tstart.tv_nsec));
-```
-
-# Programme simple: mesure du temps CPU
-
-## Preuve sur un [petit exemple](../source_codes/complexity/sum.c)
-
-```bash
-source_codes/complexity$ make bench
-RUN ONCE -O0
-the computation took about 0.00836 seconds
-RUN ONCE -O3
-the computation took about 0.00203 seconds
-RUN THOUSAND TIMES -O0
-the computation took about 0.00363 seconds
-RUN THOUSAND TIMES -O3
-the computation took about 0.00046 seconds
-```
-
-Et sur votre machine les résultats seront **différents**.
-
-. . .
-
-## Conclusion
-
-* Nécessité d'avoir une mesure indépendante du/de la
- matériel/compilateur/façon de mesurer/météo.
-
-# Analyse de complexité algorithmique (1/N)
-
-* On analyse le **temps** pris par un algorithme en fonction de la **taille de
- l'entrée**.
-
-## Exemple: recherche d'un élément dans une liste triée de taille N
-
-```C
-int sorted_list[N];
-bool in_list = is_present(N, sorted_list, elem);
-```
-
-* Plus `N` est grand, plus l'algorithme prend de temps sauf si...
-
-. . .
-
-* l'élément est le premier de la liste (ou à une position toujours la même).
-* ce genre de cas pathologique ne rentre pas en ligne de compte.
-
-# Analyse de complexité algorithmique (2/N)
-
-## Recherche linéaire
-
-```C
-bool is_present(int n, int tab[], int elem) {
- for (int i = 0; i < n; ++i) {
- if (tab[i] == elem) {
- return true;
- } else if (elem < tab[i]) {
- return false;
- }
- }
- return false;
-}
-```
-
-* Dans le **meilleurs des cas** il faut `1` comparaison.
-* Dans le **pire des cas** (élément absent p.ex.) il faut `n`
- comparaisons.
-
-. . .
-
-La **complexité algorithmique** est proportionnelle à `N`: on double la taille
-du tableau $\Rightarrow$ on double le temps pris par l'algorithme.
-
-# Analyse de complexité algorithmique (3/N)
-
-## Recherche dichotomique
-
-```C
-bool is_present_binary_search(int n, int tab[], int elem) {
- int left = 0;
- int right = n - 1;
- while (left <= right) {
- int mid = (right + left) / 2;
- if (tab[mid] < elem) {
- left = mid + 1;
- } else if (tab[mid] > elem) {
- right = mid - 1;
- } else {
- return true;
- }
- }
- return false;
-}
-```
-
-# Analyse de complexité algorithmique (4/N)
-
-## Recherche dichotomique
-
-](figs/Binary_search_complexity.svg){width=80%}
-
-. . .
-
-* Dans le **meilleurs de cas** il faut `1` comparaison.
-* Dans le **pire des cas** il faut $\log_2(N)+1$ comparaisons
-
-. . .
-
-## Linéaire vs dichotomique
-
-* $N$ vs $\log_2(N)$ comparaisons logiques.
-* Pour $N=1000000$: `1000000` vs `21` comparaisons.
-
-# Notation pour la complexité
-
-## Constante de proportionnalité
-
-* Pour la recherche linéaire ou dichotomique, on a des algorithmes qui sont
- $\sim N$ ou $\sim \log_2(N)$
-* Qu'est-ce que cela veut dire?
-
-. . .
-
-* Temps de calcul est $t=C\cdot N$ (où $C$ est le temps pris pour une
- comparaisons sur une machine/compilateur donné)
-* La complexité ne dépend pas de $C$.
-
-## Le $\mathcal{O}$ de Leibnitz
-
-* Pour noter la complexité d'un algorithme on utilise le symbole
-$\mathcal{O}$ (ou "grand Ô de").
-* Les complexités les plus couramment rencontrées sont
-
-. . .
-
-$$
-\mathcal{O}(1),\quad \mathcal{O}(\log(N)),\quad \mathcal{O}(N),\quad
-\mathcal{O}(\log(N)\cdot N), \quad \mathcal{O}(N^2), \quad
-\mathcal{O}(N^3).
-$$
-
-. . .
-
-<https://fr.wikipedia.org/wiki/Analyse_de_la_complexit%C3%A9_des_algorithmes>
-
-# Quelques exercices (1/3)
-
-## Complexité de l'algorithme de test de primalité naïf?
-
-```C
-for (i = 2; i < sqrt(N); ++i) {
- if (N % i == 0) {
- return false;
- }
-}
-return true;
-```
-
-. . .
-
-## Réponse
-
-$$
-\mathcal{O}(\sqrt{N}).
-$$
-
-# Quelques exercices (2/3)
-
-## Complexité de trouver le minimum d'un tableau?
-
-```C
-min = MAX;
-for (i = 0; i < N; ++i) {
- if (tab[i] < min) {
- min = tab[i];
- }
-}
-return min;
-```
-
-. . .
-
-## Réponse
-
-$$
-\mathcal{O}(N).
-$$
-
-# Quelques exercices (3/3)
-
-## Complexité du tri par sélection?
-
-```C
-ind = 0
-while (ind < SIZE-1) {
- min = find_min(tab[ind:SIZE]);
- swap(min, tab[ind]);
- ind += 1
-}
-```
-
-. . .
-
-## Réponse
-
-### `min = find_min`
-
-$$
-(N-1)+(N-2)+...+2+1=\sum_{i=1}^{N-1}i=N\cdot(N-1)/2=\mathcal{O}(N^2).
-$$
-
-## Finalement
-
-$$
-\mathcal{O}(N^2\mbox{ comparaisons}) + \mathcal{O}(N\mbox{
-swaps})=\mathcal{O}(N^2).
-$$
-
-
-
--
GitLab