\documentclass[12pt]{article}
\usepackage[frenchb]{babel}
\usepackage[latin1]{inputenc}
\usepackage{pas-cours,numprint}
\usepackage{amssymb,amsmath}
\usepackage{tabularx}
\usepackage[hmargin=2cm,vmargin=1.5cm]{geometry}
\usepackage[colorlinks=true]{hyperref}
\setlength{\parindent}{0pt}
\makeatletter
\renewcommand*\l@section{\color{blue!50!black}\def\@linkcolor{blue!50!black}\@dottedtocline{1}{1em}{2.3em}}
\def\contentsline#1#2#3#4{%
  \ifx\\#4\\%
    \csname l@#1\endcsname{#2}{#3}%
  \else
      \csname l@#1\endcsname{\hyper@linkstart{link}{#4}{#2}\hyper@linkend}{%
        \hyper@linkstart{link}{#4}{#3}\hyper@linkend
      }%
  \fi
}
\makeatother
\newcommand{\algoline}[1]{\fontfamily{phv}\fontseries{bx}\fontshape{n}\selectfont#1}
\begin{document}
\chap[num=C,pos=right,color=purple]{Initiation à l'algorithmique}{\emph{Stéphane PASQUET, \today}}

\begin{tabularx}{\linewidth}{p{0.5\linewidth}>{\raggedleft\arraybackslash}X}
&
\og \emph{Un langage de programmation est une convention pour donner des ordres à un ordinateur. Ce n?est pas censé être obscur, bizarre et plein de pièges subtils. Ca, ce sont les caractéristiques de la magie.}\fg{}\\ &(Dave Small)
\end{tabularx}

\renewcommand{\contentsname}{\color{purple}Sommaire}

\bigskip

{\color{purple}\hrulefill}
\tableofcontents

{\color{purple}\hrulefill}

\newpage

\env[style=defi,name={Algorithmique},degrade]
{%
Le mot \definmot{algorithme} vient du mathématicien Al-Khwarizmi.\\
Il désigne une succession d'instructions compréhensibles par un programme donné qui permettent au final d'arriver à un résultat.
}

Construire un programme est donc comme expliquer à une personne le chemin qu'elle doit prendre pour aller d'un point A à un point B de sorte qu'elle ne se perde pas. Il faut donc que chaque étape soit simple.

\medskip

L'algorithmique, l'ADN et les \href{http://leocat.free.fr/shadok/index.php}{Shadoks} ont une chose en commun : tout part de quatre termes.

\medskip

\begin{itemize}
\item[$\bullet$] Les Shadoks ont un univers lexical composé des termes \og Ga \fg, \og Bu \fg, \og Zo \fg{} et \og Meu \fg, ce qui ne leur a pas empêcher de prononcer des formules qui valent le détour.
\item[$\bullet$] L'ADN a pour base l'Adénine, la Guanine, la Cytosine et la Thymine, ce qui ne nous a pas empêcher d'exister.
\end{itemize}

\medskip

Vous le voyez, tout est une question d'agencement ...

\bigskip

\env[degrade,style=prop,name={Les instructions de base}]
{%
Un algorithme est composé de quatre types d'instructions :
\medskip
\begin{itemize}
\item[$\bullet$] l'affectation de variables
\item[$\bullet$] la lecture / écriture
\item[$\bullet$] les tests
\item[$\bullet$] les boucles
\end{itemize}
}

\env[degrade,style=defi,name={Les variables}]
{%
Les \definmot{variables} d'un algorithme sont des lettres dans lesquelles seront stockées des informations (numériques ou littérales).
}

\env[degrade,style=ex,name={Les variables},pluriel]
{%
Comme en algèbre, la variable \texttt{a} pourra prendre différentes valeurs numériques comme $-2$, 7, ...\\
La variable \texttt{temp} pourra prendre pour valeur une phrase.
}

On pourra affecter à une variable une valeur dès le début de l'algorithme, plus tard ou bien l'utilisateur pourra informer cette valeur à chaque exécution du programme.

Mais pour utiliser une variable, il faut impérativement la déclarer au début de l'algorithme (afin que celui-ci comprenne que c'est une variable).

\medskip

\env[style=rem,degrade]
{%
Le nom d'une variable ne doit pas comporter de signes de ponctuation ni d'espaces.
}

\env[degrade,style=ex,name={Exemple de déclaration de variables}]
{%
{\color{orange}\algoline{DEBUT\_ALGORITHME}}
\begin{quote}
{\color{blue!50!black}\algoline{VARIABLES :}}
A (entier), B (réel), RES (alphanumérique)
\end{quote}
{\color{orange}\algoline{FIN\_ALGORITHME}}
}

Ici, nous avons spécifié que nous allons utiliser trois variables : la première (appelée \og $A$ \fg) sera de \definmot{type numérique} et sera en plus un nombre entier, la seconde (appelée \og $B$ \fg) sera aussi de type numérique et sera un nombre réel, et une troisième (appelée \og $RES$ \fg) sera du \definmot{type alphanumérique}, c'est-à-dire composée de caractères et de chiffres.

\medskip

\env[degrade,style=defi,name={Les différents types de variables}]
{%
Il existe trois types de variables :
\medskip
\begin{itemize}
\item[$\bullet$] Le \definmot{type numérique} (entier ou réel)
\item[$\bullet$] Le \definmot{type alphanumérique} (une chaîne de caractères)
\item[$\bullet$] Le \definmot{type booléen} (VRAI ou FAUX - TRUE ou FALSE - 1 ou 0)
\end{itemize}
}

\env[degrade,style=ex,name={Exemple d'algorithme simple}]
{%
{\color{orange}\algoline{DEBUT\_ALGORITHME}}
\begin{quote}
{\color{blue!50!black}\algoline{VARIABLES :}}
A (entier), B (entier)\\
{\color{purple}\algoline{LIRE} } A\\
{\color{purple}\algoline{LIRE} } B\\
{\color{purple}\algoline{ECRIRE} }A*B
\end{quote}
{\color{orange}\algoline{FIN\_ALGORITHME}}
}

Cet algorithme demande à l'utilisateur de rentrer deux valeurs entières, puis affiche leur produit.

\medskip

\env[degrade,style=defi,name={Les tests}]
{%
Dans un algorithme, les \definmot{tests} se font sur les variables et se formulent de la façon : 
\begin{quote}
{\algoline{SI}} $<$condition(s)$>$ {\algoline{ALORS}} $<$instruction(s)$>$ {\algoline{SINON}} $<$instruction(s)$>$
\end{quote}
}

\env[degrade,style=ex,name={Exemple d'algorithme simple}]
{%
	{\color{orange}\algoline{DEBUT\_ALGORITHME}}
	\begin{quote}
		{\color{blue!50!black}\algoline{VARIABLES :}}
		A (entier), B (entier)\\
		{\color{purple}\algoline{LIRE} } A\\
		{\color{purple}\algoline{LIRE} } B\\
		{\color{green!50!black}\algoline{SI }} $A>B$ {\color{green!50!black}\algoline{ALORS}}
		\begin{quote}
			{\color{purple}\algoline{ECRIRE} } \og $A$ est plus grand que $B$ \fg
		\end{quote}
		{\color{green!50!black}\algoline{SINON}}
		\begin{quote}
			{\color{purple}\algoline{ECRIRE} } \og $A$ est plus petit que $B$ \fg
		\end{quote}
		{\color{green!50!black}\algoline{FIN DU SI}} 
	\end{quote}
	{\color{orange}\algoline{FIN\_ALGORITHME}}
}

\env[degrade,style=ex,name={Exemple d'algorithme à tests imbriqués}]
{%
	{\color{orange}\algoline{DEBUT\_ALGORITHME}}
	\begin{quote}
		{\color{blue!50!black}\algoline{VARIABLE :}} temp (entier)\\
		{\color{purple}\algoline{ECRIRE} }\og Entrez la température de l'eau : \fg\\
		{\color{purple}\algoline{LIRE} } temp\\
		{\color{green!50!black}\algoline{SI }} temp $\leqslant$ 0 {\color{green!50!black}\algoline{ALORS}}
		\begin{quote}
			{\color{purple}\algoline{ECRIRE} } \og C'est de la glace ! \fg
		\end{quote}
		{\color{green!50!black}\algoline{SINON}}
		\begin{quote}
			{\color{green!50!black}\algoline{SI }} temp $<$ 100 {\color{green!50!black}\algoline{ALORS}}
			\begin{quote}
				{\color{purple}\algoline{ECRIRE} } \og C'est du liquide ! \fg
			\end{quote}
			{\color{green!50!black}\algoline{SINON}}
			\begin{quote}
				{\color{purple}\algoline{ECRIRE} } \og C'est de la vapeur! \fg
			\end{quote}
			{\color{green!50!black}\algoline{FIN DU SI}} 
		\end{quote}
		{\color{green!50!black}\algoline{FIN DU SI}} 
	\end{quote}
{\color{orange}\algoline{FIN\_ALGORITHME}}
}

\bigskip

\env[degrade,style=defi,name={La boucle \og POUR \fg} ]
{%
La boucle s'écrivant : \begin{quote}{\algoline{POUR}} $<$variable$>$ {\algoline{DE}} $<$valeur 1$>$ {\algoline{A}} $<$valeur 2$>$ {{\algoline{FAIRE }}} $<$instruction(s)$>$\end{quote} sert à exécuter une ou plusieurs instructions lorsque la variable prend les valeurs allant de \og valeur 1 \fg{} à \og valeur 2 \fg.
}

\env[degrade,style=ex]
{%
	{\color{orange}\algoline{DEBUT\_ALGORITHME}}
	\begin{quote}
		{\color{blue!50!black}\algoline{VARIABLES :}} somme (entier), n (entier), i (entier)\\
		somme {\color{purple}\algoline{PREND LA VALEUR}} 0\\
		{\color{purple}\algoline{LIRE}} n\\
		{\color{red!50!black}\algoline{POUR}} i {\color{red!50!black}\algoline{DE}} 1 {\color{red!50!black}\algoline{A}} n {\color{red!50!black}\algoline{FAIRE}}
		\begin{quote}
			somme {\color{purple}\algoline{PREND LA VALEUR}} somme+i
		\end{quote}
		{\color{red!50!black}\algoline{FIN DU POUR}}\\
		{\color{purple}\algoline{ECRIRE}} somme
	\end{quote}
	{\color{orange}\algoline{FIN\_ALGORITHME}}
}

Cet algorithme demande à l'utilisateur de saisir une valeur entière $n$, puis calcule la somme des $n$ premiers entiers.

\bigskip

\env[degrade,style=defi,name={La boucle \og TANT QUE \fg} ]
{%
La boucle s'écrivant : \begin{quote}{\algoline{TANT QUE}} $<$condition(s)$>$ {{\algoline{FAIRE }}} $<$instruction(s)$>$\end{quote} sert à exécuter une ou plusieurs instructions tant que les conditions sont vraies.
}

\medskip

\env[degrade,style=ex]
{%
	{\color{orange}\algoline{DEBUT\_ALGORITHME}}
	\begin{quote}
		{\color{blue!50!black}\algoline{VARIABLES :}} somme (entier), n (entier), i (entier)\\
		somme {\color{purple}\algoline{PREND LA VALEUR}} 1\\
		i {\color{purple}\algoline{PREND LA VALEUR}} 2\\
		{\color{purple}\algoline{LIRE}} n\\
		{\color{red!50!black}\algoline{TANT QUE}} $i\leqslant n$ {\algoline{FAIRE}}
		\begin{quote}
			somme {\color{purple}\algoline{PREND LA VALEUR}} somme+i\\
			i {\color{purple}\algoline{PREND LA VALEUR}} i+1
		\end{quote}
		{\color{red!50!black}\algoline{FIN DU TANT QUE}}\\
		{\color{purple}\algoline{ECRIRE}} somme
	\end{quote}
	{\color{orange}\algoline{FIN\_ALGORITHME}}
}

Cet algorithme fait la même chose que le précédent.
\end{document}	