Entraînements d`algorithmique - moodle@insa

Entraînements d’algorithmique
Basique : * ; simple : ** ; plus évolué : *** ; amusant : ****.
1. Demander deux valeurs à l’utilisateur, puis afficher leur somme :
- (*) d’abord sans utiliser de sous-programmes, avec des variables globales
- (*) toujours avec des variables globales, mais en utilisant trois sous-programmes sans
paramètres Acquérir_Valeur, Ajouter_Valeurs et Afficher_Valeur
- (**) sans utiliser de variables globales, en passant les paramètres convenables aux trois
sous-programmes.
2. (*) Demander à l’utilisateur les coefficients a et b de l’équation du 1er degré ax + b = 0, puis
résoudre l’équation en tenant compte de tous les cas particuliers qui peuvent survenir.
3. Faire sortir l’escargot de son puits, en affichant le journal détaillé de sa progression, sous la
forme : « Jour n° XXX : position initiale YYY ; position finale ZZZ [ou : sortie du puits] » :
- (*) en utilisant les hypothèses du cours
- (**) en supposant que l’escargot ne se déplace pas selon un rythme quotidien
(nycthéméral, devrais-je écrire), mais alterne un déplacement de Durée_Montée heures
à la vitesse Vitesse_Montée avec un déplacement de Durée_Descente heures à la vitesse
Vitesse_Descente ; afficher l’heure en plus du jour dans le journal de progression
- (***) en utilisant un tableau décrivant des actions réalisées cycliquement par l’escargot
(par exemple : 4 h de montée, puis 1 h de descente, puis 3 h de montée, etc).
4. Calculer, à l’aide d’une boucle :
- (*) la somme des entiers de 1 à N, N étant une valeur donnée par l’utilisateur
- (**) la somme des entiers 1, 2, 4, 7, 11, etc., inférieurs ou égaux à N (la différence entre
deux entiers successifs augmentant de 1 à chaque étape).
5. Trouver, sans utiliser de tableau, le minimum, le maximum et la moyenne de valeurs entrées
au clavier :
- (*) dans le cas où les valeurs à traiter sont toutes non nulles et où on convient que
l’utilisateur indique qu’il a terminé sa saisie en entrant la valeur 0
- (*) dans le cas où l’utilisateur indique au préalable combien de valeurs il va fournir.
6. (**) Utiliser un des algorithmes élaborés précédemment pour déterminer si un triangle, dont
l’utilisateur donne les longueurs des côtés dans un ordre quelconque, est ou non un triangle
rectangle.
7. Sans utiliser de tableau, déterminer la ne valeur de la suite de Fibonacci Fn = Fn-2 + Fn-1, avec
F1 = F2 = 1 :
- (**) grâce à un algorithme itératif
- (**) grâce à algorithme récursif (dire quel algorithme est préférable).
8. Déterminer si un nombre est palindromique (i.e. si sa valeur reste la même après inversion des
chiffres, comme par exemple 12321), sans ranger ses chiffres dans un tableau :
- (***) grâce à un algorithme itératif
- (***) grâce à algorithme récursif (dire quel algorithme est préférable).

9. Dans une suite dite de Syracuse, on part d’un entier naturel N ; s’il est pair, on le divise par 2
et, s’il est impair, on le multiplie par 3 et on ajoute 1. En répétant l’opération, on obtient une
suite d'entiers qui semble toujours aboutir à la valeur 1, à partir de laquelle le cycle (1, 4, 2) se
répète (NB : on croit le constater, mais on ne sait pas le démontrer mathématiquement).
- (**) Vérifier la conjecture en partant d’un N fourni par l’utilisateur (ne pas utiliser de
tableau) ; on affichera le temps de vol de la suite (le nombre d’éléments de la suite
jusqu’à la première valeur 1 comprise ; il vaut par exemple 18 pour N = 14) et son
altitude maximale (la valeur la plus grande présente dans la suite).
- (****) L’altitude maximale de la suite peut rapidement devenir très élevée (elle vaut par
exemple 9232 pour N = 27) ; pour éviter tout débordement des calculs, c.-à-d. toute
situation où un élément de la suite deviendrait supérieur à l’entier maximum
représentable en machine Entier_Max, représenter les éléments de la liste sous forme de
liste chaînée d’entiers inférieurs ou égaux à Entier_Max.
10. (***) Déterminer, en un nombre aussi réduit que possible d’essais, un nombre pensé par
l’utilisateur et compris entre deux valeurs ; pour cela, proposer à l’utilisateur des valeurs,
auxquelles il répondra par un caractère signifiant « trop petit », « trop grand » ou « trouvé ! ».
11. (*) Lister les valeurs contenues dans un tableau à l’envers, de la dernière à la première.
12. (**) Déterminer l’indice de la plus petite et de la plus grande valeur contenue dans un tableau.
13. (**) Déterminer tous les nombres premiers inférieurs à une certaine valeur par la méthode du
crible d’Eratosthène.
14. Utiliser le résultat de la question précédente pour :
- (**) trouver les 4 premiers nombres parfaits, c.-à-d. égaux à la somme de leurs diviseurs
- (***) trouver toutes les paires de nombres amiables inférieurs à 10000 (deux nombres
sont amiables si la somme des diviseurs de l’un est égale à la somme de ceux de l’autre).
15. Dire si une valeur appartient à un tableau :
- (**) dans le cas où celui-ci n’est pas trié
- (***) dans le cas où il est trié, en procédant par dichotomie.
16. (**) Insérer, à sa place, une valeur dans un tableau trié.
17. Trier un tableau
- (**) par insertions successives, en utilisant un deuxième tableau
- (**) par un tri à bulles.
18. (***) Fusionner deux tableaux triés en un troisième tableau trié.
19. (****) Gestion d’une pile : écrire les procédures et fonctions Vider_Pile, Empiler_Elément,
Dépiler_Elément, Lister_Eléments, Nombre_Eléments, et Valeur_Sommet_Pile.
20. (****) Utiliser tout ou partie du résultat de la question précédente pour visualiser l’état des
tours de Hanoï après chaque déplacement de disque.

Un algorithme mystérieux
Que fait la procédure ci-dessous, sachant qu’elle reçoit en entrée un tableau T de N éléments,
chacun de ces éléments pouvant prendre une valeur égale à Vert, Jaune ou Rouge ?
Procédure Rasta (T)
Indice_Vert = 1
Indice_Jaune = N
Indice_Rouge = N
tq Indice_Vert <= Indice_Jaune faire
si T(Indice_Vert) = Vert
alors
Indice_Vert = Indice_Vert + 1
sinon
si T(Indice_Vert) = Jaune
alors
T(Indice_Vert) = T(Indice_Jaune)
T(Indice_Jaune) = Jaune
Indice_Jaune = Indice_Jaune – 1
sinon
T(Indice_Vert) = T(Indice_Jaune)
T(Indice_Jaune) = T(Indice_Rouge)
T(Indice_Rouge) = Rouge
Indice_Jaune = Indice_Jaune – 1
Indice_Rouge = Indice_Rouge – 1
fsi
fsi
ftq
Fin procédure
Conseil : si vous ne voyez pas du premier coup d’œil la fonction de cette procédure, faites-en
ce qu’on appelle la trace. Pour cela, donnez-vous un tableau T de taille raisonnable (8 à 10
éléments suffiront), rempli au hasard d’éléments verts, jaunes ou rouges, et faites tourner
l’algorithme « à la main », en notant l’évolution du contenu du tableau et des variables
auxiliaires chaque fois qu’un changement se produit.
NB 1 : Vous pouvez bien sûr observer le fonctionnement de la procédure en la programmant
et en la faisant exécuter par une machine, mais c’est moins formateur.
NB 2 : Cet algorithme a été inventé par Edsger Dijkstra [ˈɛtsxər ˈdɛɪkstra], un des pères de
l’informatique ; de nationalité hollandaise, il a décrit l’algorithme en utilisant les couleurs
rouge, blanche et bleue.