test

% !TXS template
\documentclass[french]{article}
\usepackage[T1]{fontenc}
\usepackage[utf8]{inputenc}
\usepackage{lmodern}
\usepackage{amsmath}
%\usepackage{unicode-math}
\usepackage[a4paper]{geometry}
\usepackage{pifont}
\usepackage{amsfonts}
\usepackage{lmodern}
\usepackage{babel}
\usepackage{stmaryrd}
\usepackage{fancyhdr}
\usepackage[T1]{fontenc}

%\usepackage{minted}

%\usepackage{titlesec}
\usepackage{lipsum}
\author{Théo DIEDA}
\date{2021 - 2022}
\title{Cours d'Informatique PCSI}

\pagestyle{fancy}
\renewcommand\headrulewidth{1pt}
\fancyhead[L]{Théo DIEDA}
\fancyhead[R]{PCSI 1 - Lycée Kléber}
\fancyfoot[C]{Page \thepage}
\fancyfoot[R]{2021/2022}



\usepackage{xcolor}
\definecolor{rouge}{HTML}{ff0000}
\definecolor{bleu}{HTML}{0000ff}
\definecolor{vert}{HTML}{00ff00}

\usepackage{titlesec}
% ----- CUT HERE ----- %
%  Supplement to titlesec providing the \addtotitleformat
%+ command for appending instead of overwriting the current style.
\makeatletter
\newcommand*\@secondofsix[6]{#2}
\newcommand{\addtotitleformat}{%
    \@ifstar{\addtotitleformat@star}{\addtotitleformat@nostar}}
\newcommand\addtotitleformat@nostar[2]{%
    \PackageError{titlesec}{non starred form of \string\addtotitleformat\space not supported}{}}
\newcommand\addtotitleformat@star[2]{%
    \edef\@currentsection@font{%
        \unexpanded\expandafter\expandafter\expandafter
            {\expandafter\expandafter\expandafter\@secondofsix \csname ttlf@\expandafter\@gobble\string#1\endcsname}}%
    \titleformat*{#1}{\@currentsection@font#2}%
}
\makeatother
% ----- CUT HERE ----- %



\renewcommand{\thesection}{\color{rouge}\huge\Roman{section})}
\addtotitleformat*{\section}{\color{rouge}\huge}
\renewcommand{\thesubsection}{\color{bleu}\Large\arabic{subsection})}
\addtotitleformat*{\subsection}{\color{bleu}\Large}
\renewcommand{\thesubsubsection}{\color{vert}\large\alph{subsubsection})}
\addtotitleformat*{\subsubsection}{\color{vert}\large}


\setlength{\parindent}{0pt}
\renewcommand{\Frlabelitemi}{\textbullet}

%%%
%\renewcommand{\thesection}{\Roman{section}/}
%\renewcommand{\thesubsection}{\arabic{subsection}/}
%\renewcommand{\thesubsubsection}{\alph{subsubsection})}
%%%

\usepackage{listings}
%%%------------------------
%New colors defined below
\definecolor{codegreen}{rgb}{0,0.6,0}
\definecolor{codegray}{rgb}{0.5,0.5,0.5}
\definecolor{codepurple}{rgb}{0.58,0,0.82}
\definecolor{backcolour}{rgb}{0.95,0.95,0.92}

%Code listing style named "mystyle"
\lstdefinestyle{mystyle}{
  backgroundcolor=\color{backcolour},   commentstyle=\color{codegreen},
  keywordstyle=\color{magenta},
  numberstyle=\tiny\color{codegray},
  stringstyle=\color{codepurple},
  basicstyle=\ttfamily\footnotesize,
  breakatwhitespace=false,         
  breaklines=true,                 
  captionpos=b,                    
  keepspaces=true,                 
  numbers=left,                    
  numbersep=5pt,                  
  showspaces=false,                
  showstringspaces=false,
  showtabs=false,                  
  tabsize=2
}

%"mystyle" code listing set
\lstset{style=mystyle}
%%%-------------------------













\begin{document}
	%\tableofcontents
	\newpage 

\part{Méthode de programmation et analyse des algorithmes}

\section{Organisation générale du code}
\subsection{Rappels}
\textbf{Notion de variable :} c'est une petite boite qui peut contenir notre valeur\\
Instruction conditionnelles : If, elif, else (si on arrive ici c'est que les conditions d'avant n'ont pas été vérifiée)\\

\textbf{Boucles :}
\begin{itemize}
	\item For :  on fait $N$ action dans notre boucle (on peut modifier la valeur de i dans la boucle étant donné qu'il reprendra sa valeur à $i+1$)
	\item While : tant que "condition" est vraie, on fait ....\\
\end{itemize}

La notion d'instruction : ce que l'on demande à l'ordi \\ Notion d'expression : ce qui se calcule\\

\textit{NB : le fait que l'assignation soit une instruction $\Rightarrow$ choix du langage}\\

On peut stocker l'évaluation d'une condition dans une variable :
\begin{itemize}
	\item while $x<18$ : ...
	\item condition = $(x<18)$, while condition: ....\\
\end{itemize}

\textbf{Notion d'effet de bord :}
Normalement quand on définit une fonction, elle doit renvoyer une valeur mais parfois, on ne veut rien renvoyer mais juste changer quelque chose :
\begin{itemize}
	\item Tri "en place" d'une liste $\rightarrow$ modification de la liste visible à l'extérieur d'une fonction
	\item print() $\rightarrow$ affiche à l'écran mais ne renvoi rien
	\item L.append(x) $\rightarrow$ modifie L mais ne renvoi rien $\Rightarrow$ NE JAMAIS ÉCRIRE : \texttt{L= L.append(x)}
\end{itemize}



\subsection{Spécification des données / d'une fonction}
Règles de bonne conduite lors de l'écriture d'une fonction : On dit ce qu'on attend en entrée et ce que fournit la fonction en sortie $\Rightarrow$ le mettre en docstrings (on met les objets d'entrée $\rightarrow$ objets de sorties puis on décrit la fonction)


\subsection{Préconditions, postconditions, invariants}

\subsubsection{Préconditions}
Lors de l'écriture d'une fonction, on a souvent besoin de contraintes supplémentaires sur les données $\rightarrow$ On les signale en commentaire ou en docstring\\
\textit{Exemple : "($n$:int)$\rightarrow$ int \vspace{0.2cm} $n$ est un entier positif ou nul"}\\

On peut avoir une précondition à l'entrée d'une boucle plus loin dans la fonction\\
\textit{Exemple : avant de distribuer les petits pois, on doit avoir la + gde fact < nbre de petit pois}\\

\textbf{But :} Ces préconditions à une partie de code servent de jalons qu'on pourra donc vérifier au fur et à mesure de l'éxécution du programme $\rightarrow$ mettre des commentaires et des notes pour le futur

\subsubsection{Postconditions}
Une fois une boucle ou une fonction exécutée, on doit avoir certaines propriétés qu'il suffit d'énoncer en commentaire ou en docstring s'il s'agit du résultat de la fonction.\\

\textbf{But :} Détecter de possibles erreurs de programmation\\

\textbf{Bonne conduite :} on énonce (en commentaire) ce qu'on veut avant de commencer à coder et on vérifie a posteriori que ca fonctionne.

\subsubsection{Invariants (de boucle)}
Lors de l'écriture d'une boucle, il arrive souvent qu'une certaine propriété soit conservée au passage de la boucle $\rightarrow$ on parle d'invariant (exemple : fusion, à chaque tour L est triée)\\

\textit{Remarque : Souvent démontrer qu'une propriété est un invariant permettra de prouver la correction de l'algorithme $\rightarrow$ Le fait qu'il soit correct}\\

Lors de la phase de programmation, il sera bon de se laisser des commentaires qui verbalisent ces invariants



\subsection{Vérifications par assertions}
Une fois tout écrit en commentaire, on peut essayer de vérifier le tout avec la fonction 'assert'\\
NB : l'usage de 'assert' doit être réservé à la phase de conception ou de débgugage car Python la désactive en mode de production.
Cela permet de se mettre des gardes-fous lors de la conception.\\

\textbf{Usage :} assert(condition, messagesipb) :
'condition' est une expression qui doit s'évaluer à :
\begin{itemize}
	\item True : tout va bien, rien ne se passe
	\item False : la fonction meurt en affichant 'messagesipb'\\
\end{itemize}

Exemple :
%\begin{minted}{Python}
\begin{lstlisting}[language=Python]
def fusion(L1,L2):
	"(liste,liste)->list
	'L1' et 'L2' sont 2 listes triées d'éléments comparables.
	Renvoie 'L' une liste triée, fusion de 'L1' et 'L2'"
	#Précondition : L1 et L2 triés
	assert(est_triee(L1), "L1 non triée !")
	assert(est_triee(L2), "L2 non triée !")
	
	L=[] #Liste d'arrivée
	i1, i2, n1, n2 = 0, 0, len(L1), len(L2) #Initialisation
	
	for i in range(n1+n2):
		if i1==n1 or (i2 < n2 and L1[i1] > L2[i2]):
			candidat = L2[i2]
			i2 += 1
		else:
			candidat = L1[i1]
			i1 += 1
		L.append(candidat) 
		#L est triée et de bonne taille
		assert(est_triee(L), "L non triée dans la boucle")
		asseert(len(L)==i+1, "L pas de bonne taille")
	return L
\end{lstlisting}
%\end{minted}