\documentclass[12pt,twoside,a4paper]{article}
\setlength{\textwidth}{16cm} \setlength{\voffset}{0cm}
\setlength{\headsep}{1cm} \setlength{\headheight}{0cm}
\setlength{\topmargin}{-0.5cm} \setlength{\textheight}{25cm}
\setlength{\evensidemargin}{0cm} \setlength{\oddsidemargin}{0cm}
\setlength{\parindent}{0cm} \setlength{\voffset}{-1.2cm}
\usepackage{t1enc}
\usepackage[latin1]{inputenc}
\usepackage[french]{babel}
\usepackage[dvips]{graphicx}
\usepackage{amsfonts}
\usepackage{amssymb}
\usepackage{amsmath}
\usepackage{fancyhdr}
%\usepackage{xspace}
\date{}

\pagestyle{fancy} \fancyhf{} \fancyhead[L]{UV 21 - Maple}
\fancyhead[R]{DUGEAD 1}

\fancyfoot[LE,RO]{\thepage{}}

\setcounter{page}{1}

%\fancypagestyle{plain}{\fancyhead{}
%\renewcommand{\headrulewidth}{0pt} }

\begin{document}
\pagestyle{fancy}

$ $

\vspace{1cm}


\begin{center}\Large{TD/TP Maple : fonctions et procédures}
\end{center}
\vspace{0cm}

%%%%%%%% A RAJOUTER
%Exercice 17. On considère une liste L numérique rangée par ordre
%croissante. Soit n sa longueur.
%    1°) Ecrire en Maple une fonction rang ayant pour paramètre la liste L et un nombre X qui  donne le rang du premier élément de L strictement plus grand que X ou n+1 si tous les éléments de L sont plus petits. Rang([1,2,5,8,8,9,10],6) donne 4
%    2°)On considère l'algorithme suivant où L est toujours une liste numérique croissante.
%Procédure saisie(L) Déclaration des paramètres L liste croissante
%numérique ENTREE et SORTIE Déclaration des variables locales
%    X :numérique, j :entier
%Début
% Lire(X)
%J :=rang((L,X) Insérer(X,j,L) Retour Si L :=[2,8,12,15] que devient
%L après l'appel de saisie(L) si l'utilisateur tape 1, après un
%deuxième appel si l'utilisateur tape 10, après un troisième appel si
%l'utilisateur tape 15. Implanter cette procédure en Maple.
%%%%%%%%%%%%%%%%%%%%%%

%\section*{Procédures}

\subsection*{Exercice 1}

\begin{enumerate}
\item Ecrire une procédure Maple ProcTrie(L) qui trie la liste L
(on pourra utiliser sort).
\item Ecrire une procédure Maple
ProcAjout(x,L) qui ajoute un élément x à la fin de la liste L.
\item Ecrire une procédure Maple ProcInserer(x,pos,L) qui insère
l'élément x dans L à la position pos.
\end{enumerate}

La liste L est dans ces trois procédures un paramètre
d'entrée-sortie.

On testera à chaque fois les procédures, pour vérifier que la
procédure a effectivement {\bf modifié la liste} placée en
paramètre.

\subsection*{Exercice 2}

 Ecrire une procédure myMember(x,L,p) fonctionnant comme
 la fonction member de Maple.

{\it Remarque :} Member à la fois renvoie un résultat
($true$/$false$ suivant si $x$ est dans L), et modifie $p$. Elle
est donc à la fois une fonction (renvoie un résultat) et une
procédure (modifie un paramètre). On parle de fonction
procédurale.

%\subsection*{Exercice 3}
%
%Ecrire une procédure pair(E) supprimant les nombres pairs d'un
%ensemble E de nombres entiers.


\subsection*{Exercice 3}

Exécutez les commandes Maple suivantes :

\begin{center}
\begin{tabular}{|l|l|}
\hline
> g:=proc(L::name)$\ \ \ \ \ $ & > g2:=proc(L::name)$\ \ \ \ $ \\
 RETURN(nops(eval(L))): & RETURN(nops(L)): \\
 end: & end: \\
 L:=[4,5,6]: & L:=[4,5,6]:\\
 g(L); & g2('L');\\
 > g('L'); &\\
\hline
\end{tabular}
\end{center}

puis les commandes :

\begin{center}
\begin{tabular}{|l|l|}
\hline
> g:=proc(x::name) $\ \ \ \ \ \ $& > g2:=proc(x::name)$\ \ \ \ \ $ \\
x:=x+1; & x:=eval(x)+1; \\
end: & end: \\
x:=3;g('x'):x; & x:=3;g2('x'):x;\\
\hline\end{tabular}
\end{center}

Expliquez les résultats obtenus.\\



\subsection*{Exercice 4}

-----------------------------------------

Conseil: faire faire en question préliminaire une fonction prenant
en paramètres deux dates (ou deux tarifs) et renvoyant vrai si la
première date est antérieure à la deuxième, et faux sinon.

-----------------------------------------

Dans une entreprise de service, un tarif est le prix
  de l'heure et compte tenu des changements de tarif, ce prix est
  accompagné d'une date d'effet. Ainsi un tarif peut s'implanter par
  la liste [jour, mois, année, prix].


Pour conserver les modifications, on considère la liste Tarifs qui
contient tous les tarifs utilisés depuis la création de
l'entreprise, rangés du plus récent au plus ancien.


Exemple:
Tarifs:=[[1,6,2002,200],[11,5,1998,160],[15,1,1997,120],[1,1,1995,100]]


\begin{enumerate}
\item Quel est le prix horaire le 15/09/1996? Ecrire en Maple une
  fonction {\bf prix:=proc(Tarifs, date)} qui détermine le tarif en cours à
  la date donnée, date étant du type [jour, mois, année].
\item Ecrire en Maple {\bf nouveauT:=proc(...)} ayant comme
paramètre
  d'entrée la liste Tarifs et permettant d'ajouter un nouveau tarif
  dont les valeurs seront saisies au clavier. On vérifiera que le
  nouveau tarif a une date d'effet postérieure au tarif en cours.
\item Chaque Intervention est implantée comme une liste avec la
date
  de prestation, le nombre d'heures correspondant à la prestation et
  le nom du client, soit


intervention:=[jour, mois, année, nombre\_heures, nom\_client].


Quel est le montant de [12,7,1999,6, ``Dupont''] en prenant pour
tarifs l'exemple donné? Ecrire une fonction {\bf montant} ayant
pour premier paramètre la liste des tarifs et comme deuxième
paramètre une intervention, et calculant le montant de la
prestation au moment ou elle a été effectuée.

\end{enumerate}



\subsection*{Exercice 5}

On relève certains jours de l'année le niveau des précipitations.
Une observation sera une liste de 3 valeurs $[$< numéro du jour
>,< numéro du mois >, < niveau >$]$. Par exemple, 10mm d'eau
observés le 13 février correspond à la liste [13,2,10]. On suppose
qu'une variable {\bf Observations} contient une liste de telles
observations. C'est donc une liste de listes.

\begin{itemize}
    \item On définit la variable
    {\bf Mois:=[31,28,31,30,31,30,31,31,30,31,30,31]} correspondant aux
    nombres de jours des mois d'une année non bissextile. Définir
    une fonction {\bf numjour} qui, à une observation donnée, associe le
    numéro du jour dans l'année. Par exemple, {\bf numjour}([12,2,10])
    vaut 43 (31 jours de janvier + 12 jours de février).
    \item Définir une fonction à valeurs booléennes {\bf correct}(x) qui
    retourne true si l'observation x correspond à un mois compris
    entre 1 et 12, un jour entre 1 et le nombre de jours du mois
    donné, et un niveau de précipitations positif ou nul.
    \item Donner une ou des instructions permettant de supprimer
    les observations incorrectes (si elles existent) de la
    variable {\bf Observations}.
    \item Donner une fonction booléenne {\bf Avant}(x,y) prenant la
    valeur true si l'observation x a lieu avant l'observation y.\\
    %\item Donner une ou des instructions Maple pour que la
    %variable {\bf Observations} soit triée chronologiquement.\\
\end{itemize}

\subsection*{Exercice 6}

Une association reçoit des dons. Un donateur peut effectuer
plusieurs dons. Chaque don est implanté sous la forme d'une liste
de deux éléments, le premier étant le nom du donateur en chaîne de
caractères, le deuxième le montant en franc (sans centime).
L'ensemble des dons est implanté sous forme d'une liste de dons.
On a donc une liste de listes. Par exemple, on pourra avoir une
liste de dons égale à:

{\footnotesize
[["ELF",10000],["BNP",10000],["MARTIN",500],["DUPONT",300],["MARTIN",200]]}

\begin{enumerate}
\item Ecrire une procédure ajout(L:: name,Nom:: string,Montant::
integer) qui ajoute à la fin de la liste L le nouveau don (dont le
nom et le montant sont les deux autres paramètres). \item Ecrire
en Maple une fonction {\texttt Moy} donnant à partir d'une liste L
de dons le montant moyen des dons. \item En fin d'année on veut
une liste des dons où chaque donateur apparaît une seule fois avec
le montant total de tous ses dons. Ecrire la fonction {\texttt
Cloture} qui à partir de L construit et renvoie cette liste. \item
Donner la ou les commande(s) Maple permettant
d'obtenir le don moyen par donateur.\\
\end{enumerate}

\subsection*{Exercice 7}

Soit $S_n(x)=\sum_{k=0}^n \frac{x^k}{k!}$.

\begin{itemize}
\item Trouver la formule de récurrence entre $S_{n+1}$ et $S_n$.
\item Ecrire en Maple une fonction Somme récursive ayant pour
paramètres x et n
  et renvoyant $S_n(x)$.
\end{itemize}


\subsection*{Exercice 8}
Ecrire une fonction récursive permettant de calculer le $n°$ terme
de la suite de Fibonacci définie par $u_0=u_1=1$ et, pour tout
$n\geq 2$, $u_n=u_{n-1}+u_{n-2}$.\\

\subsection*{Exercice 9}
 {\it Jeu du pendu}

-------------------------------------

Attention, cet exercice est assez long, les étudiants ont un peu de
mal à le faire.

-------------------------------------


On veut réaliser un jeu du pendu. On a donc un mot stocké dans une
variable S de type string (par exemple S:=``acapulco''). Nous
allons créer une chaîne de caractères Mot correspondant à la
situation où en est le joueur (avec les lettres qu'il a déjà
trouvées). Supposons que l'on ait perdu au bout de 10 tentatives.
Il faut donc demander une lettre au joueur. Si la lettre est dans
le mot S à trouver, on la remplace dans Mot. Si la lettre n'y est
pas, alors le joueur a une chance de moins. Si le mot est trouvé,
alors le joueur a gagné. S'il ne reste plus de tentative, le
joueur a perdu.

Pour cela, nous allons procéder comme suit. \begin{enumerate}
\item Créer une fonction \texttt{MotVide} prenant en paramètre une
chaîne de caractères et créant une chaîne de la même taille formée
de caractères -. Par exemple, \texttt{MotVide}(``acapulco'') doit
renvoyer ``- - - - - - - -''\item Créer une fonction
\texttt{EstDedans} prenant en paramètres une chaîne de caractères
S et une lettre (sous forme d'une chaîne d'un caractère) et
renvoyant {\em true} si lettre est dans S, et {\em false} sinon.
Par exemple \texttt{EstDedans}(``acapulco'',``b'') renvoie {\em
faux}. \item Créer une fonction \texttt{Remplace} prenant en
paramètres deux chaînes de caractères S1 et S2 et une lettre (sous
forme de chaîne d'un caractère). Cette fonction renvoie une chaîne
formée à partir de S2 où l'on a mis la lettre à la bonne place (ou
aux bonnes places), i.e. la où elle apparaît dans S1. Par exemple,
\texttt{Remplace}(``acapulco'',``-c-pu-c-'',``a'') renvoie
``acapu-c-''.

Remarque : si S est une chaîne de caractères, substring(S,i..j)
renvoie la chaîne formée des lettres d'indice i à j (de S). On
pourra utiliser cette fonction pour remplacer une lettre dans un
mot.\item Créer une fonction \texttt{Pendu} prenant en paramètre
une chaîne de caractères et simulant un jeu du pendu.
\end{enumerate}


\end{document}
