\documentclass[11pt] {article} \usepackage[T1]{fontenc} 
\usepackage[utf8]{inputenc}
\usepackage{amsmath,amssymb,graphicx,multicol,mathrsfs, fancyhdr,enumerate,fourier,eurosym,alterqcm,enumerate,tabularx,variations,numprint,framed}
\usepackage[dvips]{color}
\usepackage[tikz]{bclogo}
\usepackage{pst-plot,pst-tree,pstricks,pst-node,pstricks-add,pst-math,pst-xkey,pst-eucl}
\usepackage[francais]{babel} 
\usepackage{xcolor}
\usepackage{framed}
\usepackage{algorithm}
\usepackage{algpseudocode}

\definecolor{fond}{RGB}{136,136,136}
\definecolor{sicolor}{RGB}{128,0,128}
\definecolor{tantquecolor}{RGB}{221,111,6}
\definecolor{pourcolor}{RGB}{187,136,0}
\definecolor{bloccolor}{RGB}{128,0,0}
\newenvironment{cadrecode}{%
\def\FrameCommand{{\color{fond}\vrule width 5pt}\fcolorbox{fond}{white}}%
\MakeFramed {\hsize \linewidth \advance\hsize-\width \FrameRestore}\begin{footnotesize}}%
{\end{footnotesize}\endMakeFramed}
\makeatletter
\def\therule{\makebox[\algorithmicindent][l]{\hspace*{.5em}\color{fond} \vrule width 1pt height .75\baselineskip depth .25\baselineskip}}%
\newtoks\therules
\therules={}
\def\appendto#1#2{\expandafter#1\expandafter{\the#1#2}}
\def\gobblefirst#1{#1\expandafter\expandafter\expandafter{\expandafter\@gobble\the#1}}%
\def\Ligne{\State\unskip\the\therules}% 
\def\pushindent{\appendto\therules\therule}%
\def\popindent{\gobblefirst\therules}%
\def\printindent{\unskip\the\therules}%
\def\printandpush{\printindent\pushindent}%
\def\popandprint{\popindent\printindent}%
\def\Variables{\Ligne \textcolor{bloccolor}{\textbf{VARIABLES}}}
\def\Si#1{\Ligne \textcolor{sicolor}{\textbf{SI}} #1 \textcolor{sicolor}{\textbf{ALORS}}}%
\def\Sinon{\Ligne \textcolor{sicolor}{\textbf{SINON}}}%
\def\Pour#1#2#3{\Ligne \textcolor{pourcolor}{\textbf{POUR}} #1 \textcolor{pourcolor}{\textbf{ALLANT\_DE}} #2 \textcolor{pourcolor}{\textbf{A}} #3}%
\def\Tantque#1{\Ligne \textcolor{tantquecolor}{\textbf{TANT\_QUE}} #1 \textcolor{tantquecolor}{\textbf{FAIRE}}}%
\algdef{SE}[WHILE]{DebutTantQue}{FinTantQue}
  {\pushindent \printindent  \textcolor{tantquecolor}{\textbf{DEBUT\_TANT\_QUE}}}
  {\printindent \popindent  \textcolor{tantquecolor}{\textbf{FIN\_TANT\_QUE}}}%
\algdef{SE}[FOR]{DebutPour}{FinPour}
  {\pushindent \printindent \textcolor{pourcolor}{\textbf{DEBUT\_POUR}}}
  {\printindent \popindent  \textcolor{pourcolor}{\textbf{FIN\_POUR}}}%
\algdef{SE}[IF]{DebutSi}{FinSi}%
  {\pushindent \printindent \textcolor{sicolor}{\textbf{DEBUT\_SI}}}
  {\printindent \popindent \textcolor{sicolor}{\textbf{FIN\_SI}}}%
\algdef{SE}[IF]{DebutSinon}{FinSinon}
  {\pushindent \printindent \textcolor{sicolor}{\textbf{DEBUT\_SINON}}}
  {\printindent \popindent \textcolor{sicolor}{\textbf{FIN\_SINON}}}%
\algdef{SE}[PROCEDURE]{DebutAlgo}{FinAlgo}
   {\printandpush \textcolor{bloccolor}{\textbf{DEBUT\_ALGORITHME}}}%
   {\popandprint \textcolor{bloccolor}{\textbf{FIN\_ALGORITHME}}}%
\makeatother


\usepackage[colorlinks=true,pdfstartview=FitV,linkcolor=blue,citecolor=blue,urlcolor=blue]{hyperref}
\everymath{\displaystyle}
\textwidth 19cm \textheight 25.5cm \hoffset 
-1,4cm \voffset -3.7cm \oddsidemargin 0pt 
\renewcommand{\thesubsection}{\textcolor{blue}{\Roman{subsection}}} 
\renewcommand{\thesubsubsection}{\textcolor{blue}{\Roman{subsection}}.\textcolor{blue}{\arabic{subsubsection}}} 
\pagestyle{fancy}
% pour le pied de page central
\cfoot{Page \thepage/\pageref{fin}}

%\definecolor{fond}{gray}{0.95}
%\newenvironment{cadrecode}{%
%  \def\FrameCommand{{\color[HTML]{888888}\vrule width 3pt}\colorbox{fond}}%
%  \MakeFramed {\advance\hsize-\width \FrameRestore}}%
%{\endMakeFramed}

%\title{\textbf{\textcolor{red}{Initiation aux algorithmes}}}
%\date{}
%\author{}

\begin{document}

%\maketitle

%\tableofcontents


\begin{center}
\section*{\textcolor{red}{Initiation aux algorithmes}}

\end{center}


\begin{multicols}{2}
\setlength{\columnseprule}{1pt}
\setlength{\columnsep}{2 cm}

\subsection{\textcolor{blue}{Qu'est-ce qu'un algorithme ?}}

Le mot algorithme vient du nom Al Khwarizmi (Abu Ja'far Mohammed Ben Mussa Al-Khwarismi),  né vers 780 dans la région de Khwarezm (aujourd'hui Khiva), au sud de la Mer d'Aral (Ouzbékistan), et mort à Bagdad en 850.\\

\begin{bclogo}[couleur = cyan!20, arrondi = 0.1,logo=\bcbook]{\textcolor{red}{Définition}}
Un algorithme est une suite d'opérations élémentaires, à appliquer dans un ordre déterminé à des données.\\
C'est donc une liste d'instructions élémentaires à suivre. Ces instructions fournissent en un nombre fini d'étapes des résultats.\\

Écrire un algorithme consiste à donner une méthode détaillée décrivant toutes les étapes d'une t‚che à ccomplir.
\end{bclogo}

\bigskip

\textbf{\textcolor{red}{Exemples :}} une notice de montage, une recette de cuisine, un chemin indiqué par un GPS, une division à la main, trier des cartes à jouer, calculer la somme des termes consécutifs d'une suite de nombres, sont des algorithmes.\\

\noindent On peut considérer un algorithme comme une machine fonctionnant en \textbf{trois} étapes :
\begin{enumerate}
	\item les éléments dont on part : les entrées;
	\item les instructions à effectuer sur ces éléments : le traitement;
	\item les résultats obtenus : les sorties.
\end{enumerate}

\textbf{\textcolor{red}{Exercice :}}
On considère le programme de calcul suivant :
\begin{enumerate}[$\bullet$]
	\item Choisir un nombre.
	\item Lui ajouter $1$.
	\item Multiplier le résultat par $2$.
	\item Soustraire $3$ au résultat.
	\item Afficher le résultat.
\end{enumerate}
\begin{enumerate}
	\item Appliquer cet algorithme à $3$; $-4$, $0$ et $\dfrac{1}{3}$.
	\item Identifier les trois étapes de cet algorithme.
\end{enumerate}

\subsection{\textcolor{blue}{Variables et affectation}}
Pour commencer un algorithme, il faut des éléments sur lesquels on souhaite travailler (dans l'exemple précédent, il nous faut un nombre). Ces éléments sont les données d'entrée qui seront utilisées lors des étapes du traitement.\\
\\
\begin{bclogo}[couleur = cyan!20, arrondi = 0.1,logo=\bcbook]{\textcolor{red}{Définition}}
Les données d'entrée sont stockées dans la mémoire de la calculatrice ou de l'ordinateur, à un emplacement appelé \textbf{variable} et repéré par un nom. On peut donc considérer une variable comme une bo\^ite.\\
Le nom de la variable est son \textbf{étiquette}.\\
La variable peut contenir une valeur (un nombre, un mot, une liste de nombres $\cdots$)
\end{bclogo}

\bigskip

Lorsque nous déclarons les variables, nous n'avons fait que réserver un espace dans la mémoire de l'ordinateur ou de la calculatrice.\\
C'est la même chose que lorsqu'un restaurateur marque \og{} RÉSERVÉ\fg{} sur une table de restaurant.\\
Pour autant, la place n'est pas occupée.\\
Occuper cette place, c'est donner une valeur à l'espace mémoire réservé : c'est \textbf{\textcolor{red}{l'affectation}}.\\

\begin{bclogo}[couleur = cyan!20, arrondi = 0.1,logo=\bcbook]{\textcolor{red}{Définition}}
Une \textbf{affectation} est l'attribution d'une valeur à la variable.
\end{bclogo}

\bigskip


Si la variable s'appelle $A$, l'affectation peut s'écrire de différentes manières :
\begin{enumerate}[$\bullet$]
	\item Affecter à $A$ la valeur $3$;
	\item $A$ prend la valeur $3$;
	\item $A \leftarrow 3$ ;
	\item A=3
\end{enumerate}

\textbf{\textcolor{red}{Exemples :}}
\begin{enumerate}
\item 
\fbox{\begin{minipage}{6cm}

\begin{enumerate}[1~:]
\item ENTREES : $x$

\item SORTIES : $y$

\item $b\leftarrow x+1$

\item $c\leftarrow 3b$

\item  $y\leftarrow  c^2$
\end{enumerate}
\end{minipage}}

\begin{enumerate}
\item Si l'entrée est 2, qelle est la sortie donnée par cet algotithme ?

\item Pour une entrée $x$ quelconque, quelle est la sortie ? Quelle est la fonction associée à cet algorithme ?
\end{enumerate}

\item Considérons l'algorithme suivant :\\
	\\
	\begin{tabularx}{\linewidth}{|l|*{2}{>{\centering \arraybackslash}X|}} \hline

	\hline
	Déclaration des variables&$a\ ;\ b\ ;\ c$\\ \hline
	\multicolumn{2}{|l|}{Début de l'algorithme}\\ \hline
	Affectation&On affecte à $a$ la valeur 3\\ \hline
	Affectation&On affecte à $a$ la valeur $a^2-2a+1$\\ \hline
	Affectation&On affecte à $b$ la valeur 7\\ \hline
	Affectation&On affecte à $b$ la valeur $b^2-4b+4$\\ \hline
	Affectation&On affecte à $c$ la valeur $a+b-9$\\ \hline
	Instruction de sortie&Afficher $c$\\ \hline
	\multicolumn{2}{|l|}{Fin de l'algorithme}\\ \hline
	\end{tabularx}
	\end{enumerate}
	
	
\bigskip

\begin{enumerate}
	\item Compléter le tableau suivant :\\
	\begin{tabular}{|c|c|c|c|}\hline
	&Valeur de $a$&Valeur de $b$&Valeur de $c$\\ \hline
	
Étape 1&&&\\ \hline
	
Étape 2&&&\\ \hline
	
Étape 3&&&\\ \hline
	
Étape 4&&&\\ \hline
	
Étape 5&&&\\ \hline
	\end{tabular}

%	\item Programmer l'algorithme sur Algobox puis sur calculatrice et vérifier les résultats.\\


%\begin{minipage}{8cm}
%	Programme sous Algobox\\
%\begin{small}
%\begin{verbatim}
%1   VARIABLES
%2     A EST_DU_TYPE NOMBRE
%3     B EST_DU_TYPE NOMBRE
%4     C EST_DU_TYPE NOMBRE
%5   DEBUT_ALGORITHME
%6     A PREND_LA_VALEUR 3
%7     A PREND_LA_VALEUR A*A-2*A+1
%8     B PREND_LA_VALEUR 7
%9     B PREND_LA_VALEUR B*B-4*B+4
%10    C PREND_LA_VALEUR A+B-9
%11    AFFICHER "A="
%12    AFFICHER A
%13    AFFICHER "B="
%14    AFFICHER B
%15    AFFICHER "C="
%16    AFFICHER C
%17  FIN_ALGORITHME
%\end{verbatim}
%\end{small}
%\end{minipage}
%\begin{minipage}{8cm}
%Programme sous TI\\
%\\

%\begin{tabular}{l}
%PROGRAM:ALGO1\\
%:$3\rightarrow$A\\
%:$A*A-2A+1\rightarrow A$\\
%:$7\rightarrow B$\\
%:$B*B-4B+4\rightarrow B$\\
%:$A+B-9\rightarrow C$\\
%:DISP "A=",A\\
%:DISP "B=",B\\
%:DISP "C=,C\\
%\end{tabular}
%\vspace*{3cm}
%\end{minipage}
%\end{enumerate}


	\item Que permet de déterminer cet algorithme programmé avec le logiciel Algobox ?\\
%\begin{small}
%\begin{verbatim}
%1   VARIABLES
%2     A EST_DU_TYPE NOMBRE
%3     B EST_DU_TYPE NOMBRE
%4     C EST_DU_TYPE NOMBRE
%5     D EST_DU_TYPE NOMBRE
%6   DEBUT_ALGORITHME
%7     LIRE A
%8     LIRE B
%9     LIRE C
%10    D PREND_LA_VALEUR (A+B+C)/3
%11    AFFICHER D
%12  FIN_ALGORITHME
%\end{verbatim}

\begin{algorithmic}[1]
\fontfamily{phv}\selectfont
\begin{cadrecode}
\Variables
\Ligne A EST\_DU\_TYPE NOMBRE
\Ligne B EST\_DU\_TYPE NOMBRE
\Ligne C EST\_DU\_TYPE NOMBRE
\Ligne D EST\_DU\_TYPE NOMBRE
\DebutAlgo
\Ligne LIRE A
\Ligne LIRE B
\Ligne LIRE C
\Ligne D PREND\_LA\_VALEUR (A+B+C)/3
\Ligne AFFICHER D
\FinAlgo
\end{cadrecode}
\end{algorithmic}


	\item Considérons l'algorithme suivant :\\
	\begin{center}
	\fbox{\begin{minipage}{10cm}
	VARIABLES\\
	A, B, C nombres réels\\
	DEBUT ALGORITHME\\
	Saisir un nombre  A\\
	Saisir un nombre  B\\
On affecte à C la valeur $\sqrt{A^2+B^2}$\\
	Afficher C\\
	FIN ALGORITHME
	\end{minipage}}	
	\end{center}
\begin{enumerate}
	\item Programmer cet algorithme sur Algobox ou sur calculatrice.
	
\bigskip

	Sur Algobox : on obtient : 
	\begin{algorithmic}[1]
\fontfamily{phv}\selectfont
\begin{cadrecode}
\Variables
\Ligne A EST\_DU\_TYPE NOMBRE
\Ligne B EST\_DU\_TYPE NOMBRE
\Ligne C EST\_DU\_TYPE NOMBRE
\DebutAlgo
\Ligne LIRE A
\Ligne LIRE B
\Ligne C PREND\_LA\_VALEUR sqrt(pow(A,2)+pow(B,2))
\Ligne AFFICHER "C="
\Ligne AFFICHER C
\FinAlgo
\end{cadrecode}
\end{algorithmic}

	\item Compléter le tableau ci-dessous :\\
	\\
	\begin{tabular}{|c|c|c|}\hline
	Valeur de $A$&3&6\\ \hline
	Valeur de $B$&4&8\\ \hline
	Valeur de $C$&&\\ \hline
	\end{tabular}
	\item Que permet de faire cet algorithme ?
\end{enumerate}
\end{enumerate}


\subsection*{\textcolor{red}{Exercice}}
Écrire un algorithme permettant de calculer les coordonnées du milieu d'un segment.

\subsection*{\textcolor{red}{Exercice}}
Écrire un algorithme permettant de calculer la longueur d'un segment [AB], à partir des coordonnées de A et de B.

%	Les nombres $a$, $b$, $c$ seront donnés pour chaque calcul.\\
%	Faire le test avec $a=1$, $b=2$, $c=3$ et $x=1$.
%\end{enumerate}


%\section{Les touches de la calculatrice}
%\begin{center}
%\renewcommand{\arraystretch}{2}
%	\begin{tabular}{|c|c|}\hline
%	Commande&T.I.\\ \hline
%	Aller dans l'éditeur de programme&\tc{PRGM}\\ \hline
%	Créer un nouveau programme COUCOU&\begin{tabular}{c}NEW 1:Create New \tc{ENTER}\\ NAME$=$ COUCOU\\ \end{tabular}\\ \hline
%	Une ligne de programme&commence par : \\ \hline
%	\begin{tabular}{l} Pour faire saisir une entrée\\ Pour afficher une sortie (un résultat) \end{tabular}&
%	\begin{tabular}{l} \tc{PRGM} I/O 1:Input ou Prompt\\ \tc{PRGM} I/O 2:Disp\end{tabular}\\ \hline
%	Guillemets&\tc{ALPHA}\tc{+} pour obtenir \tc{"}\\ \hline
%	Séparateur de commande&\tc{ALPHA}\tc{\blacksquare} pour obtenir \tc{:}\\ \hline
%	Stocker, mettre en mémoire&\tc{STO} qui s'affiche $->$ à l'écran\\ \hline
%	\begin{tabular}{l}For, If, Then, Else,End, Pause, While\\ Faire varier $k$ de $1$ à $5$ \end{tabular}&
%	\begin{tabular}{l}\tc{PRGM} CTL\\ For($K$\ ,$1$\ ,$5$) \end{tabular}\\ \hline
%	Lbl, Goto&\tc{PRGM} CTL\\ \hline
%	Test : $=$, $<$, $>$, $\neq$\ldots&\tc{2nd}\tc{MATH} pour obtenir \tc{TEST}\\ \hline
%	Effacer la liste 1&\tc{STAT} 4:ClrList \tc{ENTER}\tc{2nd}\tc{1}\\ \hline
%	Exécuter un programme&\tc{PRGM} EXEC\\ \hline
%	Modifier un programme&\tc{PRGM} EDIT\\ \hline
%	\end{tabular}
%	\end{center}





%\section{\textcolor{blue}{Les instructions conditionnelles}}
%On souhaite écrire un algorithme testant si un triangle est rectangle ou non en $A$.\\
%Pour cela, il faut calculer $\displaystyle BC^2$ d'une part et $\displaystyle AB^2+AC^2$ d'autre part, puis comparer les deux valeurs. Cela fait intervenir un test, aussi appelé instruction conditionnelle.\\
%
%\fbox{\begin{minipage}{1\textwidth} La résolution de certains problèmes nécessite la mise en place d'un test pour effectuer une t‚che :
%\begin{itemize}
%	\item si le test est positif, on effectue la t‚che;
%	\item sinon, c'est-à-dire si le test est négatif, on effectue une autre t‚che.
%\end{itemize}
%On parle d'\textbf{\textcolor{red}{instruction conditionnelle}} (ou test ou structure alternative).\\
%En algorithmique, cette instruction conditionnelle se rédige ainsi :
%\begin{center}
%\begin{tabular}{|l|}
%\hline
%\textbf{Si} \textit{condition} \\
%\qquad \begin{tabular}{|l} 
%				\textbf{alors} \textit{traitement 1}\\
%				\textbf{sinon} \textit{traitement 2}\\
%				\end{tabular}\\
%\textbf{FinSi}\\ \hline
%\end{tabular}
%\end{center}
%\end{minipage}}\\
%
%\textbf{Exemples} :
%\begin{enumerate}[1)]
%	\item On considère l'algorithme suivant :\\
%	\\
%	\begin{tabular}{|l|}\hline
%	Variables\\
%	\qquad \begin{tabular}{|l}
%					$x$ du type nombre\\
%					$y$ du type nombre\\
%					\end{tabular}\\ \hline
%	Entrée\\
%	\qquad \begin{tabular}{|l}
%					demander un nombre $x$\\
%					\end{tabular}\\ \hline
%	Traitement\\
%  \qquad \begin{tabular}{|l}
%  				Si $x<0$ \\
%					\qquad \begin{tabular}{|l}
%									Alors affecter à $y$ le nombre $\dfrac{1}{x}$\\
%									Sinon affecter à $y$ le nombre $\displaystyle \sqrt{x}$\\
%									\end{tabular}\\
%					FinSi\\ 
%					\end{tabular}\\ \hline
%	Afficher $y$\\ \hline
%	\end{tabular}\\
%\begin{enumerate}[a)]
%	\item Tester cet algorithme pour $x=1\ ;\ -2\ ;\ 4\ ;\ -1\ ;\ 0$.
%	\item \'Ecrire la fonction obtenue sur $\mathbb{R}$.
%\end{enumerate}
%	\item \textbf{\textcolor{red}{Suite de Syracuse}} : \\
%	On définit la suite $\left(u_{n}\right)$ ainsi : on choisit $u_{0}$ et $u_{n+1}=\dfrac{1}{2}u_{n}$ si $u_{n}$ est pair, $u_{n+1}=3u_{n}+1$ si $u_{n}$ est impair.\\
%	
%Écrire l'algorithme correspondant.\\
%	Avec Algobox :
%	\begin{algorithmic}[1]
%\fontfamily{phv}\selectfont
%\begin{cadrecode}
%\Variables
%\Ligne a EST\_DU\_TYPE NOMBRE
%\Ligne b EST\_DU\_TYPE NOMBRE
%\DebutAlgo
%\Ligne LIRE a
%\Si{(a\%2==0)}
%\DebutSi
%\Ligne b PREND\_LA\_VALEUR a/2
%\FinSi
%\Sinon
%\DebutSinon
%\Ligne b PREND\_LA\_VALEUR 3*a+1
%\FinSinon
%\Ligne AFFICHER "b="
%\Ligne AFFICHER b
%\FinAlgo
%\end{cadrecode}
%\end{algorithmic}
%
%\textbf{Remarque : } cet algorithme ne permet que de calculer un terme de la suite, en fonction du terme précédent.\\
%On aimerait pouvoir calculer un nombre déteriné de termes, par exemple les cent premiers termes.\\
%Pour cela, il faut répéter le programme ; c'est ce qu'on va voir dans le paragraphe suivant.
%\end{enumerate}
%
%\section{\textcolor{blue}{La boucle itérative}}
%\textbf{\textcolor{red}{Exemples :}}
%
%\begin{enumerate}
%\item On souhaite calculer le nombre $\displaystyle 2^{10}$. Pour cela, on considère le nombre $2$ puis on le multiplie par $2$. On multiplie ensuite le résultat obtenu par $2$ et ainsi de suite. On répète donc $9$ fois l'opération : multiplier par $2$. Répéter plusieurs fois de duite une m\^eme t‚che s'appelle en algorithme \textbf{exécuter une boucle (à compteur)}.\\
%\\
%\fbox{\begin{minipage}{1\textwidth} La boucle à compteur consiste à répéter une t‚che fixe $n$ fois, $n$ étant fixé à l'avance.\\
%On la rédige de la manière suivante :
%\begin{center}
%\begin{tabular}{|l|}\hline 
%Pour $i$ allant de $$1 à $n$\\
%\qquad \begin{tabular}{|l}
%				Traitement\\
%				\end{tabular}\\
%Fin boucle pour\\ \hline
%\end{tabular}
%\end{center}
%\end{minipage}}
%
%\item Calcul des cent premiers termes de la suite de Syracuse :
%\begin{algorithmic}[1]
%\fontfamily{phv}\selectfont
%\begin{cadrecode}
%\Variables
%\Ligne a EST\_DU\_TYPE NOMBRE
%\Ligne i EST\_DU\_TYPE NOMBRE
%\DebutAlgo
%\Ligne LIRE a
%\Pour{i}{1}{100}
%\DebutPour
%\Si{(a\%2==0)}
%\DebutSi
%\Ligne a PREND\_LA\_VALEUR a/2
%\FinSi
%\Sinon
%\DebutSinon
%\Ligne a PREND\_LA\_VALEUR 3*a+1
%\FinSinon
%\Ligne AFFICHER "a="
%\Ligne AFFICHER a
%\FinPour
%\FinAlgo
%\end{cadrecode}
%\end{algorithmic}
%
%\end{enumerate}
%
%
%
%\item 
%	 On considère l'algorithme suivant :\\
%	\\
%	\begin{tabular}{|l|}\hline
%	Variables\\
%	\qquad \begin{tabular}{|l}
%					$N$ du type nombre\\
%					$S$ du type nombre\\
%					$i$ du type nombre\\
%					\end{tabular}\\ \hline
%	Entrée\\
%	\qquad \begin{tabular}{|l}
%					Saisir $N$\\
%					$0\leftarrow S$\\
%					\end{tabular}\\ \hline
%	Traitement\\
%  \qquad \begin{tabular}{|l}
%  				Pour $i$ allant de $1$ jusqu'à $N$ faire\\
%					\qquad \begin{tabular}{|l}
%									$S+\dfrac{1}{i(i+1)}\leftarrow S$\\
%									\end{tabular}\\
%					FinPour\\ 
%					\end{tabular}\\ \hline
%	Afficher $S$\\ \hline
%	\end{tabular}
%\begin{enumerate}
%	\item Compléter le tableau ci-dessous en prenant comme valeur initiale de $N$ : $N=5$.
%	\begin{center}
%	\renewcommand{\arraystretch}{2}
%	\begin{tabular}{|c|p{5cm}|p{5cm}|}\hline
%	Numéro de passage dans la boucle&Valeur de $S$ avant le passage dans la boucle&Valeur de $S$ après le passage dans la boucle\\ \hline
%	1&&\\ \hline
%	2&&\\ \hline
%	3&&\\ \hline
%	4&&\\ \hline
%	5&&\\ \hline
%	\end{tabular}
%	\end{center}
%	\item \`A quoi sert cet algorithme ?
%
%
%\end{enumerate}
%%	\item Considérons à présent l'algorithme suivant :\\
%%	\\
%%	\begin{tabular}{|l|}\hline
%%	Variables\\
%%	\qquad \begin{tabular}{|l}
%%					$N$ du type nombre\\
%%					$A$ du type nombre\\
%%					$B$ du type nombre\\
%%					\end{tabular}\\ \hline
%%	Entrée\\
%%	\qquad \begin{tabular}{|l}
%%					Saisir $N$\\
%%					$2\rightarrow A$\\
%%					$1\rightarrow B$\\
%%					\end{tabular}\\ \hline
%%	Traitement\\
%%  \qquad \begin{tabular}{|l}
%%  				Pour $i$ allant de $0$ jusqu'à $N$ faire\\
%%					\qquad \begin{tabular}{|l}
%%									$B+A\rightarrow B$\\
%%									\end{tabular}\\
%%					FinPour\\ 
%%					\end{tabular}\\ \hline
%%	Afficher $B$\\ \hline
%%	\end{tabular}
%%\begin{enumerate}
%%	\item Utilisez cet algorithme pour compléter le tableau suivant :
%%	\begin{center}
%%	\renewcommand{\arraystretch}{2}
%%	\begin{tabular}{|c|p{2cm}|p{2cm}|p{2cm}|p{2cm}|p{2cm}|p{2cm}|}\hline
%%	$N$&0&1&2&3&4&5\\ \hline
%%	$B$&3&&&&&\\ \hline
%%	\end{tabular}
%%	\end{center}
%%	\item Placez les points de coordonnées $(N\ ;\ B)$. Que constatez-vous?
%%	\item Donnez une expression de la fonction $f$ qui, au nombre $N$ saisi, associe le nombre $B$ en sortie.
%%\end{enumerate}
%%	\item Complétez l'algorithme suivant pour qu'il affiche la table de multiplication (de $0$ à $12$) d'un nombre entier naturel $N$ saisi par l'ordinateur :\\
%%		\\
%%	\begin{tabular}{|l|}\hline
%%	Variables\\
%%	\qquad \begin{tabular}{|l}
%%					$N$ du type nombre\\
%%					$i$ du type nombre\\
%%					$R$ du type nombre\\
%%					\end{tabular}\\ \hline
%%	Entrée\\
%%	\qquad \begin{tabular}{|l}
%%					Saisir $N$\\
%%					\end{tabular}\\ \hline
%%	Traitement\\
%%  \qquad \begin{tabular}{|l}
%%  				Pour $i$ allant de $0$ jusqu'à $\ldots\ldots$ faire\\
%%					\qquad \begin{tabular}{|l}
%%									$\ldots\ldots\ldots\rightarrow R$\\
%%									Afficher $\ldots\ldots$ \og $\times$\fg $\ldots\ldots$\og$=$\fg$\ldots\ldots$\\
%%									\end{tabular}\\
%%					FinPour\\ 
%%					\end{tabular}\\ \hline
%%	\end{tabular}
%%\end{enumerate}
%
%\section{\textcolor{blue}{La boucle conditionnelle}}
%Les boucles vues  précédemment sont très pratiques pour répéter des instructions à condition de savoir le nombre de répétitions nécessaires.\\
%Or ce n'est pas toujours le cas : il est alors possible d'avoir recours à la structure TANT QUE\dots qui permet de répéter une série d'instructions (comprises entre DEBUT TANT QUE et FIN TANT QUE) tant qu'une certaine condition est vérifiée :\\
%
%\textbf{\textcolor{red}{Exemple 1 :}}\\
%Un individu a emprunté à un ami une somme de \numprint{2500} euros (prêt sans intérêts).\\
%Pour rembourser son ami, il prévoit de lui remettre 110 euros par mois. Mais comme cela ne correspond pas à un nombre pile de mois, il se demande quel sera le montant à rembourser le dernier mois.\\
%En utilisant la variable montant pour représenter le montant qu'il reste à rembourser, le problème peut se résoudre avec l'algorithme suivant :\\
%\begin{algorithmic}[1]
%\fontfamily{phv}\selectfont
%\begin{cadrecode}
%\Variables
%\Ligne montant EST\_DU\_TYPE NOMBRE
%\DebutAlgo
%\Ligne montant PREND\_LA\_VALEUR 2500
%\Tantque{(montant>=110)}
%\DebutTantQue
%\Ligne montant PREND\_LA\_VALEUR montant-110
%\FinTantQue
%\Ligne AFFICHER montant
%\FinAlgo
%\end{cadrecode}
%\end{algorithmic}
%
%\textbf{\textcolor{red}{Exemple 2}}\\
%On cherche à connaÓtre le plus petit entier $N$ tel que $2^{N}$ soit supérieur ou égal à \numprint{10000}.\\
%Pour résoudre ce problème de faÁon algorithmique, l'idée est de calculer les puissances consécutives de 2 jusqu'à ce qu'on atteigne \numprint{10000}.\\
%Une structure TANT QUE est particulièrement adaptée à ce genre de problème car on ne sait pas a priori combien de calculs seront nécessaires.\\
%En utilisant la variable N, le problème peut se résoudre avec l'algorithme suivant (réalisé avec Algobox) .\\
%
%
%\begin{algorithmic}[1]
%\fontfamily{phv}\selectfont
%\begin{cadrecode}
%\Variables
%\Ligne N EST\_DU\_TYPE NOMBRE
%\DebutAlgo
%\Ligne N PREND\_LA\_VALEUR 1
%\Tantque{(pow(2,N)<10000)}
%\DebutTantQue
%\Ligne N PREND\_LA\_VALEUR N+1
%\FinTantQue
%\Ligne AFFICHER N
%\FinAlgo
%\end{cadrecode}
%\end{algorithmic}
%
%\textbf{\textcolor{red}{Exemple 3 :}}\\
%On constate expérimentalement que la suite de Syracuse se termine toujours par le cycle 1 - 4 - 2 pour tous les nombres testés comme premier terme de la suite.\\
%On appelle temps de vol le nombre d'étapes pour trouver un terme de la suite égal à 1, donc le rang du premier terme de la suite égal à 1.\\
%Algorithme possible :
%
%\begin{algorithmic}[1]
%\fontfamily{phv}\selectfont
%\begin{cadrecode}
%\Variables
%\Ligne n EST\_DU\_TYPE NOMBRE
%\Ligne u\_n EST\_DU\_TYPE NOMBRE
%\Ligne u\_n\_temp EST\_DU\_TYPE NOMBRE
%\DebutAlgo
%\Ligne AFFICHER "Entrer un entier naturel : "
%\Ligne LIRE u\_n
%\Ligne AFFICHER "u\_n="
%\Ligne AFFICHER u\_n
%\Ligne n PREND\_LA\_VALEUR 0
%\Tantque{(u\_n!=1)}
%\DebutTantQue
%\Si{(u\_n\%2==0)}
%\DebutSi
%\Ligne u\_n\_temp PREND\_LA\_VALEUR u\_n/2
%\FinSi
%\Si{(u\_n\%2==1)}
%\DebutSi
%\Ligne u\_n\_temp PREND\_LA\_VALEUR 3*u\_n+1
%\FinSi
%\Ligne u\_n PREND\_LA\_VALEUR u\_n\_temp
%\Ligne AFFICHER "u\_n="
%\Ligne AFFICHER u\_n
%\Ligne n PREND\_LA\_VALEUR n+1
%\FinTantQue
%\end{cadrecode}
%\end{algorithmic}

\end{multicols}

\label{fin}
\end{document}  