Feat(NSI): cours sur la complexité

1NSI/09_Recherche_par_dichotomie_et_complexite/1B_complexite.tex

@@ -0,0 +1,89 @@
+\documentclass[a4paper,10pt]{article}
+\usepackage{myXsim}
+\usepackage{minted}
+
+\author{Benjamin Bertrand}
+\title{Recheche par dicotomie et complexité - Cours}
+\date{Mars 2023}
+
+\pagestyle{empty}
+
+\begin{document}
+
+\maketitle
+
+\section{Complexité}
+
+\begin{definition}[Ordre de complexité]
+    On dit qu'un algorithme est d'une \textbf{compléxité de l'ordre de $f(n)$} si il existe une constante positive K telle que, quelle que soit la taille n de l'entrée, le nombre d'opérations élémentaires est plus petit que $K \times f(n)$.
+
+    On dit alors que l'algorithme est en $\mathcal{O}(f(n))$.
+\end{definition}
+
+\section{Etude de la complexité}
+
+\begin{enumerate}
+    \item Recherche du maximum d'une liste
+        \begin{multicols}{2}
+            \inputminted[bgcolor=base3]{python}{./algos/1B_max.py}
+
+            Calcul de la compléxité
+        \end{multicols}
+    \item Moyenne
+        \begin{multicols}{2}
+            \inputminted[bgcolor=base3]{python}{./algos/1B_max.py}
+
+            Calcul de la compléxité
+        \end{multicols}
+    \item Table de multiplication
+        \begin{multicols}{2}
+            \inputminted[bgcolor=base3]{python}{./algos/1B_table.py}
+
+            Calcul de la compléxité
+        \end{multicols}
+    \item Recherche par dichotomie
+        \begin{multicols}{2}
+            \inputminted[bgcolor=base3]{python}{./algos/1B_dicho.py}
+
+            Calcul de la compléxité
+        \end{multicols}
+\end{enumerate}
+
+
+\section{Les complexités courantes}
+
+Dans la pratique, on ne choisira que des fonctions $f(n)$ simples prise dans la liste suivante (classé par ordre croissant de rapidité):
+
+\begin{itemize}
+    \item $\mathcal{O}(1)$: complexité constante. Le temps d'exécution est indépendant de $n$ (la taille de l'entrée).
+
+        \textbf{Exemples}:
+
+    \item $\mathcal{O}(log(n))$: complexité logarithmique. Le temps d'exécution augmente d'une quantité constante quand la taille de l'entrée ($n$) est doublée.
+
+        \textbf{Exemple}:
+
+    \item $\mathcal{O}(nlog(n))$: complexité linéaire. Le temps d'exécution est proportionnel à la taille de l'entrée ($n$)
+
+        \textbf{Exemples}:
+
+    \item $\mathcal{O}(n^2)$: complexité quadratique. Le temps d'exécution est multiplié par 4 quand la taille de l'entrée est multipliée par 2.
+
+        \textbf{Exemples}:
+
+    \item $\mathcal{O}(n^k)$: complexité polynomiale. Le temps d'exécution est majoré par un polynôme de la taille d'entrée.
+
+        \textbf{Exemples}:
+
+    \item $\mathcal{O}(k^n)$: complexité exponentielle. Le temps d'exécution croit trop rapidement pour que la taille d'entrée puisse être grand.
+
+        \textbf{Exemples}:
+\end{itemize}
+
+\paragraph{Temps d'exécution en fonction de la taille d'entrée}~
+
+\begin{center}
+    \includegraphics[scale=0.9]{./fig/complexite}
+\end{center}
+
+\end{document}

1NSI/09_Recherche_par_dichotomie_et_complexite/algos/1B_dicho.py

@@ -0,0 +1,12 @@
+def dichotomie(liste, x):
+    g = 0
+    d = len(L)-1
+    while g <= l:
+        m = (g + d) // 2
+        if L[m] < x:
+            g = m
+        elif L[m] > x:
+            d = m
+        else:
+            return m
+    return None

1NSI/09_Recherche_par_dichotomie_et_complexite/algos/1B_max.py

@@ -0,0 +1,6 @@
+def maximum(liste):
+    candidat = liste[0]
+    for element in liste:
+        if element > candidat:
+            candidat = element
+    return candidat

1NSI/09_Recherche_par_dichotomie_et_complexite/algos/1B_moyenne.py

@@ -0,0 +1,5 @@
+def moyenne(liste):
+    moy = 0
+    for element in liste:
+        moy = moy + element
+    return moy / len(liste)

1NSI/09_Recherche_par_dichotomie_et_complexite/algos/1B_table.py

@@ -0,0 +1,6 @@
+def table(liste):
+    resultats = []
+    for element1 in liste:
+        for element2 in liste:
+            resultats.append(element1 * element2)
+    return resultats