\documentclass[10pt,a4paper]{article}
%\usepackage{hyperref}
\usepackage[cp1252]{inputenc}
\usepackage[LGR,T1]{fontenc}
\usepackage{lmodern}
\usepackage[hmargin=1.5cm,vmargin=2cm,dvips]{geometry}
\usepackage{graphicx}
\usepackage{pstricks,pst-plot,pstricks-add} 
\usepackage{pst-eucl}
\usepackage[fleqn]{amsmath}
\usepackage{amssymb}
\usepackage{fancyhdr}
\usepackage{fancybox}
\usepackage{multicol}
\usepackage{xcolor}
\usepackage{epsfig}
\usepackage{pifont}
\usepackage[framed]{ntheorem}
\usepackage[greek,frenchb]{babel}
\usepackage{tabularx}
\usepackage{array}
%\usepackage{longtable}
%\usepackage{colortab}
%\usepackage{colortbl}
%\usepackage{arydshln}

\lhead[]{\small 2^{nde} ISI}
\chead[]{\textsc{Introduction à l'algorithmique}}
\rhead[]{\small {Algofiche n°1}}
\lfoot{\small \url{http://mathematiques.daval.free.fr}}
\rfoot{\small -\thepage-}
\cfoot{}

%\def\R{{\mathbb R}}
%\def\Q{{\mathbb Q}}
%\def\Z{{\mathbb Z}}
%\def\D{{\mathbb D}}
%\def\N{{\mathbb N}}
%\def\C{{\mathbb C}}

\pagestyle{fancy}

%\theoremstyle{break}
%\theorembodyfont{\upshape}
%\newframedtheorem{Prop}{Propriété}
%\newtheorem{Rem}{Remarque}
%\theorembodyfont{\rmfamily}
%\newtheorem{Exo}{Exercice \no{}}
%\theoremstyle{nonumberbreak}
%\newframedtheorem{Cs}{Ce qu'il faut ABSOLUMENT savoir faire}
%\theorembodyfont{\small \sffamily}
%\newtheorem{Ex}{Exemple}
%\theorembodyfont{\slshape}
%\newframedtheorem{Def}{Définition}

\renewcommand\thesection{\Roman{section}}
\renewcommand\FrenchLabelItem{\textbullet}
\newcommand{\V}{\overrightarrow}
\newcommand{\Rep}{(O;\V{\imath};\V{\jmath})}
%\newcommand{\Ouv}{(O;\V{u};\V{v})}
%\newcommand{\Int}[2]{[\, #1 ; #2 \,]}
%\newcommand{\Reel}{\mathfrak{Re}} 
%\newcommand{\Ima}{\mathfrak{Im}} 
%\renewcommand{\Abs}[1]{\left \lvert#1\right \rvert}
\newcommand{\Coor}[2]{\begin{pmatrix} #1\\#2 \end{pmatrix}}
%\newcommand{\Syst}[2]{\left\{\begin{array}{ccccc} #1\\ #2 \end{array}\right.}
%\newcolumntype{C}[1]{>{\centering\arraybackslash}p{#1cm}}
\renewcommand{\arraystretch}{1.2} 



\begin{document}
%\fontsize{9pt}{11pt}\selectfont

\setlength{\parskip}{3ex plus 1ex minus 1ex}
\setlength{\parindent}{0cm} 
%\baselineskip 13pt
%................................................................

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\section{Qu'est-ce qu'un algorithme ?}

Un algorithme est une suite d'instructions, qui une fois exécutée correctement, conduit à un résultat donné.


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\subsection{Les algorithmes dans la vie courante}

Les manuels d'utilisation actuels sont essentiellement des recueils d'algorithmes : des instructions sont données afin de faire fonctionner telle ou telle fonction. \\
Les exemples de la vie courante ne manquent pas.

Examinons plus particulièrement des algorithmes plus anciens : les recettes de cuisine. \\
Une recette de cuisine comporte trois étapes : 
\begin{enumerate}
   \item Réunir les ingrédients
   \item Préparer
   \item Déguster
\end{enumerate}

La préparation consiste à exécuter une suite d'instructions : par exemple, plonger les tomates dans une casserole d'eau bouillante pendant quelques instants avant de les peler.
On ne sait pas pourquoi il faut procéder de la sorte et d'ailleurs, ça n'a aucune importance : la recette a
été écrite par quelqu'un qui sait. Elle marche.

En comparant avec les algorithmes de mathématiques, on pourrait dire que les ingrédients de la recette sont les \textbf{entrées} du processus auxquelles on applique l'algorithme (la \textbf{préparation})
pour obtenir, en \textbf{sortie}, un plat que l'on dégustera avec plaisir (ou pas !)


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\subsection{Construction d'un algorithme}

Un algorithme se présente en général sous la forme suivante : 

\textbf{Déclaration des variables :} \\
   \hspace*{0.5cm} on décrit dans le détail les éléments que l'on va utiliser dans l'algorithme, \\
\textbf{Initialisation ou Entrée des données :} \\
   \hspace*{0.5cm} on récupère les données et/ou on les initialise, \\
\textbf{Traitement des données :} \\
   \hspace*{0.5cm}  on effectue les opérations nécessaires pour répondre au problème posé, \\
\textbf{Sortie :} \\
   \hspace*{0.5cm} on affiche le résultat.


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\subsection{Outils pour la seconde}

Il existe une quantité de langages de programmation et de logiciels permettant de définir des algorithmes. \\
Cette année, nous serons amenés à utiliser les outils suivants :

\setlength{\parindent}{0.7cm} 
\begin{itemize}
   \item Utilisation du LANGAGE NATUREL,
   \item Utilisation de la fonction de programmation de la CALCULATRICE,
   \item Utilisation d'un logiciel informatique : ALGOBOX,
   \item Utilisation d'un langage de programmation : PYTHON.
\end{itemize}
\setlength{\parindent}{0cm} 

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\section{Un premier exemple}

Le but de ce premier TP sur l'algorithmique consiste déterminer la distance entre deux points connaissant leurs coordonnées dans un repère orthonormé :

\shadowbox{
\begin{minipage}{17cm}
   On considère les points $A\Coor{x_A}{y_A}$ et $B\Coor{x_B}{y_B}$ définis dans un repère orthonormal $\Rep$. \\
   Construire un algorithme permettant de calculer la longueur $AB$.
\end{minipage}
}

%%%%%%%%%%%%%%
\pagebreak %%%
%%%%%%%%%%%%%%

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\subsection{Langage naturel}

Le langage naturel, pour nous, est le français. Nous utiliserons seulement des mots simples, le texte doit être clair et bien structuré.

On sait que la longueur d'un segment $AB$ est définie par : $AB=\sqrt{(x_B-x_A)^2+(y_B-y_A)^2}$. \\

\begin{minipage}{8cm}
   On peut construire l'algorithme suivant : \\
   
   \textbf{Variables :} \\
      \hspace*{0.5cm} $x_A$ est l'abscisse de $A$ \\
      \hspace*{0.5cm} $y_A$ est l'ordonnée de $A$ \\
      \hspace*{0.5cm} $x_B$ est l'abscisse de $B$ \\
      \hspace*{0.5cm} $y_B$ est l'ordonnée de $B$ \\
      \hspace*{0.5cm} $D$ est la distance entre $A$ et $B$ \\

   \textbf{Initialisation, entrées :} \\
      \hspace*{0.5cm} Saisir $x_A$ \\
      \hspace*{0.5cm} Saisir $y_A$ \\
      \hspace*{0.5cm} Saisir $x_B$ \\
      \hspace*{0.5cm} Saisir $y_B$ \\

   \textbf{Traitement :} \\
      \hspace*{0.5cm} $D$ prend la valeur \\
      \hspace*{0.5cm} $\sqrt{(x_B-x_A)^2+(y_B-y_A)^2}$ \\

   \textbf{Sortie :} \\
      \hspace*{0.5cm} Afficher la valeur de $D$ \\
      \vspace*{1cm}
\end{minipage}
\begin{minipage}{9cm}  
   \psset{yunit=0.65}
   \begin{pspicture}(-4,0)(5,15)
      %\psgrid[subgriddiv=0,gridlabels=0,gridcolor=lightgray](0,0)(-4,0)(5,14)
      %\psaxes(0,0)(-4,0)(5,14)
      \psset{algebraic=true}
      \psline(-4,0)(-4,15.5)
      \rput{0}(2,1){\psellipse(0,0)(1.41,1)}
      \rput(2,1.05){\textbf{Fin}}
      \psline(2,3)(2,2)
      \psline(3,3)(0,3)(0,5)(4,5)
      \parametricplot{-0.9304398617240537}{0.0}{1*1.27*cos(t)+0*1.27*sin(t)+2.74|0*1.27*cos(t)+1*1.27*sin(t)+5}
      \parametricplot{2.2826431997038052}{3.1126152597382317}{1*1.35*cos(t)+0*1.35*sin(t)+4.38|0*1.35*cos(t)+1*1.35*sin(t)+2.96}
      \rput[tl](-2.5,4.2){\textbf{sortie}}
      \rput(2,4.05){Afficher D}
      \psline(2,6)(2,5)
      \psframe(0,6)(4,8)
      \rput[tl](-2.5,7.2){\textbf{calculs}}
      \rput(2,7.3){Calculer D :}
      \rput(2,6.7){\small{$\sqrt{(x_B-x_A)^2+(y_B-y_A)^2}$}} 
      \psline(2,9)(2,8)\pspolygon(0,9)(3.5,9)(4,11)(0.5,11)
      \rput[tl](-2.5,10.2){\textbf{entrées}}
      \rput(2,10.3){Lire}
      \rput(2,9.7){$x_A, y_A, x_B, y_B$}
      \psline(2,12)(2,11)
      \rput{0}(2,13){\psellipse(0,0)(1.41,1)}
      \rput(2,13.05){\textbf{Début}}
      \rput(2,15){Ou sous forme d'organigramme :}
   \end{pspicture}
\end{minipage}


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\subsection{Avec une calculatrice}

Voici ce que donne cet algorithme avec vos calculatrices :

\hspace*{0.5cm}
\fbox{
\begin{minipage}{7.5cm}   
   \begin{large}TI-82 Stats.fr\end{large} \\
   \hline
   \ \\
   \textbf{Préparation :} \\
   Appuyer sur "programme" \fbox{PRGM} \\
   Sélectionner "nouveau" \fbox{NOUV} \\
   Donner un nom au programme : DISTANCE \\
   
   \textbf{Saisie :} \\
   :Input $"XA=",X$ \\
   :Input $"YA=",Y$ \\
   :Input $"XB=",Z$ \\
   :Input $"YB=",T$ \\
   $\sqrt{\textcolor{white}{.}}((Z-X)\wedge2+(T-Y)\wedge2)\rightarrow D$ \\
   Disp $"D=",D$ \\ 
   
   \textbf {Utilisation :}  \\
   Appuyer sur "programme" \fbox{PRGM} \\
   Sélectionner "Exécuter" \fbox{EXEC} \\
   Sélectionner le programme \\
   Entrer les données ... et laisser faire ... \\
\end{minipage}
}
\hspace{1cm}
\fbox{
\begin{minipage}{7.5cm}   
   \begin{large}Casio Graph 35\end{large} \\
   \hline
   \ \\
   \textbf{Préparation :} \\
   Appuyer sur "Menu" \fbox{MENU} \\
   Sélectionner "Programme" \fbox{PRGM} \\
   Sélectionner "nouveau" \fbox{NEW} \\
   Donner un nom au programme : DISTANCE \\
   
   \textbf{Saisie :} \\
   $"XA":\;?\rightarrow X\leftarrow$ \psline(-0.15,0.1)(-0.15,0.3) \\
   $"YA":\;?\rightarrow Y\leftarrow$ \psline(-0.15,0.1)(-0.15,0.3) \\
   $"XB":\;?\rightarrow Z\leftarrow$ \psline(-0.15,0.1)(-0.15,0.3) \\
   $"YB":\;?\rightarrow T\leftarrow$ \psline(-0.15,0.1)(-0.15,0.3) \\
   $\sqrt{\textcolor{white}{.}}((Z-X)\wedge2+(T-Y)\wedge2)\rightarrow D\leftarrow$ \psline(-0.15,0.1)(-0.15,0.3) \\
   $"D=":D$\;\pspolygon[fillstyle=solid,fillcolor=black](0,0)(0.15,0)(0.15,0.15) \\
   
   \textbf {Utilisation :}  \\
   Appuyer sur "programme" \fbox{PRGM} \\
   Sélectionner le programme \\
   Entrer les données ... et laisser faire ... \\   
\end{minipage}
}


%%%%%%%%%%%%%%
\pagebreak %%%
%%%%%%%%%%%%%%


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\subsection{Avec Algobox}

AlgoBox est un \textbf{logiciel} libre, multi-plateforme et gratuit d'aide à l'élaboration et à l'exécution d'algorithmes dans l'esprit du nouveau programme de seconde. \\
Il est téléchargeable à l'adresse 
http://www.xm1math.net/algobox/download.html

Voici l'exemple de la programmation de notre exercice avec Algobox :

\begin{minipage}{10cm}
\begin{itemize}
   \item Cliquer sur le bouton \ovalbox{\textsf{Déclarer nouvelle variable}}, \\
   dans le champ \textsf{Nom de la variable}, entrer xA (vérifier le Type de la variable est bien sur \textsf{NOMBRE}).
   \item Répeter cette opération pour les variables yA, xB, yB et Distance.
   \item Se placer sur la ligne \textsf{DEBUT\_ ALGORITHME}, \\
   cliquer sur le bouton \ovalbox{\textsf{Nouvelle Ligne}}, \\
   cliquer sur le bouton \ovalbox{\textsf{Ajouter LIRE variable}}, \\
   dans le champ \textsf{LIRE la variable}, sélectionner la variable xA.
   \item Répéter cette opération pour les trois variables yA, xB, et yB.
   \item Créer une \textsf{nouvelle ligne}, \\
   cliquer sur le bouton \ovalbox{\textsf{AFFECTER valeur à variable}}, \\
   sélectionner la variable "Distance", \\
   indiquer sa valeur grâce à la formule : \\
   sqrt$((\text{xB}-\text{xA})\wedge2+(\text{yB}-\text{yA})\wedge2)$.
   \item Créer une \textsf{nouvelle ligne}, \\
   cliquer sur le bouton \ovalbox{\textsf{Ajouter AFFICHER message}}, \\
   écrire : Distance entre les points A et B :
   \item Créer une \textsf{nouvelle ligne},\\
   cliquer sur le bouton \ovalbox{\textsf{Ajouter AFFICHER variable}}, \\
   sélectionner distance.
\end{itemize}
\end{minipage}
\hspace*{1cm}
\begin{minipage}{6cm}
On obtient : \\

\textsf{$\blacktriangledown$ \textbf{VARIABLES} \\
\hspace*{0.01cm}
\begin{tabular}{|l}
   xA EST\_ DU\_ TYPE NOMBRE \\
   yA EST\_ DU\_ TYPE NOMBRE \\
   xB EST\_ DU\_ TYPE NOMBRE \\
   yB EST\_ DU\_ TYPE NOMBRE \\
   Distance EST\_ DU\_ TYPE NOMBRE
\end{tabular} \\
$\blacktriangledown$ \textbf{DEBUT\_ ALGORITHME} \\
\hspace*{0.05cm}
\begin{tabular}{|l}
   LIRE xA \\
   LIRE yA \\
   LIRE xB \\
   LIRE yB \\
   Distance PREND\_ LA\_ VALEUR \\
   \hspace*{1cm} sqrt$((\text{xB}-\text{xA})\wedge2+(\text{yB}-\text{yA})\wedge2)$ \\
   AFFICHER "Distance entre les points A et B :" \\
   AFFICHER Distance \\
\end{tabular} \\
\hspace*{0.15cm}-~\,\textbf{FIN\_ ALGORITHME} \\
}
\end{minipage} \\

Notre algorithme est maintenant terminé, il n'y a plus qu'à le tester :

\setlength{\parindent}{0.7cm}
\begin{itemize}
   \item Cliquer sur le bouton \ovalbox{\textsf{Tester Algorithme}},
   \item dans la fenêtre qui s'affiche, cliquer sur le bouton \ovalbox{\textsf{Lancer algorithme}},
   \item entrer les variables demandées une à une puis laisser le logiciel calculer la distance ...
\end{itemize}
\setlength{\parindent}{0cm}


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\subsection{Avec Python}

Python est un \textbf{langage de programmation} facile à utiliser et puissant. Il offre des structures de données de haut niveau et une approche simple mais réelle de la programmation. \\
Il est téléchargeable à l'adresse : http://www.python.org/download/

\begin{minipage}{8cm}
Pour ceux qui voudraient se lancer dans la programmation de cet exercice, voici les instructions : \\

Lancer Python en cliquant sur \texttt{IDLE (Python GUI)},  \\

faire \texttt{File – New Window}, \\

taper le programme ci contre, \\  

le sauvegarder (\texttt{File - Save as}), \\

le lancer en appuyant sur \texttt{F5}.
\end{minipage}
\hspace*{2cm}
\begin{minipage}{8cm}
\texttt{
\begin{tabular}{|l|}
   \hline
   from math import * \\
   print "Entrer l'abscisse de A" \\
   x = input() \\
   print "Entrer l'ordonnée de A" \\
   y = input() \\
   print "Entrer l'abscisse de B" \\
   z = input() \\
   print "Entrer l'ordonnée de B" \\
   t = input() \\
   d = sqrt$((\text{z}-\text{x})\text{**}2+(\text{t}-\text{y})\text{**}2)$ \\
   print "La distance entre A e B est :"\\
   print d \\
   \hline
\end{tabular}
}
\end{minipage}

\end{document}