\input mias

\TP1
%%%%%%%%%%%%%%%%%
\def\affect{\modemath{{\mkern -2mu :\mkern -.3mu = \mkern 6mu}}}
\def\dpt{\modemath{{\mkern -2mu : \mkern 5mu}}}
\def\k {\ \kern 1cm}
%%%%%%%%%%%%%%%%%
\vskip -5mm
%%%%%%%%%%%%%%%%%
Ce sujet tr\`es \'el\'ementaire a pour but de vous faire manipuler des mots. Turbo--Pascal
propose le type {\tt string} qui est tr\`es similaire au type {\tt mot} qui
nous int\'eresse.
\puce La d\'eclaration d'une variable {\tt s \dpt string} \'equivaut \`a celle d'un tableau
\par
\centerline{\tt s \dpt array[0..255] of char.}
\par
La longueur {\tt l = length(s)} de {\tt s} est cod\'ee par la composante d'indice {\tt 0} : \par
\centerline{\tt l =  ord(s[0])}
\par 
et, pour chaque {\tt n} dans le domaine {\tt [1..l]}, {\tt s[n]} est le {\tt n}--i\`eme
caract\`ere de {\tt s}. 
\puce Nous prendrons la d\'efinition suivante du type {\tt mot} :
\pars
{\parindent 4cm
\tt
\item{type mot =} record\par
{\parindent 6cm
\item{ch \dpt} array[1..Max] of char ;\par
\item{long \dpt} integer\par
}
\item{} end ;\par
}
\pars
o\`u {\tt Max} est une constante que vous choisirez en fonction de vos besoins.
\parm
{\bf I. Primitives relatives aux mots.}
\pars
Ecrire les primitives suivantes \dpt
\pars
\bib{\tt procedure motvide( var u \dpt mot ) ;}{ 
construire le mot vide, c'est--\`a--dire, 
sch\'ematiquement : {\tt u \affect ()},
}
\par
\bib{\tt procedure adjoindre( var u \dpt mot ; x \dpt char ) ;}{
adjoindre le caract\`ere {\tt x}
\`a la fin du mot {\tt u} c'est--\`a--dire \dpt {\tt u \affect ux},
} 
\par
\bib{\tt procedure lire( var u \dpt mot ) ;} {
donner \`a {\tt u} la valeur correspondant \`a une cha\^\i ne
de caract\`eres lue \`a l'\'ecran, {\sl cette proc\'edure est la seule o\`u doit intervenir une variable
de type {\tt string}},
}\par
\bib{\tt procedure retirer( var u \dpt mot ) ;} {
retirer le dernier caract\`ere d'un mot 
c'est--\`a--dire \dpt si {\tt u = vx} alors {\tt u \affect v}, 
}
\par
\bib{\tt function longueur( u \dpt mot ) \dpt integer ;} {
renvoyer la longueur d'un mot,
}
\par
\bib{\tt function nieme( u \dpt mot ; n \dpt integer ) \dpt char ;} {
renvoyer le {\tt n}--i\`eme
caract\`ere du mot {\tt u},}\par
\bib{\tt procedure ecrire( u \dpt mot ) ;} {
\'ecrire \`a l'\'ecran la cha\^\i ne de caract\`eres correspondant
au mot {\tt u}.
}
\parm
{\bf II. Applications.}
\pars
Ecrire des programmes n'utilisant que les primitives que vous venez de d\'efinir (les
lectures et \'ecritures se feront toutes au clavier et \`a l'\'ecran). 
Par exemple : 
\puce Inverser un mot (c'est--\`a--dire, transformer un mot en son image miroir).
\puce Tester si un mot est un palindrome (c'est--\`a--dire, tester s'il est \'egal \`a son inverse). 
\puce Concat\'ener deux mots.
\puce Comparer deux mots.
\puce Tester si un mot {\tt v} 
est un sous--mot du mot {\tt u} :
si le test est positif, il devra permettre de localiser la premi\`ere occurrence
de {\tt v} dans {\tt u}.
\puce Tester si un mot est correctement parenth\'es\'e.

\bye