%\documentclass{article} %DÉSACTIVER POUR A5
\documentclass[a5paper]{article} %ACTIVER POUR A5

%########
% Packages #
%########

\usepackage[utf8]{inputenc}
\usepackage[T1]{fontenc}
\usepackage[frenchb]{babel}

%######Affichage des maths
\DecimalMathComma %pour ne plus avoir d'espace après la virgule dans l'écriture décimale des nombres

\usepackage{amsmath}
\usepackage{amssymb,amsthm}
\usepackage{mathrsfs}
\usepackage{amsopn}

\usepackage[np]{numprint}%écriture des nombres avec des espaces et en écriture scientifique

\usepackage{dsfont} %Pour faire le 1 double barre de la fonction caractérisitque dans un enironnement maths. \mathds{1}
%\usepackage{bbold} %Double barre mais en petit pour tout les nombres dans un enironnement maths.\mathbb{1}

%######Graphique
\usepackage[dvipsnames]{xcolor}
\usepackage{graphicx}
\usepackage{pgf}
\usepackage{tikz}
\usepackage{tkz-tab}
\usetikzlibrary{shapes,arrows}

\usepackage{geometry} 
\geometry{hscale=0.85,vscale=0.85,centering}

%######Tableau
\usepackage{array}%pour centrer dans un tableau

\usepackage{colortbl}%pour colorier les cellules lignes colonnes d'un tableau: \rowcolor{} , 	\columncolor{}

\usepackage{tabularx}%quelques amélioraions de l"environnement tabular

\usepackage{diagbox} % Pour faire une diagonale dans une case d'un tableau: \diagbox{bas gauche}{haut droit}

%######Hyperliens dans les pdf

\usepackage[colorlinks=true,linkcolor=Violet,urlcolor=Violet]{hyperref}% Pour créer des liens à l'intérieur du pdf: \hyperlink{label}{texte du lien} permettra d'atteindre la cible identifiée par \hypertarget{label}{texte de la cible}. Les textes du lien et de la cible peuvent être vides.

%######Vrac
\usepackage{eurosym}%pour afficher le symbole euro

\usepackage{enumerate}%énumération avec des lettres Pour avoir une liste en ligne utiliser \begin{tasks} et non pas enumerate puis \task et non pas \item

\usepackage{stmaryrd}%pour faire des "intervalles" d'entiers \llbracket et \rrbracket

\usepackage{xlop}%poser les calculs

\usepackage{verbatim}%pour utiliser commande \exclure et normalement pour faire l'affichage tel quel sans compiler le texte. 
%\usepackage{alltt}%Pour utiliser une commande latex dans un environnement verbatim il faut utiliser: alltt

\usepackage{fancyhdr}

%######Algo

\usepackage{listings} % \begin{lstlisting} \end{lstlisting} affiche du code comme le fait le langage choisi. \lstset{language=Pascal} \lstset{language=Python} pour choisir le langage dans le document avant chaque programme ou avant le \begin{document} pour l'appliquer à tout le document. \lstset{} permet d'indiquer toutes les options. Pas de caractère accentué (option lourdingue à rajouter). Il espossible d'inclure un code python d'un fichier extérieur \lstinputlisting{source_filename.py}.
\lstset{language=Python}

\usepackage[french]{algorithm2e}%pseudocode

%############### Formule developpée molécule chimie

\usepackage{chemfig}

%#####################
% Commande et environnement #
%#####################

\theoremstyle{plain}

%Pour redéfinir les commande section (changer la couleur centrer):
\usepackage{titlesec}
\titleformat{\section}[block]{\color{blue}\Large\bfseries\filcenter}{}{1em}{}
\titleformat{\subsection}[hang]{\color{purple}\large\bfseries}{\thesubsection}{1em}{}
\titleformat{\subsubsection}[hang]{\color{purple!75}\bfseries}{\thesubsubsection}{1em}{}
\titleformat{\paragraph}[hang]{}{}{1em}{}

\renewcommand{\thesection}{{}}
\renewcommand{\thesubsection}{\color{purple}\Roman{subsection}}
\renewcommand{\thesubsubsection}{\color{purple!75}\Roman{subsection}-\arabic{subsubsection}}

\newenvironment{correction}{\color{Brown}}{\medskip}

\newenvironment{sujet}{}{\medskip}

%environnement bareme
\newenvironment{bareme}{\footnotesize \hfill }{\footnotesize \emph{~points}}


\newenvironment{notes}{\color{violet}\noindent ~\\}{~\\}

%Pour redéfinir les environnements exercices et autres avec de la couleur
\newsavebox{\selvestebox}
\newenvironment{colbox}[1]
{\newcommand\colboxcolor{#1}%
	\begin{lrbox}{\selvestebox}%
		\begin{minipage}{\dimexpr\columnwidth-2\fboxsep\relax}}
		{\end{minipage}\end{lrbox}%
	\begin{center}
		\colorbox{\colboxcolor}{\usebox{\selvestebox}}
\end{center}}

%environnement exercice
\newcounter{Exercice}
\setcounter{Exercice}{1}
\newcounter{Exercicecorrection}
\newenvironment{exercice}{ \setcounter{Exercicecorrection}{\theExercice} \color{blue} \begin{colbox}{blue!7} \hfill {\color{RoyalBlue}Exercice \theExercice} \hfill \addtocounter{Exercice}{1} \small}{ \end{colbox} }

%environnement exercicecorrection
\newenvironment{exercicecorrection}{\medskip \small \color{Brown} \noindent \hfill\rule{0.25\linewidth}{0.1pt} {Correction exercice \theExercicecorrection} \rule{0.25\linewidth}{0.1pt}\hfill}{\noindent \hfill\rule{0.2\linewidth}{0.1pt}Fin de la correction\rule{0.2\linewidth}{0.1pt}\hfill \medskip}

%environnement exercice supplémentaire
\newenvironment{exercicesup}{ \setcounter{Exercicecorrection}{\theExercice} \medskip \noindent \underline{\footnotesize\color{violet}Exercice \theExercice{} pour s'entraîner. } \addtocounter{Exercice}{1} \medskip \color{violet}\footnotesize}{\medskip}

%environnement exercice interrogation
\newcounter{Exerciceinterro}
\setcounter{Exerciceinterro}{1}
\newenvironment{exerciceinterro}{
\medskip \noindent \underline{\color{purple}Exercice noté \theExerciceinterro . } \addtocounter{Exerciceinterro}{1} \medskip \color{blue}\small }{\medskip}

%environnement exercice interrogation déjà donné
\newcounter{Exerciceinterrofait}
\setcounter{Exerciceinterrofait}{1}
\newenvironment{exerciceinterrofait}{
\medskip \noindent \underline{\color{purple}Exercice noté déjà fait\theExerciceinterrofait . } \addtocounter{Exerciceinterrofait}{1} \medskip \color{blue}\small }{\medskip}

%environnement pour le résumé de la démonstration écrire en orange
\newenvironment{resume}{\color{orange}}{\medskip}

%environnement definition
\newcounter{Definition}
\setcounter{Definition}{1}
\newenvironment{définition}{\medskip \noindent {\color{MidnightBlue}Définition \theDefinition} \addtocounter{Definition}{1} \newline \noindent \begin{tabular}{|>{\columncolor{MidnightBlue!10}}m{12cm}|}\hline \\ }{\\ \hline \end{tabular}}

%environnement théorème il est possible d'ajouter un titre de théorème en mettant entre accolade le titre après le begin{théorème}
\newcounter{Theoreme}
\setcounter{Theoreme}{1}
\newenvironment{théorème}[1]{\medskip \noindent {\color{purple}Théorème \theTheoreme #1} \addtocounter{Theoreme}{1} 

\noindent \begin{tabular}{||m{12cm}||}\hline \\ }{\\ \hline \end{tabular}}

%environnement proposition
\newcounter{Proposition}
\setcounter{Proposition}{1}
\newenvironment{proposition}[1]{\medskip \noindent {\color{Purple}Proposition \theProposition #1} \addtocounter{Proposition}{1}

\noindent \begin{tabular}{|>{\columncolor{Purple!5}}m{12cm}|}\hline \\}{\\ \hline \end{tabular}}

%environnement lemme
\newcounter{Lemme}
\setcounter{Lemme}{1}
\newenvironment{lemme}[1]{\medskip \noindent {\color{Plum}Lemme \theLemme #1} \addtocounter{Lemme}{1}

\noindent \begin{tabular}{|>{\columncolor{Plum!5}}m{12cm}|}\hline \\ }{\\ \hline \end{tabular}}

%environnement corollaire
\newcounter{Corollaire}
\setcounter{Corollaire}{1}
\newenvironment{corollaire}[1]{\medskip \noindent {\color{RedViolet}Corollaire \theCorollaire #1} \addtocounter{Corollaire}{1} 

\noindent \begin{tabular}{|>{\columncolor{RedViolet!5}}m{12cm}|}\hline \\ }{\\ \hline \end{tabular}}

%environnement démonstration
\newcounter{Demonstration}
\setcounter{Demonstration}{1}
\newenvironment{preuve}{\medskip \noindent \color{CadetBlue} \hfill \rule{0.25\linewidth}{0.1pt} {\color{PineGreen}Démonstration \theDemonstration} \rule{0.25\linewidth}{0.1pt} \hfill \addtocounter{Demonstration}{1} \color{CadetBlue} 

}{\noindent \hfill\rule{0.2\linewidth}{0.1pt}Fin de la démonstration\rule{0.2\linewidth}{0.1pt}\hfill}

%environnement conclusion encadré et coloré
\newenvironment{conclusion}
	{\color{PineGreen}\begin{tabular}{|c|}\hline \\ \begin{minipage}{0.85\linewidth} \begin{center} }
	{\end{center} \end{minipage} \\ \\ \hline \end{tabular} }

%Commande pour l'objectif et l'écrire en vert
\newcommand{\objectif}[1]{{\color{PineGreen}#1}

\medskip}


%########################
%Test conditionnel pour l'affichage    #
%########################
\newif\ifs
\strue%affiche la boite à trous
%\sfalse%affiche la réponse

%Pour faire une case à trou complétable sur le pdf
\newcounter{Trous}
\setcounter{Trous}{1}
\newcommand{\trous}[2][3cm]{
\ifs
\begin{Form}
\TextField[name=\theTrous ,bordercolor=,borderwidth=0, backgroundcolor=gray!20, align=1,  width=#1 ,height=0.2cm, bordersep=0,color=black] {}
\end{Form}
\xspace
\else
#2
\fi
\addtocounter{Trous}{1}
}

%en tête puis pied de page
\pagestyle{empty}
\pagestyle{fancy} 
\renewcommand{\headrulewidth}{0pt}%Pas de ligne horizontale en haut
\lhead[]{}%entre crochets pages paires entre accolades pages impaires
\chead[\small ]{\footnotesize \href{http://unemainlavelautre.net/}{Variables et instructions élémentaires} }% l left, c center, r right
\rhead[]{}
\lfoot[]{}
\cfoot[\small -\thepage -]{\small -\thepage -}
\rfoot[]{}

%Les couleurs déjà utilisées: blue = liens url, purple = mot importants, brown = correction, cyan = notes, green= exercices du manuel correspondant à la partie, orange=definition, purple = exercice, violet=proposition, corollaire et démonstration

%############################
%les environnements qu'on affiche ou pas  #
%############################

\newcommand{\exclure}[1]{\renewenvironment{#1}{\begingroup\comment}{\endcomment\endgroup\ignorespaces}}
\exclure{exerciceinterro}
\exclure{bareme}
\exclure{notes}
\exclure{exerciceinterrofait}
%\exclure{exercicecorrection}
%\exclure{correction}
\exclure{resume}
\exclure{preuve}
%\exclure{sujet}

\begin{document}

\section{Variables et instructions élémentaires.}

\begin{notes}
	
	Cette leçon sera faite deux fois: avec calculatrice et avec python. Certains exercices ne peuvent être fait qu'avec la connaissance de Python. Les exemples doivent ête programmés au fur et à mesure d'abord avec calculatrice et ensuite avec Python.
	
	Il faut faire un mémento des instructions calculatrices et un mémento des Python.
	
\end{notes}
	
\subsection{Variables, instructions, et premières fonctions.}

\subsubsection{Les variables.}

En programmation une \emph{\color{purple}variable} est le nom donné à quelque chose (nombre en général) de mémorisé dans la machine.

\medskip
Remarques.
\begin{enumerate}
	\item La variable en programmation n'est pas celle des mathématiques.
	\item Si la variable avec la calculatrice est un nombre (décimal) avec Python il y a différents types de variables (cf \emph{infra}).
\end{enumerate}

\subsubsection{Affectation}

L'instruction qui consiste a créer une variable, \emph{i.e.} enregistrer quelque chose dans une variable, est appelée une \emph{\color{purple}affectation} (ou \emph{assignation}).

Par exemple pour enregistrer le nombre $3$ dans la variable $C$:

\medskip
\noindent
\begin{tabular}{|m{4cm}|m{2.4cm}|m{2.4cm}|m{2.4cm}|}
	\hline
		Scratch
		&
		Algorithme
		&
		Python 3
		&
		Ti
	\\
		\includegraphics[scale=0.35]{2ieme_calcul_numerique_01_variables_et_instructions_elementaires_01_affectation_scratch.png}
		&
		$C \leftarrow 3$
		&
		\begin{tabular}{c}
			\begin{minipage}{2cm}
				\begin{lstlisting}{language=Python}
C=3
				\end{lstlisting}
			\end{minipage}
			\\
		\end{tabular}
		&
		$3 \rightarrow C$
	\\
	\hline
\end{tabular}

\medskip
Remarques.
\begin{enumerate}
	\item Avec Python le nom de la variable peut être un mot, par exemple \emph{lavariableC}, mais avec la calculatrice la variable est une seule lettre, $C$.
	\item Contrairement au $"="$ des mathématiques, la commande d'affectation de Python $"="$ n'est pas symétrique. Il ne faut pas écrire \begin{tabular}{c}
		\begin{minipage}{0.8cm}
			\begin{lstlisting}{language=Python}
3=C
			\end{lstlisting}
		\end{minipage}
		\\
	\end{tabular}.
	\item Si la variable $C$ était déjà utilisée, affecter $5+C$ à $C$ efface la précédente valeur enregistrée, $3$, dans $C$ et la remplace par $5+3$. 
\end{enumerate}

\subsubsection{Afficher.}

Pour voir ce qui a été enregistré dans une variable nous utilisons une instruction d'affichage.

Par exemple pour afficher le contenu de la variable $C$:

\medskip
\noindent
\begin{tabular}{|m{4cm}|m{2.4cm}|m{2.4cm}|m{2.4cm}|}
	\hline
	Scratch
	&
	Algorithme
	&
	Python 3
	&
	Ti
	\\
	\includegraphics[scale=0.3]{2ieme_calcul_numerique_01_variables_et_instructions_elementaires_02_affichage_scratch.png}
	&
	$\text{Afficher } C$
	&
	\begin{tabular}{c}
		\begin{minipage}{2cm}
			\begin{lstlisting}{language=Python}
print(C)
			\end{lstlisting}
		\end{minipage}
		\\
	\end{tabular}
	&
	$\text{Disp }C$
	\\
	\hline
\end{tabular}

\subsubsection{Séquence.}

Dans les langages de programmation que nous utiliserons, chaque nouvelle instruction est écrite sur une nouvelle ligne.

La machine exécute les instructions les unes après les autres en allant de haut en bas.

Une suite d'instructions qui se suivent est appelée une \emph{\color{purple}séquence}.

Par exemple
\begin{tabular}{|c|}
	\hline
	\begin{minipage}{3cm}
		\LinesNumbered
		\SetKw{entrer}{entrer}
		\SetKw{prend}{$\leftarrow$}
		\SetKw{afficher}{Afficher}
		\begin{algorithm}[H]
			\SetAlgoLined
			\DontPrintSemicolon
			$C$ \prend $3$\;
			$C$ \prend $5+C$\;
			\afficher $C$\;
		\end{algorithm}
	\end{minipage}
	\\
	\hline
\end{tabular}
est une séquence de trois instructions.


\begin{exercice}
	
	\begin{enumerate}
		\item Quels sont les contenus des différentes variables après exécution de l'algorithme ci-dessous quand $n$ contient la valeur $2$ et $m$ la valeur $7$.
		
		\begin{center}
		\begin{tabular}{|c|}
			\hline
			\begin{minipage}{3cm}
				\LinesNumbered
				\SetKw{entrer}{entrer}
				\SetKw{prend}{$\leftarrow$}
				\SetKw{afficher}{afficher}
				\begin{algorithm}[H]
					\SetAlgoLined
					\DontPrintSemicolon
					$x$ \prend $10n+m$\;
					$y$ \prend $100x$\;
					$z$ \prend $100y$\;
					$s$ \prend $x+y+z$\;
				\end{algorithm}
			\end{minipage}
			\\
			\hline
		\end{tabular}
		\end{center}
		
		\item Exécutez l'algorithme pour d'autres valeurs de $m$ et de $n$, entières entre $1$ et $9$. Quelle est la forme du nombre contenu dans $s$ après exécution?
		
	\end{enumerate}
	
\end{exercice}

\begin{exercicecorrection}
	
	\begin{center}
		\begin{tabular}{|m{2cm}|m{1cm}|m{1cm}|m{1cm}|m{1cm}|m{1cm}|m{1cm}|}
			\hline
			Variables & $n$ & $m$ & $x$ & $y$ & $z$ & $s$
			\\
			\hline
		\end{tabular}
	\end{center}
	
\end{exercicecorrection}

\begin{exercice}
	
	\begin{enumerate}
		
		\item Écrivez l'algorithme (langage naturel) correspondant à ce script Python
		
		\begin{center}
		\begin{tabular}{|c|}
			\hline
			\begin{minipage}{1.6cm}
				\begin{lstlisting}{language=Python}
a=n-2
b=a*n
c=b+1
				\end{lstlisting}
			\end{minipage}
			\\
			\hline
		\end{tabular}
		\end{center}
		
		\item Que contient chaque variable après l'exécution des instructions du script si $n=5$? $n=3$? $n=1$? $n=4$?
		
		\item Émettez une conjecture puis démontrez-la.
		
	\end{enumerate}

\end{exercice}

\subsubsection{Les différents types de variables.}

Les variables ne servent pas à mémoriser que des nombres mais différents types d'objets:

\medskip
\noindent	
	\begin{tabular}{|m{2cm}|m{2cm}|m{1.5cm}|m{4.5cm}|}
		\hline
		Types & Exemple & Nom en Python & Explication
		\\
		\hline
		\hline
		Entier & $3$ & \textbf{int} & \textbf{int} pour integer
		\\
		\hline
		Flottant & $5.4$ & \textbf{float} & nombre décimal avec virgule flottante (comme une écriture scientifique)
		\\
		\hline
		Chaîne de caractères & $''LUT''$ & \textbf{str} & \textbf{str} pour string. Souvent des mots ou des phrases.
		\\
		\hline
		Booléen & $5>2-1$ & \textbf{bool} & il s'agit d'une phrase mathématique à laquelle nous pouvons associer soit la valeur vraie ($1$) soit la valeur faux ($0$).
		\\
		\hline
	\end{tabular}

\medskip
Remarques.
\begin{enumerate}
	\item Si le typage des variables existe sur la calculatrice, il est moins explicite que dans Python. Nous n'utiliserons avec la calculatrice quasiment que des variables de type nombre.
\end{enumerate}

\subsection{Blocs d'instructions.}

Les blocs d'instructions sont des séquences d'instructions qui sont séparées du reste du programme soit parce qu'il faut les lire plusieurs fois, soit il ne faut les lire que sous certaines conditions.

\subsubsection{Instruction conditionnelle.}

Il est possible des n'effectuer un bloc d'instruction que si une certaine condition est vérifiée comme, par exemple le monstre qui surgit dans un jeu vidéo si l'avatar s'en est trop approché.

\medskip
\noindent
\begin{tabular}{|m{5.5cm}|m{5.5cm}|}
	\hline
	Scratch
	&
	Algorithme
	\\
	\includegraphics[scale=0.38]{2ieme_calcul_numerique_01_variables_et_instructions_elementaires_03_si_scratch.png}
	&
	\begin{tabular}{|c|}
		\hline
		\begin{minipage}{5cm}
			\LinesNumbered
			\SetKw{entrer}{entrer}
			\SetKw{prend}{$\leftarrow$}
			\SetKw{afficher}{afficher}
			\begin{algorithm}[H]
				\SetAlgoLined
				\DontPrintSemicolon
				\eSi{$distance \leqslant 10$}{
					\afficher "Bouh!"}
					{\afficher "Tout va bien"
				}
			\end{algorithm}
		\end{minipage}
		\\
		\hline
	\end{tabular}
	
	~
	
	\\
	\hline
\end{tabular}

\medskip
\noindent
\begin{tabular}{|m{5.5cm}|m{5.5cm}|}
	\hline
	Python 3
	&
	Ti
	\\
	\begin{tabular}{c}
		\begin{minipage}{2cm}
			\begin{lstlisting}{language=Python}
if distance<= 10:
  print("Bouh!")
else:
  print("Tout va bien")
			\end{lstlisting}
		\end{minipage}
		\\
	\end{tabular}
	&
	\includegraphics[scale=0.6]{2ieme_calcul_numerique_01_variables_et_instructions_elementaires_06_si_ti.png}
	\\
	\hline
\end{tabular}

\begin{exercice}
	
	Considérons l'algorithme ci-dessous
	\begin{center}
	\begin{tabular}{|c|}
		\hline
		\begin{minipage}{5cm}
			\LinesNumbered
			\SetKw{entrer}{entrer}
			\SetKw{prend}{$\leftarrow$}
			\SetKw{afficher}{afficher}
			\begin{algorithm}[H]
				\SetAlgoLined
				\DontPrintSemicolon
				\eSi{$a>b$}{
					\afficher $b$}
				{\afficher $a$
				}
			\end{algorithm}
		\end{minipage}
		\\
		\hline
	\end{tabular}
	\end{center}

	Que retourne cet algorithme si $a=3$ e $b=5$? $a=2$ et $b=0,5$? $a=4$ et $b=4$?
	
\end{exercice}

\subsubsection{Boucle bornée (for).}


Considérons un exemple. On construit un escalier de proche en proche.

\begin{center}
	
	\begin{tikzpicture}[scale=0.5]
		\draw (1,0)--(2,0)--(2,1)--(1,1)--cycle;
		\draw (3,0)--(5,0);
		\draw (3,1)--(5,1);
		\draw (4,2)--(5,2);
		\draw (3,0)--(3,1);
		\draw (4,0)--(4,2);
		\draw (5,0)--(5,2);
		\draw (6,0)--(9,0);
		\draw (6,1)--(9,1);
		\draw (7,2)--(9,2);
		\draw (8,3)--(9,3);
		\draw (6,0)--(6,1);
		\draw (7,0)--(7,2);
		\draw (8,0)--(8,3);
		\draw (9,0)--(9,3);
		\draw (0,-1) node{\small Étape $1$};
		\draw (4,-1) node{\small Étape $2$};
		\draw (8,-1) node{\small Étape $3$};
	\end{tikzpicture}
\end{center}

Nous souhaiterions connaître le nombre de carrés qui forment l'escalier à la vingtième étape. Pour cela nous utilisons un programme dans lequel $nbc$ désigne le nombre de carrés dessinés.

\medskip
\noindent
\begin{tabular}{|m{5.5cm}|m{5.5cm}|}
	\hline
	Scratch
	&
	Algorithme
	\\
	\includegraphics[scale=0.35]{2ieme_calcul_numerique_01_variables_et_instructions_elementaires_04_for_scratch.png}
	&
	\begin{tabular}{|c|}
		\hline
		\begin{minipage}{5cm}
			\LinesNumbered
			\SetKw{entrer}{entrer}
			\SetKw{prend}{$\leftarrow$}
			\SetKw{afficher}{afficher}
			\begin{algorithm}[H]
				\SetAlgoLined
				\DontPrintSemicolon
				$nbc$ \prend $1$\;
				\Pour{$k$ allant de $2$ à $20$}{
					$nbc$ \prend  $nbc$+$k$
					}
			\end{algorithm}
		\end{minipage}
		\\
		\hline
	\end{tabular}
	
	~
	
	\\
	\hline
\end{tabular}

\medskip
\noindent
\begin{tabular}{|m{5.5cm}|m{5.5cm}|}
	\hline
	Python 3
	&
	Ti
	\\
	\begin{tabular}{c}
		\begin{minipage}{2cm}
			\begin{lstlisting}{language=Python}
nbc=1
for k in range(2,20):
	nbc=nbc+k
			\end{lstlisting}
		\end{minipage}
		\\
	\end{tabular}
	&
	\includegraphics[scale=0.6]{2ieme_calcul_numerique_01_variables_et_instructions_elementaires_07_for_ti.png}
	\\
	\hline
\end{tabular}

\begin{exercice}
	
	On considère deux algorithmes suivants.
	
	\noindent 
	\begin{tabular}{m{6cm}m{6cm}}
		Algorithme 1
		&
		Algorithme 2
		\\
		\begin{tabular}{|c|}
			\hline
			\begin{minipage}{5cm}
				\LinesNumbered
				\SetKw{entrer}{entrer}
				\SetKw{prend}{$\leftarrow$}
				\SetKw{afficher}{afficher}
				\begin{algorithm}[H]
					\SetAlgoLined
					\DontPrintSemicolon
					$c$ \prend $0$\;
					\Pour{$k$ allant de $1$ à $6$}{
						$c$ \prend $k$
						}
				\end{algorithm}
			\end{minipage}
			\\
			\hline
		\end{tabular}
		&
		
		\begin{tabular}{|c|}
			\hline
			\begin{minipage}{5cm}
				\LinesNumbered
				\SetKw{entrer}{entrer}
				\SetKw{prend}{$\leftarrow$}
				\SetKw{afficher}{afficher}
				\begin{algorithm}[H]
					\SetAlgoLined
					\DontPrintSemicolon
					$c$ \prend $0$ \;
					\Pour{$k$ allant de $1$ à $6$}{
						$c$ \prend $c+k$
					}
				\end{algorithm}
			\end{minipage}
			\\
			\hline
		\end{tabular}
		\\
	\end{tabular}
	
	Indiquez le contenu de la variable $c$ au fur et à mesure de l'exécution de chacun des algorithmes.
	
\end{exercice}

\begin{exercice}
	
	Quelle sortie obtenez-vous en exécutant le deux scripts suivants?
	
	\noindent 
	\begin{tabular}{m{6cm}m{6cm}}
		Algorithme 1
		&
		Algorithme 2
		\\
		\begin{tabular}{|c|}
			\hline
			\begin{minipage}{4cm}
				\begin{lstlisting}{language=Python}
a=5
for k in range(5):
	a=10*a-8
print(a)
				\end{lstlisting}
			\end{minipage}
			\\
			\hline
		\end{tabular}
		&
		
		\begin{tabular}{|c|}
			\hline
			\begin{minipage}{4cm}
				\begin{lstlisting}{language=Python}
a=5
for k in range(5):
	a=10*a-8
	print(a)
				\end{lstlisting}
			\end{minipage}
			\\
			\hline
		\end{tabular}
		\\
	\end{tabular}
	
\end{exercice}

\subsubsection{Boucle non bornée (while)}

Si, sur un jeu d'échecs, nous déposons un grain de riz sur la première case, puis deux sur la seconde, quatre sur la suivante et ainsi de suite en doublant à chaque fois, sur la quantième cases déposerons-nous plus d'un million de grain sur une case?

Dans cet exemple nous ne savons pas combien de fois il faudra doubler le nombre. Nous utilisons alors une boucle non bornée. 

Notons $case$ la variable comptant le nombre de cases remplies et $riz$ celle comptant le nombre de grain riz déposés dans une case.

\medskip
\noindent
\begin{tabular}{|m{5.5cm}|m{5.5cm}|}
	\hline
	Scratch
	&
	Algorithme
	\\
	\includegraphics[scale=0.35]{2ieme_calcul_numerique_01_variables_et_instructions_elementaires_05_while_scratch.png}
	&
	\begin{tabular}{|c|}
		\hline
		\begin{minipage}{5cm}
			\LinesNumbered
			\SetKw{entrer}{entrer}
			\SetKw{prend}{$\leftarrow$}
			\SetKw{afficher}{Afficher}
			\begin{algorithm}[H]
				\SetAlgoLined
				\DontPrintSemicolon
				$case$ \prend $1$\;
				$riz$ \prend 1\;
				\Tq{$riz \leqslant 1000000$}{
					$riz$ \prend  $2\times riz$\;
					$case$ \prend $case +1$\;
				}
			\afficher $case$\;
			\end{algorithm}
		\end{minipage}
		\\
		\hline
	\end{tabular}
	
	~
	
	\\
	\hline
\end{tabular}

\medskip
\noindent
\begin{tabular}{|m{5.5cm}|m{5.5cm}|}
	\hline
	Python 3
	&
	Ti
	\\
	\begin{tabular}{c}
		\begin{minipage}{2cm}
			\begin{lstlisting}{language=Python}
case=1
riz=1
while riz<=1000000:
	riz=2*riz
	case=case+1
print(case)
			\end{lstlisting}
		\end{minipage}
		\\
	\end{tabular}
	&
	\includegraphics[scale=0.6]{2ieme_calcul_numerique_01_variables_et_instructions_elementaires_08_while_ti.png}
	\\
	\hline
\end{tabular}

\subsection{Python.}

Les opérateurs de calcul Python.

\begin{center}
	
	\begin{tabular}{|m{2cm}|m{6cm}|}
		\hline
		$*$ & multiplication\\
		\hline
		$+$ & addition
		\\
		\hline
		$-$ & soustraction
		\\
		\hline
		$/$ & division décimale
		\\
		\hline
		$//$ & quotient de la division euclidienne
		\\
		\hline
		$\%$ & reste de la division euclidienne
		\\
		\hline
		$**$ & exposant
		\\
		\hline
	\end{tabular}
\end{center}

\medskip
Les opérateurs de comparaison Python.

\begin{center}
	\begin{tabular}{|m{2cm}|m{2cm}|m{4cm}|}
		\hline
		Python & Mathématique & Exemple
		\\
		\hline
		$==$ & $=$ & $1==2$ a la valeur faux
		\\
		\hline
		$!=$ & $\ne$ & $1!=2$ a la valeur vrai
		\\
		\hline
		$<>$ & $\ne$ & $1<>2$ a la valeur vrai
		\\
		\hline
		$>$ & $>$ & $1>2$ a la valeur faux
		\\
		\hline
		$<$ & $<$ & $1<2$ a la valeur vrai
		\\
		\hline
		$>=$ & $\geqslant$ & $1>2$ a la valeur faux
		\\
		\hline
		$<$ & $\leqslant$ & $1<2$ a la valeur vrai
		\\
		\hline
	\end{tabular}
	
\end{center}

\begin{exercice}
	
	On affecte à $n$ un entier naturel.
	
	Reliez chaque instruction de la colonne de gauche à l'expression de la colonne de droite correspondante.
	
	\noindent
	\begin{tabular}{m{5cm}m{5cm}}
		
		\begin{enumerate}
			\item \begin{lstlisting}{language=Python}
n*2
			\end{lstlisting}
			
			\item \begin{lstlisting}{language=Python}
n+1
			\end{lstlisting}
			
			\item \begin{lstlisting}{language=Python}
n%10
			\end{lstlisting}
			
			\item \begin{lstlisting}{language=Python}
n**2
			\end{lstlisting}
			
			\item \begin{lstlisting}{language=Python}
n-1
			\end{lstlisting}
			
			\item \begin{lstlisting}{language=Python}
n//10
			\end{lstlisting}
			
		\end{enumerate}
		
		&
		
		\begin{enumerate}[a.]
			\item Le carré de $n$.
			
			\medskip
			\item L'entier qui précède $n$.
			
			\medskip
			\item Le double de $n$.
			
			\medskip
			\item Le chiffre des unités de $n$.
			
			\medskip
			\item Le nombre de dizaines de $n$.
			
			\medskip
			\item L'entier successeur de $n$.
			
		\end{enumerate}
	\end{tabular}
	
\end{exercice}


\begin{exercice}
	
	Déterminez le type de la variable a dans chacun des cas suivants puis vérifiez votre réponse en utilisant la fonction \textbf{type()}. Par exemple tapez \textbf{type(2)} dans le shell pour le premier.
	
	\noindent
	\begin{tabular}{m{5cm}m{5cm}}
		
		\begin{enumerate}
			\item \begin{lstlisting}{language=Python}
a=2
			\end{lstlisting}
			
			\item \begin{lstlisting}{language=Python}
a=4.5
			\end{lstlisting}
			
			\item \begin{lstlisting}{language=Python}
a=2+3.5
			\end{lstlisting}
			
			\item \begin{lstlisting}{language=Python}
a=51//6
			\end{lstlisting}
			
			\item \begin{lstlisting}{language=Python}
a=2.5+3.5
			\end{lstlisting}
					
		\end{enumerate}
		
		&
		
		
		\begin{enumerate}
			\setcounter{enumi}{5}
			\item \begin{lstlisting}{language=Python}
a=14/2
			\end{lstlisting}
			
			\item \begin{lstlisting}{language=Python}
a="33"
			\end{lstlisting}
			
			\item \begin{lstlisting}{language=Python}
a=33
			\end{lstlisting}
			
			\item \begin{lstlisting}{language=Python}
a=2e10
			\end{lstlisting}
			
			\item \begin{lstlisting}{language=Python}
a=[4,6,12.3]
			\end{lstlisting}
			
		\end{enumerate}
	\end{tabular}
	
\end{exercice}

\subsection{Exercices.}


\begin{exercice}
	
	\begin{enumerate}
		\item Qu'affiche le script Python suivant s'il est exécuté?
		
		\begin{center}
			\begin{tabular}{|c|}
				\hline
				\begin{minipage}{2cm}
					\begin{lstlisting}{language=Python}
a=6
b=3
a=a/b
b=b/a
c=a*b
print(c)
					\end{lstlisting}
				\end{minipage}
				\\
				\hline
			\end{tabular}
		\end{center}
		
		\item Si la valeur initiale de $a$ est $x$ et si celle de $b$ et $y$, exprimez la valeur de $c$ en fonction de $x$ et $y$.
	\end{enumerate}
	
\end{exercice}

\begin{exercicecorrection}
	
	\begin{enumerate}
		\item \objectif{Déterminons ce que retourne le script s'il est exécuté.}
		
		\begin{tabular}{|c|c|c|c|}
			\hline
			Variables & $a$ & $b$ & $c$
			\\
			\hline
			$1$ & $6$ &&
			\\
			\hline
			$2$ & $6$ & $3$ & 
			\\
			\hline
			$3$ & $2$ & $3$ & 
			\\
			\hline
			$4$ & $2$ & $1,5$ &
			\\
			\hline
			$5$ & $2$ & $1,5$ & $3$
			\\
			\hline 
		\end{tabular}
		
		\begin{conclusion}
			
			Le programme affiche $3$.
			
		\end{conclusion}
		
		\item \objectif{Exprimons $c$ en fonction de $x$ et $y$.}
		
		Reprenons le précédent tableau d'état des variables:
		
		\begin{center}
		\begin{tabular}{|c|c|c|c|}
			\hline
			Variables & $a$ & $b$ & $c$
			\\
			\hline
			$1$ & $x$ &&
			\\
			\hline
			$2$ & $x$ & $y$ & 
			\\
			\hline
			$3$ & $\frac{x}{y}$ & $y$ & 
			\\
			\hline
			$4$ & $\frac{x}{y}$ & $\frac{y}{\frac{x}{y}}=\frac{y^2}{x}$ &
			\\
			\hline
			$5$ & $\frac{x}{y}$ & $\frac{y^2}{x}$ & $\frac{x}{y} \cdot \frac{y^2}{x}=y$
			\\
			\hline 
		\end{tabular}
		\end{center}
		
		\begin{conclusion}
			
			Si $a=x$ et $b=y$ alors $c=y$.
			
		\end{conclusion}
		
	\end{enumerate}
\end{exercicecorrection}
\begin{exercice}
	
	Dans un magasin de photocopies les 20 premières photocopies sont facturées à $0,10\ \text{\euro}$ et les suivantes à $0,08\ \text{\euro}$. 
	
	Complétez le programme suivant pour qu'il retourne le prix à payer $p$ pour $n$ photocopies. Puis programmez-le et donnez le prix à payer pour $350$ photocopies.
	
	\begin{center}
		\begin{tabular}{|c|}
			\hline
			\begin{minipage}{4cm}
				\LinesNumbered
				\SetKw{entrer}{entrer}
				\SetKw{prend}{$\leftarrow$}
				\SetKw{afficher}{afficher}
				\begin{algorithm}[H]
					\SetAlgoLined
					\DontPrintSemicolon
					$p$ \prend $0$\;
					\eSi{$n \leqslant 20$}
						{\afficher $\dots$}
						{\afficher $\dots$}
				\end{algorithm}
			\end{minipage}
			\\
			\hline
		\end{tabular}
	\end{center}
	
\end{exercice}

\begin{exercicecorrection}
	\begin{center}
		\begin{tabular}{|c|}
			\hline
			\begin{minipage}{6cm}
				\LinesNumbered
				\SetKw{entrer}{entrer}
				\SetKw{prend}{$\leftarrow$}
				\SetKw{afficher}{afficher}
				\begin{algorithm}[H]
					\SetAlgoLined
					\DontPrintSemicolon
					$p$ \prend $0$\;
					\eSi{$n \leqslant 20$}
					{\afficher $0,10 \times n$}
					{\afficher $0,10 \times 20 + 0,08 \times (p-20)$}
				\end{algorithm}
			\end{minipage}
			\\
			\hline
		\end{tabular}
	\end{center}
	
	\begin{conclusion}
		
		Pour $350$ photocopies il fut payer $28,4\ \text{\euro}$.
		
	\end{conclusion}
	
\end{exercicecorrection}

\begin{exercice}
	
	Dîtes ce que renvoie le programme suivant. 
	
	\begin{center}
	\begin{tabular}{|c|}
		\hline
		\begin{minipage}{6cm}
			\LinesNumbered
			\SetKw{entrer}{Entrer}
			\SetKw{prend}{$\leftarrow$}
			\SetKw{afficher}{Afficher}
			\begin{algorithm}[H]
				\SetAlgoLined
				\DontPrintSemicolon
				$x$ \prend $-3$\;
				\eSi{$x<0$}{
					\afficher $-x$\;
				}{
					\afficher $x$\;
				}
			\end{algorithm}
		\end{minipage}
		\\
		\hline
	\end{tabular}
	\end{center}
	
	Que renvoie ce programme si maintenant $x=2$? $x=-3,14$?
	
\end{exercice}

\begin{exercicecorrection}
	
	
	Le nombre renvoyé par ce programme est appelé \emph{\color{purple}valeur absolue de $x$}, que nous noterons $\color{purple}|x|$.
	
\end{exercicecorrection}

\begin{exercice}
	
	Expliquez le rôle du script Python suivant.
	
	\begin{center}
		\begin{tabular}{|c|}
			\hline
			\begin{minipage}{8cm}
				\begin{lstlisting}{language=Python}
for k in range(11):
	print(8*k)
				\end{lstlisting}
			\end{minipage}
			\\
			\hline
		\end{tabular}
	\end{center}
	
\end{exercice}

\begin{exercicecorrection}
	
	Le script affiche la table de multiplication de $8$.
	
\end{exercicecorrection}

\begin{exercice}
	
	Programmez l'algorithme suivant avec votre calculatrice et exécutez-le. Expliquez.
	
	\begin{center}
		\begin{tabular}{|c|}
			\hline
			\begin{minipage}{6cm}
				\LinesNumbered
				\SetKw{entrer}{Entrer}
				\SetKw{prend}{$\leftarrow$}
				\SetKw{afficher}{Afficher}
				\begin{algorithm}[H]
					\SetAlgoLined
					\DontPrintSemicolon
					$n$ \prend $10$\;
					\Tq{$n<20$}{$n$ \prend $n-1$}
				\end{algorithm}
			\end{minipage}
			\\
			\hline
		\end{tabular}
	\end{center}
	
\end{exercice}

\begin{exercicecorrection}
	
	Le programme ne s'arrête jamais car $n$ n'est jamais plus grand que $20$. Il s'agit d'une boucle infinie. C'est ce qu'on appelle un bug.
	
	Ce bug peut être utilisé sur votre calculatrice pour créer des programmes.
	
\end{exercicecorrection}
\begin{exercice}
	
	Exécutez l'algorithme ci-dessous où $a$ et $b$ sont deux entiers et indique la valeur de $c$ à la sortie quand $a=235$ et $b=13$, quand $a=21$ et $b=43$, quand $a=84$ et $b=7$.
	
	\begin{center}
		\begin{tabular}{|c|}
			\hline
			\begin{minipage}{6cm}
				\LinesNumbered
				\SetKw{entrer}{Entrer}
				\SetKw{prend}{$\leftarrow$}
				\SetKw{afficher}{Afficher}
				\begin{algorithm}[H]
					\SetAlgoLined
					\DontPrintSemicolon
					$k$ \prend $0$\;
					\Tq{$kb \leqslant a$}
						{$k$ \prend $k+1$}
					$c$ \prend $(k-1)b$\;
					\afficher $c$\;
				\end{algorithm}
			\end{minipage}
			\\
			\hline
		\end{tabular}
		
	\end{center}
	
	Que représente $c$ pour $a$ et $b$?
	
\end{exercice}

\begin{exercicecorrection}
	
	$c$ est le plus grand multiple de $b$ inférieur à $a$. Autrement dit la réponse à la question dans $a$ combien de fois puis-je mettre $b$ est $k-1$.
	
\end{exercicecorrection}

\begin{exercice}
	
	En partant de l'algorithme de l'exercice précédent rédigez un algorithme qui renvoie la division euclidienne de $a$ par $b$.
	
\end{exercice}

\begin{exercicecorrection}
	
	\begin{center}
		\begin{tabular}{|c|}
			\hline
			\begin{minipage}{6cm}
				\LinesNumbered
				\SetKw{entrer}{Entrer}
				\SetKw{prend}{$\leftarrow$}
				\SetKw{afficher}{Afficher}
				\begin{algorithm}[H]
					\SetAlgoLined
					\DontPrintSemicolon
					$k$ \prend $0$\;
					\Tq{$kb \leqslant a$}
					{$k$ \prend $k+1$}
					\afficher "Quotient:", $k-1$, "Reste:", $a-(k-1)b$\;
				\end{algorithm}
			\end{minipage}
			\\
			\hline
		\end{tabular}
		
	\end{center}
	
\end{exercicecorrection}

\begin{exercice}
	
	Rappelons que les opérandes $//$ et $\%$ renvoient respectivement le quotient et le reste dans la division euclidienne.
	
	\begin{enumerate}
		\item Dans le programme suivant $a$ et $b$ sont des entiers naturels.
		
		\begin{center}
			\begin{tabular}{|c|}
				\hline
				\begin{minipage}{8cm}
					\begin{lstlisting}{language=Python}
if a%b==0:
	print("oui")
else:
	print("non")
					\end{lstlisting}
				\end{minipage}
				\\
				\hline
			\end{tabular}
		\end{center}
		
		Si l'algorithme renvoie \emph{oui} comment sont appelés $b$ vis-à-vis de $a$ et $a$ vis-à-vis de $b$?
		
		\item Créez et programmez un algorithme en Python qui vérifie si un nombre $n$ est premier.
		
	\end{enumerate}
	
\end{exercice}

\begin{exercice}
	
	La formule de Tanner permet de prévoir la taille d'une personne à l'âge adulte connaissant la taille de ses parents. Pour un garçon, on ajoute à la demi-somme des tailles des deux parents $6,5$. pour une fille on enlève $6,5$ à la demi-somme des tailles des deux parents. Toutes les tailles sont exprimées en centimètres.
	
	Concevez un algorithme qui, à partir de la taille des deux parents, calcule le résultat donné par la formule de Tanner. Puis programmez cet algorithme.

\end{exercice}

\begin{exercice}
	
	Que calcule l'algorithme ci-dessous? Programmez-le et testez-le en choisissant $n=10$ puis $n=100$.
	
	\begin{center}
		\begin{tabular}{|c|}
			\hline
			\begin{minipage}{8cm}
				\begin{lstlisting}{language=Python}
n=4
f=1
for k in range(1,n+1):
	f=f*k
print(f)
				\end{lstlisting}
			\end{minipage}
			\\
			\hline
		\end{tabular}
	\end{center}
	
\end{exercice}

\begin{exercice}
	
	Nous voulons savoir à partir de quelle valeur de l'entier $n$ la somme $S= 1+ \frac{1}{2} + \frac{1}{3} + \dots + \frac{1}{n}$ dépasse $10$.
	
	\begin{enumerate}
		\item Complétez l'algorithme suivant afin que la variable $N$ contienne la valeur cherchée en fin d'algorithme.
		
		\begin{center}
			
			\begin{tabular}{|c|}
				\hline
				\begin{minipage}{6cm}
					\LinesNumbered
					\SetKw{entrer}{Entrer}
					\SetKw{prend}{$\leftarrow$}
					\SetKw{afficher}{Afficher}
					\begin{algorithm}[H]
						\SetAlgoLined
						\DontPrintSemicolon
						$N$ \prend $1$\;
						$S$ \prend $0$\;
						\Tq{$\dots$}
						{S \prend $\dots$\;
						$N$ \prend $N+1$}
					\end{algorithm}
				\end{minipage}
				\\
				\hline
			\end{tabular}
			
		\end{center}
		
		\item Programmez cet algorithme et déduisez-en  la valeur recherchée.
	\end{enumerate} 
	
\end{exercice}

\begin{exercice}
	
	Réalisez un programme en Python qui vérifie si trois nombres forment un triplet pythagoricien.
	
\end{exercice}

\begin{exercice}
	
	Exécutez le programme Python suivant pour différentes valeurs de $a$ puis interprétez-le.
	
	\begin{center}
	\begin{tabular}{|c|}
		\hline
		\begin{minipage}{6cm}
			\begin{lstlisting}{language=Python}
a=12
b=2
while a>1:
	while a%b==0:
		a=a/b
		print(b)
	b=b+1
			\end{lstlisting}
		\end{minipage}
		\\
		\hline
	\end{tabular}
	\end{center}
	
\end{exercice}

\end{document}

\section{Modèles.}

\subsection{Graphique}

	\begin{center}
		\begin{tikzpicture}[xscale=1,yscale=1]
			\def\xY{-0.5};
			\def\yY{-0.5};
			\def\xZ{8.5};
			\def\yZ{7};
			\coordinate (Y) at (\xY,\yY);
			\coordinate (Z) at (\xZ,\yZ);
			\draw[step=0.1cm,line width=0.01cm,gray!30!white] (Y) grid (Z);
			\draw[step=1cm,line width=0.02cm,black!70!white] (Y) grid (Z);
			\draw node[below left,fill=white](0,0){\small $0$};
			\foreach \x in {1, 2}	\draw[thick](\x,0.1cm)--(\x,-0.1cm) node[below,fill=white]{\footnotesize  \pgfmathparse{\x }\pgfmathprintnumber{\pgfmathresult}};
			\foreach \y in {1,2}	\draw[thick](0.1cm,\y)--(-0.1cm,\y) node[left,fill=white]{\footnotesize  \pgfmathparse{\y }\pgfmathprintnumber{\pgfmathresult}};
			\draw[ ->,very thick] (\xY, 0) -- (\xZ, 0) node[right]{$x$};
			\draw[ ->,very thick] (0, \yY) -- (0, \yZ) node[above]{$y$};
			\draw[blue, thick][samples=100,domain=0:7] plot(\x,{(\x +1)^2/exp(\x )});
			\draw[blue] (3,2) node[fill=white] {$\mathcal{C}_B$};
			\fill[color=gray , opacity=0.25] (-0.5, {(-(2/9)*((-0.5)*2)*(2*(-0.5))+(4/3)*(2*(-0.5))+4)/2})
				-- plot [domain=-0.5:2] (\x,{(-(2/9)*(\x*2)*(2*\x)+(4/3)*(2*\x)+4)/2})
				-- (2, {(-(2/9)*(2*2)*(2*2)+(4/3)*(2*2)+4)/2})
				-- (2,0) 
				--(-0.5,0)
				-- cycle;
			\draw[blue, thick] plot[smooth] coordinates {(-3,-1)(-2.5,-0.65)(-2,0)(-1.5,1)(-1,1.5)(-0.5,1.8)(0,2)(0.5,1.89)(1,1.6)(1.5,1.35)(2,1)(2.5,0.55)(3,0)(3.5,-0.9)(4,-1.5)(4.5,-1.82)(5,-2)};
		\end{tikzpicture}
	\end{center}

Pour évaluer la fonction f en a avec tikz: \pgfmathparse{f(a)}\pgfmathresult

Pour affecter la valeur a à la variable \x: \def\x{a}

\subsection{Dessin.}

	\begin{tikzpicture}
		\coordinate (A) at (0,0);
		\coordinate (B) at (5,-1);
		\coordinate (F) at (6,0);
		\coordinate (C) at (7,1);
		\coordinate (D) at (2,2);
		\coordinate (O) at (3.5,0.5);
		\coordinate (S) at (3.5,6);
		\coordinate (J) at (3.5,3.5);
		\coordinate (K) at (3,4.666);
		\draw (A) node {$\bullet$};
		\draw (B)node {$\bullet$};
		\draw (F)node {$\bullet$};
		\draw (C)node {$\bullet$};
		\draw (D)node {$\bullet$};
		\draw (O)node {$\bullet$};
		\draw (S)node {$\bullet$};
		\draw (J)node {$\bullet$};
		\draw (K)node {$\bullet$};
		\draw (A)node[below]{$A$};
		\draw (B)node[below right]{$B$};
		\draw (F)node[right]{$F$};
		\draw (C)node[right]{$C$};
		\draw (D)node[above right]{$D$};
		\draw (O)node[above right]{$O$};
		\draw (S)node[above]{$S$};
		\draw (J)node[above right]{$J$};
		\draw (K)node[below right]{$K$};
		\draw[blue, thick](A)--(B)--(C);
		\draw[blue, thick,dashed](A)--(D)--(C);
		\draw[blue, thick](A)--(S);
		\draw[blue, thick](B)--(S);
		\draw[blue, thick](C)--(S);
		\draw[blue, thick,dashed](D)--(S);
		\draw[blue, thick,dashed](O)--(S);
		\draw[blue, thick](F)--(S);
		\draw[blue, thick,dashed](A)--(C);
		\draw[blue, thick,dashed](D)--(B);
		\draw[blue, thick,dashed](B)--(J)--(C);
		\fill[color=gray , opacity=0.05] (A)--(B)--(C)--(D)--cycle;	
		\fill[color=gray , opacity=0.1] (B)--(C)--(S)--cycle;
		\fill[color=gray , opacity=0.15] (A)--(D)--(C)--(S)--cycle;
		\fill[color=gray , opacity=0.20] (B)--(C)--(J)--cycle;			
	\end{tikzpicture}

\subsection{Arbre.}

	\begin{center}
	\begin{tikzpicture}
		\coordinate (A1) at (3.2,2);
		\coordinate (A2) at (3.2,1.2);
		\coordinate (A3) at (3.2,-0.4);
		\coordinate (A4) at (3.2,-1.2);
		\coordinate (A5) at (3.2,-2);
		\coordinate (A6) at (3.2,-2.8);
		\coordinate (B1) at (1.6,1.7);
		\coordinate (B2) at (1.6,-1.7);
		\coordinate (C1) at (0,0);
		\draw node (A11) at (A1) {$1$};	
		\draw node (A12) at (A2) {$2$};
		\draw node (A13) at (A3) {$1$};
		\draw node (A14) at (A4) {$2$};
		\draw node (A15) at (A5) {$3$};
		\draw node (A16) at (A6) {$4$};
		\draw node (B11) at (B1) {$N$};
		\draw node (B12) at (B2) {$B$};
		\draw node (C11) at (C1) {$\square$};
		\draw (B11)--(A11)node[midway]{\footnotesize\color{blue}$0,5$};
		\draw (B11)--(A12)node[midway]{\footnotesize\color{blue}$0,5$};
		\draw[color=red] (B12)--(A13)node[midway]{\footnotesize\color{blue}$0,25$};
		\draw (B12)--(A14)node[midway]{\footnotesize\color{blue}$0,25$};
		\draw (B12)--(A15)node[midway]{\footnotesize\color{blue}$0,25$};
		\draw (B12)--(A16)node[midway]{\footnotesize\color{blue}$0,25$};
		\draw (C11)--(B11)node[midway]{\footnotesize\color{blue}$\frac{3}{8}$};
		\draw[color=red] (C11)--(B12)node[midway]{\footnotesize\color{blue}$\frac{5}{8}$};
		\node [shading = axis,rectangle, left color=blue, right color=blue!30!white,shading angle=135, anchor=north, minimum width=\paperwidth, minimum height=5.5cm] (box) at (current page.north){};
	\end{tikzpicture}
	\end{center}

\subsection{Tab}
	
	\begin{center}
	\begin{tikzpicture}
		\tkzTabInit[lgt=1.6 , espcl=1.6, deltacl=0.5]{$x$ /0.8, $f'$ /0.8, $f$ /1.6}
		{$-\infty$ ,$1$, $+\infty$}
		\tkzTabLine{,+,d,+,}%
		\tkzTabVar {+/ $\mathrm{e}$, -D+ / $0$ / $+\infty$, - / $\mathrm{e}$ / }
	\end{tikzpicture}
	\end{center}

\subsection{Tab2.}

\begin{tikzpicture}
		\tkzTabInit[lgt=1 , espcl=1.6]{$x$ /0.8, $C_M'$ /0.8, $C_M$ /2.4}
	{$-\infty$ ,$-10$, $0$, $5$, $10$, $40$,  $+\infty$}
		\tkzTabLine{,+,z,-,d,-,t,-,z,+,t,+,}%
		\tkzTabVar {-/$-\infty$, +/$30$,-D+/$-\infty$ /$+\infty$,R/ /,-/$70$, R/ /, +/$+\infty$ }
		\tkzTabVal[draw]{3}{5}{0.5}{}{$75$}
		\tkzTabVal[draw]{5}{7}{0.5}{}{$\np{92,5}$}
		\draw[fill=Red!80,opacity=0.2](M30) rectangle (M63);
		\end{tikzpicture}

\subsection{Python}

\begin{tabular}{|c|}
	\hline
	\begin{minipage}{8cm}
		\begin{lstlisting}{language=Python}
		\textbf{Inititalisation}
		for i=1 to 14:
		print("oups")
		while 1<2:
		a=input()
		test
		\end{lstlisting}
	\end{minipage}
	\\
	\hline
\end{tabular}

\subsection{Pseudocode}

\begin{tabular}{|c|}
	\hline
	\begin{minipage}{8cm}
		\LinesNumbered
		\SetKw{entrer}{entrer}
		\SetKw{prend}{$\leftarrow$}
		\SetKw{afficher}{afficher}
		\begin{algorithm}[H]
			\SetAlgoLined
			\DontPrintSemicolon
			\entrer pi
			0\;
			\Tq{1}{
				2\;
				\eSi{3}{
					4\;
					5\;
					}{
					6\;
					}
				}
				
			\Pour{7}{
				\Si{8}{
					9\;
					}
				}
		\end{algorithm}
	\end{minipage}
	\\
	\hline
\end{tabular}

\subsection{Tabularx}

Pour center dans une seule cellule \hfill avant et après le texte suffisent

\noindent
\begin{tabularx}{\linewidth}{|m{2.5cm}|*{6}{>{\centering\arraybackslash}X|}}
	\hline
	Nombre affiché sur la face & 1 & 2 & 3 & 4 & 5 & 6
	\\
	\hline
\end{tabularx}

\subsection{Tableau sans une case et diagonale.}


	\begin{tabular}{|*{7}{c|}}
		\cline{2-7} \multicolumn{1}{c|}{}& Moyenne & Minimum & Quartile 1 & Médiane &	Quartile 3 & Maximum
		\\
		\hline
		Série $T$ &	\backslashbox{$v_n$}{$u_n$}&	67&	70&	72&	74& 78
		\\
		\hline
		Série $P$ &&&&&& 
		\\
		\hline
	\end{tabular}
	
\subsection{Retrait dans la marge.}

\hspace*{-1cm}

\subsection{Note dans la marge}

\marginpar{\color{red}$\heartsuit$}

\subsection{Notation modulo.}

$3 \equiv 1 \mod{2}$

\subsection{Diapositive.}

%Pour afficher la page en paysage il faut modifier
%\usepackage[a5paper,landscape]{geometry} %ACTIVER POUR A5
%\geometry{hscale=0.9,vscale=0.9,centering} %ACTIVER POUR A5

\pagecolor{cyan!25}

\begin{center}
	
	\begin{tikzpicture}
	\coordinate (AA) at (-9,6.5);
	\node (AA) at (AA) {};
	\coordinate (BB) at (9,6.5);
	\node (BB) at (BB) {};
	\coordinate (CC) at (9,-6.5);
	\node (CC) at (CC) {};
	\coordinate (DD) at (-9,-6.5);
	\node (DD) at (DD) {};
	\draw (AA)--(BB)--(CC)--(DD)--(AA);
	\end{tikzpicture}
	
\end{center}