Algorithme et Programmation - Cours en ligne de l'INSA de ... · PDF fileAlgorithme et Programmation . ... Il vous est demandé de mettre en œuvre une méthodologie de ... plus forte

Année universitaire 2009-2010

Algorithme et Programmation

Sujets des

Travaux Dirigés et des Travaux pratiques

2ème année INSA – MIC


Année universitaire 2009-2010

Algorithme et Programmation

Sujets des

Travaux Dirigés et des Travaux pratiques

Enseignants de travaux dirigés

Groupe A : Dominique Vial, [email protected]

Groupe B : Colette Merce, [email protected]

Groupe C : Guillaume Auriol, [email protected]

Groupe D : Patrick Esquirol, [email protected]

Enseignants de travaux pratiques

Groupe A : Dominique Vial, [email protected]

Romaric Guilherm, [email protected]

Groupe B : Colette Merce, [email protected]

Vincent Baudoui,

Groupe C : Guillaume Auriol, [email protected]

Dominique Vial, [email protected]

Groupe D : Patrick Esquirol, [email protected]

Nicolas Jozefowiez, [email protected]


mailto:[email protected]











2ème année INSA – MIC 4

CONSIGNES GENERALES

Les sujets de travaux dirigés et de travaux pratiques sont mis à votre disposition avant les séances de TD et TP afin que vous puissiez les préparer. Travaux dirigés

- Les TD sont axés sur la conception de programmes (choix de structures de données, approche par décomposition) et sur l'écriture d'algorithmes classiques (algorithmes de tri, de recherche en table, algorithmes récursifs, etc.).

- Vous devez avoir lu et assimilé le cours correspondant aux notions utilisées dans la séance de TD avant celle-ci. Des tests d'auto-évaluation pourront vous être proposés en début de certaines séances de TD. Ils seront relevés et corrigés par l'enseignant sans être notés.

- Le travail en TD se fait par groupe de 4 étudiants ; chaque groupe élabore collectivement une solution au TD et la soumet à l'enseignant. Il n'y aura pas de manière systématique pour chaque TD une solution corrigée au tableau. Une solution papier ne sera pas distribuée non plus.

Travaux Pratiques

Les TP sont centrés sur les différentes phases de développement d'un logiciel (conception, codage, tests unitaires et tests globaux). Il vous est demandé de mettre en œuvre une méthodologie de développement rigoureuse (détaillée dans le cadre du 1er TP).

Le but des TP est de vous permettre de comprendre et mettre en œuvre les notions vues en cours et en TD, de poser des questions, de progresser. Ils ne sont pas notés.

- Les TP doivent être préparés : établir avant la séance de TP l'algorithme du programme principal basé sur une approche par décomposition et la spécification des principaux sous-programmes. Cette fiche de conception sera demandée pendant la séance de TP.

- Un répertoire spécifique sera crée pour chaque sujet de TP. Il regroupera entre autres les fichiers correspondant aux différentes étapes de développement et de test de votre programme (développement incrémental). Cela permet de revenir facilement en arrière en cas de besoin pour affiner un test unitaire.

- A la fin de la séance de TP (ou de la 2ème séance si le sujet s'étend sur 2 séances), vous remettrez votre listing à l'enseignant de TP qui vous encadre. Celui-ci vous le rendra annoté au cours de la séance suivante afin que vous puissiez prendre en compte les annotations dans vos développements suivants.



TD1 – ANALYSE DESCENDANTE – ALGORITHMES –

– SOUS-PROGRAMMES –

– ALGORITHME DE KAPREKAR –

2 SEANCES

Partie 1 (séance 1)

Travail préparatoire au TD :

• Revoir les notions des chapitres 1et 2 du polycopié (Rappels et Sous-programmes)

Objectifs :

• Analyser un cahier des charges • Proposer une décomposition en sous-programmes

L’algorithme de Kaprekar consiste à associer à un nombre n entier positif un nombre K généré de la façon suivante :

On considère les chiffres de n. On forme le nombre n1 en arrangeant ces chiffres dans l’ordre croissant et le nombre n2 en les arrangeant dans l’ordre décroissant.

On pose K= n2 - n1. On itère ensuite le processus en remplaçant n par K. On arrête les itérations lorsque :

Le nombre K obtenu à l'issue d'une itération est nul, Les nombres K obtenus à l'issue de 2 itérations successives sont identiques, Le nombre d'itérations dépasse une valeur maximale prédéfinie.

Si n est un nombre positif à 4 chiffres non tous égaux, on peut montrer que l’algorithme de Kaprekar produit un nombre K = 6174 qui n'évolue plus au fil des itérations.

Exemple : à partir du nombre n= 5463 on obtient K= 6174 selon les itérations suivantes : 6543 – 3456 = 3087 8730 – 378 = 8352 8532 – 2358 = 6174 7641 – 1467 = 6174


On veut concevoir un programme permettant de tester l’algorithme de Kaprekar à partir de nombres à 4 chiffres fournis par un utilisateur. L’utilisateur devra pouvoir tester plusieurs nombres ; le programme s’arrêtera lorsque l’utilisateur fournira le nombre 0.

Travail demandé :

• Proposer une structure de données permettant de manipuler les chiffres composant un nombre de 4 chiffres c'est à dire permettant de les trier par ordre croissant et/ou décroissant.

• Ecrire le programme principal (déclaration des variables et partie instructions) en s'appuyant sur une décomposition logique en sous-programmes.

• Spécifier les sous-programmes identifiés lors de la décomposition (type du sous-programme, liste des paramètres avec leur mode de passage et leur type, commentaire précisant le but du sous-programme et la signification des paramètres)

• Vérifier la cohérence entre les appels des sous-programmes et leurs spécifications.

Partie 2 (1 séance)


• Revoir la partie 1 du TD1

Objectifs :

• Algorithmique (décomposition d'un nombre en chiffres, recomposition, tri, etc.) • Syntaxe Ada

Travail demandé :

• Compléter le programme écrit dans la 1ère partie, en écrivant les corps des sous-programmes spécifiés excepté le sous-programme de tri.


TD2 – TABLEAUX NON CONTRAINTS –

– GESTION D’UN TABLEAU DE NOTES –

2 SEANCES


• Comprendre les notions relatives aux tableaux non contraints (chapitre 3 du polycopié)

Objectifs :

• Savoir déclarer et utiliser à bon escient les tableaux non contraints • Développer un algorithme de tri dans un tableau

Un enseignant souhaite développer un logiciel facilitant la gestion des notes de ses classes d'élèves. Les classes n'ont pas toutes le même nombre d'élèves. Le logiciel doit permettre de saisir le nombre d'élèves de la classe considérée, les noms et prénoms des élèves (fournis dans un ordre quelconque) ainsi que la note obtenue pour chaque élève dans la matière considérée. Il doit permettre aussi d'afficher, au choix de l'utilisateur du programme, la liste des élèves classée selon leur note (de la plus élevée à la plus basse), la liste des élèves classée par ordre alphabétique, etc. Pour classer les étudiants par ordre décroissant de leur note, l’enseignant souhaite mettre en œuvre un algorithme de tri basé sur le principe de la recherche du plus grand élément d’un tableau. Le principe est le suivant : o on recherche la plus forte note du tableau et on la permute avec la note située en première

position dans le tableau, o on recherche ensuite la plus forte note du tableau privé de la note située en première

position, et on la permute avec la note située en deuxième position du tableau, ainsi de suite jusqu'à obtenir un tableau complètement classé. Votre mission est d’aider l’enseignant, non informaticien, à développer son programme.


Travail demandé :

• Choisir les structures de données les plus adaptées aux fonctionnalités du logiciel. Identifier éventuellement l'influence de ce choix sur les conditions d'utilisation du logiciel.

• Concevoir l'architecture du programme et spécifier les différents sous-programmes. • Développer le sous-programme de tri permettant de classer les étudiants par ordre

décroissant de leur note. Définir les jeux de tests qui permettraient de valider ce sous-programme.

• Adapter cet algorithme pour effectuer un classement des étudiants par ordre alphabétique de leur nom (et éventuellement de leur prénom en cas d’égalité du nom).


TD3

– RECURSIVITE –

Travail préparatoire au TD

• Revoir le chapitre4 sur la récursivité; • Faire l'exercice 1.

1. Calcul de pnC

Le nombre de combinaisons de n éléments pris p à p (0 ≤ p < n) peut être calculé en se basant sur les formules récursives suivantes :

10 =nC 1=n

nC p

np

np

n CCC 11

1 −−− +=

Ecrire une fonction récursive qui calcule . pnC

Dessiner l’arbre d’exécution pour un appel à cette fonction avec n= 3 et p=2.

2. Somme des éléments d’un tableau

On dispose d’un tableau non contraint dont la déclaration est la suivante : type Tab is array(natural range <>) of float ;

Ecrire une fonction récursive qui permet de calculer la somme des éléments d’un tableau de ce type.

3. Palindrome

Un palindrome est un mot, une phrase, un nombre qui, si l'on ne tient compte ni des espaces ou apostrophes ni des signes de ponctuation, peut être lu de droite à gauche ou de gauche à droite en gardant la même signification. Par exemple : eve, laval, un roc cornu, 239932 sont des palindromes.

a- Ecrire la version récursive et la version itérative d'un sous-programme permettant de déterminer si un mot donné est ou non un palindrome. On supposera que les mots ne comportent que des caractères significatifs (pas de blanc ou de signe de ponctuation).

b- Ecrire un programme qui saisit un mot fourni par l'utilisateur et affiche s'il s'agit ou pas d'un palindrome.


4. Recherche de la sortie dans un labyrinthe

On considère un labyrinthe modélisé par un tableau à 2 dimensions contenant des caractères. On adopte les conventions suivantes (cf. exemple) :

- le caractère ‘H’ représente un mur ; - le caractère ‘•’ représente un passage.

Il s’agit de trouver, à partir d’une position donnée, un chemin quelconque vers une sortie (pas nécessairement le chemin le plus court, ni le plus direct). On ne considère que des déplacements horizontaux ou verticaux (pas en diagonale).

Ecrire un sous-programme qui, pour un labyrinthe et une position de départ donnés, indique s’il existe un chemin vers une sortie. Si un tel chemin existe, le chemin trouvé doit être matérialisé par des caractères ∗ dans le labyrinthe.

H H H H H H H

H • • H • • H

H H H H • H H

H • • • • H H

H • • H • H H

H • • • • • H

H H H H H • H

Exemple de labyrinthe : Exécution pour différentes positions de départ :

H H H H H H H

H • • H ∗ • H

H H H H ∗ H H

H ∗ ∗ ∗ ∗ H H

H ∗ • H • H H

H ∗ ∗ ∗ ∗ ∗ H

H H H H H ∗ H

Chemin vers la sortie

Position de départ : ligne 2 ; colonne 5 Sortie trouvée ! Position de départ : ligne 2 ; colonne 3 Il n’existe pas de chemin vers la sortie!


TD4

– POINTEURS –

2 SEANCES

Travail préparatoire au TD

• Revoir le chapitre sur les pointeurs; • Faire l'exercice 1.

1. Nombre d’éléments d’une liste

Soient les déclarations suivantes :

type Element ; type Liste is access Element ; type Element is record

Info : ................ ; Suiv : Liste ;

end record ;

Ecrire une fonction qui retourne le nombre d’éléments contenus dans une liste donnée (fournir une version itérative et une version récursive de cette fonction).

2. Ajout d’un élément en fin de liste

Ecrire un sous-programme permettant d’ajouter un élément à la fin d’une liste. On considèrera le type Liste défini dans le cadre de l’exercice 1. Comment modifier la déclaration du type Liste pour simplifier l’insertion en fin de liste ?

3. Eclatement de liste

On dispose d’une liste de nombres entiers. On veut éclater cette liste en une liste de nombres pairs et une liste de nombres impairs. L’ordre des nombres dans ces listes est indifférent. Ecrire le programme réalisant l’éclatement de la liste.



TP1 – ANALYSE DESCENDANTE –

– ALGORITHME DE KAPREKAR –

Travail préparatoire au TP :

• Revoir les rappels du cours et le TD1 sur la décomposition d’un programme en sous-programmes

Objectifs :

• Maitriser l’environnement de développement lié à l’enseignement (création d’un fichier, copie d’un fichier, exécuter un programme,…)

• Savoir mettre en œuvre (écriture, tests de correction, correction, tests de validation) par étapes successives un programme simple

Le but de ce TP est de développer un programme permettant de tester l’algorithme de Kaprekar pour les nombres à 4 chiffres. Nous rappelons les principes de cet algorithme. A un nombre quelconque n est associé un autre nombre K(n) généré de la façon suivante :

On considère les chiffres de n, écrits dans une base quelconque. On forme le nombre n1 en arrangeant ces chiffres dans l’ordre croissant et le nombre n2 en les arrangeant dans l’ordre décroissant.

On pose K(n) = n2 - n1. On itère ensuite le processus avec K(n). Pour un nombre initial à 4 chiffres, l’algorithme de Kaprekar produit au final l’une des possibilités suivantes un nombre constant.

Travail demandé :

• Ecrire un programme P1 qui : 1. saisit un nombre de 4 chiffres fourni par l'utilisateur, 2. fait appel à un sous programme de décomposition d’un nombre en un

tableau, 3. affiche les chiffres issus de la décomposition.

• Valider le programme P1 en faisant afficher la décomposition pour plusieurs nombres saisis.

• Copier ce programme en un programme P2. Intégrer à P2 un appel à un sous-programme de recomposition d’un nombre à partir d’un tableau.

• Valider ce nouveau programme P2 en faisant afficher les chiffres issus de la décomposition puis le nombre recomposé.


• Récupérer le sous-programme de tri par ordre croissant d’un tableau à l’adresse fournie par vos enseignants.

• Adapter ce sous-programme à vos déclarations et étendre le programme P2 en un programme P3 en intégrant le sous-programme de tri.

• Valider le programme P3. Ppour cela : 1. saisir un nombre 2. décomposer ce nombre en chiffres rangés dans un tableau 3. trier le tableau 4. afficher le nombre recomposé formé à partir du tableau trié

• Finir le programme P3 pour tester l’algorithme de Kaprekar pour plusieurs nombres saisis par l’utilisateur jusqu’à ce qu’il tape 0 pour arrêter le test.

Note importante

Ce premier TP est particulier dans le sens où la phase de réflexion / conception / décomposition indispensable avant toute implémentation a été réalisée au cours des deux premières séances de TD. La méthodologie de développement est détaillée : le programme final est mis au point progressivement. Chaque sous-programme est validé individuellement. Cette méthodologie doit être suivie dans l'ensemble des TP (cf. consignes générales données en début du fascicule).


TP2 – ANALYSE DES MOTS DANS UNE PHRASE –

– TABLEAUX NON CONTRAINTS – CHAINES DE CARACTERES–

Travail préparatoire au TP :

• Revoir le cours et les TD sur les tableaux non contraints et les chaînes de caractères.

Objectifs : Manipulation de tableaux ; algorithme de recherche dans un tableau.

Le but de ce TP est de réaliser un programme permettant d’identifier les différents mots qui composent une chaîne de caractères. Le caractère ′ ′, appelé espace (barre d’espacement du clavier) est utilisé comme délimiteur ; un mot est une plus grande suite de caractères différents de espace. Dans un premier temps on s’intéresse uniquement à la mise au point d'un sous-programme permettant d’identifier le premier mot d’une chaîne (le plus à gauche). En considérant la chaîne restante, le même sous-programme peut alors être réutilisé pour obtenir le deuxième mot de la chaîne initiale, puis le troisième, et ainsi de suite jusqu’à ce que la chaîne restante après analyse du dernier mot soit vide.

ex : dans la chaîne :

Le hc ei n a ob ei3 4 2 1 7 8 6 5 11 12 10 9 15 16 14 13 19 18 17 20

" "

- le 1er mot est "Le" ; il commence à l’indice 3 et finit à l’indice 4 ; - le reste de la chaîne (indices 5..20) contient le 2ème mot "chien" (indices 7..11) ; - le reste de la chaîne (indices 12..20) contient le 3ème mot "aboie" (indices 14..18) - le reste de la phrase (indices 19..20) ne contient aucun mot. Le premier mot d’une chaîne, s’il existe, est défini par 2 entiers, deb et fin, tels que :

- deb est l’indice du premier caractère de la chaîne (le plus à gauche) différant de espace. S’il n’y en a aucun, la chaîne ne comporte aucun mot.

- si le début du premier mot a été trouvé, tous les caractères suivants qui diffèrent de espace font partie du premier mot ; fin est l’indice du dernier de ces caractères.


Travail demandé :

1.a Ecrire un sous-programme Chercher_Mot qui cherche uniquement le premier mot contenu dans une chaîne. La spécification de ce sous programme est la suivante : procedure Chercher_Mot ( Dans : in string;

Trouve : out boolean; Deb, Fin : out positive);

où : - Dans représente la chaîne dans laquelle on cherche le mot ; - Trouve indique si un mot a été trouvé dans la chaîne ; - Deb et Fin sont les indices du premier et du dernier caractère du premier mot trouvé.

1.b Ecrire un programme P1 de test de la procédure Chercher_Mot. P1 saisit une chaîne fournie par l’utilisateur, cherche le premier mot et affiche le résultat de la recherche (présence d’un mot et si oui indices de début et de fin dans la chaîne). On testera notamment les cas particuliers suivants :

- la chaîne saisie est de longueur nulle ; - la chaîne a une longueur >0 mais ne comporte que des espaces ; - la chaîne contient un mot et aucun espace ; - la chaîne comporte un mot précédé par des espaces ; - la chaîne comporte un mot suivi d’espaces ; - la chaîne comporte deux mots séparés par des espaces.

2. Ecrire un programme P2 qui saisit une chaîne fournie par l’utilisateur, recherche, affiche et compte tous les mots qui la composent. 3. Ecrire un programme P3 qui répète indéfiniment les actions décrites en 2 ou s’arrête si la chaîne saisie est de longueur nulle.


TP 3 – RECURSIVITE –

– RECHERCHE DICHOTOMIQUE – FLOCONS DE KOCH –

Durée : 1 séance de TP

Travail préparatoire au TP: revoir le cours et les TD sur la récursivité.

1- RECHERCHE DICHOTOMIQUE D'UNE VALEUR DANS UN VECTEUR ORDONNE

Soit V un vecteur (vecteur = tableau à une seule dimension) dont les composantes sont toutes différentes et rangées par ordre croissant. On désire déterminer si V contient une valeur donnée VAL et si tel est le cas, obtenir l’indice de VAL dans V. Pour cela on utilise une procédure de recherche dichotomique.

Principe de la recherche dichotomique : - si V est vide, VAL n’appartient pas à V - si V n’est pas vide, on peut déterminer « l’indice du milieu » M, du vecteur V

et comparer VAL à V(M). - si VAL = V(M), la recherche est terminée. VAL est à l’indice M. - si VAL < V(M), la recherche continue parmi les composantes inférieures à V(M), c-à-d celles dont l’indice est inférieur à M. - si VAL > V(M), la recherche continue parmi les composantes supérieures à V(M), c-à-d celles dont l’indice est supérieur à M.

a- Ecrire le sous-programme de recherche dichotomique (version récursive).

b- Ecrire un programme permettant de vérifier le bon fonctionnement du sous-

programme sur l’ensemble des cas possibles ; ce programme doit permettre de saisir un vecteur V quelconque (la taille est préalablement demandée à l’utilisateur) et la valeur VAL ; il doit ensuite afficher le résultat de la recherche de VAL dans V.

Question théorique annexe : pour un vecteur V de taille quelconque N, quel est le nombre maximum de comparaisons qu’il faut réaliser pour pouvoir conclure sur le résultat d’une recherche ?


2- COURBES ET FLOCONS DE KOCH Les figures ci-dessous représentent des courbes de Koch de finesse croissante :

1 32

En disposant 3 courbes de Koch de même taille et de même finesse, on obtient des flocons de Koch :

1 32 Ecrire une procédure récursive permettant de dessiner une courbe de Koch. L’utilisateur fournira sa finesse (un entier positif) et la longueur du segment initial (en pixels). On utilisera le paquetage Tortue_Graphique qui fournit un ensemble de sous-programmes permettant de réaliser des dessins. Pour plus de précisions sur les fonctionnalités de ce paquetage, éditer le fichier tortue_graphique.ads. On s’intéressera en particulier aux sous-programmes Tracer_Segment(Long) et Tourner(Angle). Réutiliser cette procédure pour le dessin d’un flocon de Koch. Pour utiliser le paquetage :

a) copier les fichiers tortue_graphique.ads et tortue_graphique.adb présents dans le répertoire /home/commetud/2eme Annee MIC/ADA/UV1/TP4 dans votre répertoire de travail.

b) insérer le nom du paquetage dans la clause with de votre programme :

with ..., ..., Tortue_Graphique;

c) compiler et créer un programme exécutable avec la directive suivante : gnatmake-graphx mon_prog.adb


TP 4 – POINTEURS–

– L ISTE – PROCESSUS –

2 SEANCES

Travail préparatoire au TP: Revoir le cours et les TD sur les pointeurs.

1- Gestion d'une liste de nombres (1ère séance)

Ecrire un programme qui

- lit une suite de valeurs entières fournies par l'utilisateur (la suite se termine par la valeur 0) et mémorise ces valeurs dans une structure de liste. La valeur 0 ne doit pas être mémorisée dans la liste ; les éléments sont rangés dans la liste dans l’ordre de leur lecture.

- affiche ces valeurs dans l'ordre de la saisie (première valeur saisie, première valeur affichée).

- affiche ces valeurs dans l'ordre inverse de la saisie (première valeur saisie, dernière valeur affichée). Remarques : - on ne dispose d'aucune information sur le nombre de valeurs fournies par l'utilisateur. - écrire un sous-programme associé à chaque fonctionnalité demandée (sous-

programme d’insertion d’une valeur dans la liste, sous-programme d’affichage dans l’ordre de la liste, sous-programme d’affichage dans l’ordre inverse de la liste).



2- Simulation d’ordonnancement de processus (2ème séance)

N tâches sont en attente d’exécution sur un processeur. Les tâches sont numérotées de 1 à N dans la file d'attente et ont une durée d'exécution. On veut simuler l'exécution par le processeur des tâches en attente en utilisant le principe de Round Robin qui est le suivant. Le processeur partage son temps sur les différentes tâches. Etant donné un quantum de temps élémentaire Q, il exécute chaque tâche de la file d'attente pendant Q unités de temps (la durée de la tâche est diminuée de Q) avant de passer à la suivante, etc.. Lorsqu'une tâche est terminée, elle quitte la file d'attente. Exemple : si on dispose de 4 tâches avec les durées indiquées dans la table ci-dessous et si la valeur du quantum de temps est 2, l’ordre d’achèvement des tâches est : T3, T1, T4 et T2.

T1 T2 T3 T4 3 5 2 3

Représentation interne : On représentera une tâche en cours d'exécution par une liste chaînée circulaire (le suivant du dernier élément de la liste est le premier élément de cette liste). En quoi cette représentation est-elle bien adaptée au problème ? 1- Ecrire un programme qui :

a- lit le nombre de tâches et la durée d'exécution de chacune et génère la représentation interne,

b- lit une valeur de Q et affiche les numéros des tâches au fur et à mesure de leur achèvement.

2- Modifier le programme précédent pour qu’il soit possible de répéter le 1-b pour différentes valeurs de Q fournies par l’utilisateur sans avoir besoin de re-saisir les données initiales (nombre et durées des tâches).

Documents

Algorithme et Programmation - Cours en ligne de l'INSA de ... · PDF fileAlgorithme et Programmation . ... Il vous est demandé de mettre en œuvre une méthodologie de ... plus forte