\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}