Vous êtes sur la page 1sur 17

EXO6: Partie 2

Écrire un programme en assembleur pour compter le nombre de ‘la’ dans une phrase. le caractère ‘$’ est utilisé pour
marquer la fin de la chaine de caractère.
Exemple : ‘’ la programmation en assembleur est facile lalala$’’ → il y a 4 ‘la’

Solution: Explication
Soit Compt_la une variable qui sera incrémenté quand le programme détecte un ‘l’ puis un ‘a’ en parcourant les
éléments du tableau de caractère qu’on va appeler phrase.
Donc, chaque élément phrase[i] est comparé d'abords à ‘l’:
- Si l’élément phrase[i] est égale à ‘l’, on teste l’élément suivant: si [i+1] est égale à ‘a’ , on incrémente Compt_la.
- sinon, on passe à l’élément suivant.
Le programme répète ces comparaisons tant que la fin de la phrase n’est pas ateinte. Cette fin est marqué par le caractère
‘$’. Après la fin d’exécution, la variable Compt_la contiendra le nombre de ‘la’ dans la phrase.
Le registre d’index SI sera utilisé pour indexer directement les éléments du tableau ‘phrase’ composés des caractères
(c-à-d de type Byte) donc SI sera incrémenté de 1 pour passer d’un élément i à l’élément suivant du tableau.

SI=0

. . . . . . . . . . . l a . . . . . . . . . . . . . . . $

phrase[SI]=‘$’? : non  phrase[SI]=‘l’? : non  passer à l’élément suivant


EXO6: Partie 2
Écrire un programme en assembleur pour Compter le nombre de ‘la’ dans une phrase. le caractère ‘$’ est utilisé pour
marquer la fin de la chaine de caractère.
Exemple : ‘’ la programmation en assembleur est facile lalala$’’ → il y a 4 ‘la’

Solution: Explication
Soit Compt_la une variable qui sera incrémenté quand le programme détecte un ‘l’ puis un ‘a’ en parcourant les
éléments du tableau de caractère qu’on va appeler phrase.
Donc, chaque élément phrase[i] est comparé d'abords à ‘l’:
- Si l’élément phrase[i] est égale à ‘l’, on teste l’élément suivant: si [i+1] est égale à ‘a’ , on incrémente Compt_la.
- sinon, on passe à l’élément suivant.
Le programme répète ces comparaisons tant que la fin de la phrase n’est pas ateinte. Cette fin est marqué par le caractère
‘$’. Après la fin d’exécution, la variable Compt_la contiendra le nombre de ‘la’ dans la phrase.
Le registre d’index SI sera utilisé pour indexer directement les éléments du tableau ‘phrase’ composés des caractères
(c-à-d de type Byte) donc SI sera incrémenté de 1 pour passer d’un élément i à l’élément suivant du tableau.

SI=1

. . . . . . . . . . . l a . . . . . . . . . . . . . . . $

phrase[SI]=‘$’? : non  phrase[SI]=‘l’? : non  passer à l’élément suivant


EXO6: Partie 2
Écrire un programme en assembleur pour Compter le nombre de ‘la’ dans une phrase. le caractère ‘$’ est utilisé pour
marquer la fin de la chaine de caractère.
Exemple : ‘’ la programmation en assembleur est facile lalala$’’ → il y a 4 ‘la’

Solution: Explication
Soit Compt_la une variable qui sera incrémenté quand le programme détecte un ‘l’ puis un ‘a’ en parcourant les
éléments du tableau de caractères qu’on va appeler phrase.
Donc, chaque élément phrase[i] est comparé d'abords à ‘l’:
- Si l’élément phrase[i] est égale à ‘l’, on teste l’élément suivant: si [i+1] est égale à ‘a’ , on incrémente Compt_la.
- sinon, on passe à l’élément suivant.
Le programme répète ces comparaisons tant que la fin de la phrase n’est pas ateinte. Cette fin est marqué par le caractère
‘$’. Après la fin d’exécution, la variable Compt_la contiendra le nombre de ‘la’ dans la phrase.
Le registre d’index SI sera utilisé pour indexer directement les éléments du tableau ‘phrase’ composés des caractères
(c-à-d de type Byte) donc SI sera incrémenté de 1 pour passer d’un élément i à l’élément suivant du tableau.

SI=1
SI=XX ...........

. . . . . . . . . . . l a . . . . . . . . . . . . . . . $

phrase[SI]=‘$’? : non  phrase[SI]=‘l’? : oui  phrase[SI+1]=‘a’? : oui


 Compt_la = Compt_la + 1
EXO6: Partie 2
Écrire un programme en assembleur pour Compter le nombre de ‘la’ dans une phrase. le caractère ‘$’ est utilisé pour
marquer la fin de la chaine de caractère.
Exemple : ‘’ la programmation en assembleur est facile lalala$’’ → il y a 4 ‘la’

Solution: Explication
Soit Compt_la une variable qui sera incrémenté quand le programme détecte un ‘l’ puis un ‘a’ en parcourant les
éléments du tableau de caractère qu’on va appeler phrase.
Donc, chaque élément phrase[i] est comparé d'abords à ‘l’:
- Si l’élément phrase[i] est égale à ‘l’, on teste l’élément suivant: si [i+1] est égale à ‘a’ , on incrémente Compt_la.
- sinon, on passe à l’élément suivant.
Le programme répète ces comparaisons tant que la fin de la phrase n’est pas ateinte. Cette fin est marqué par le caractère
‘$’. Après la fin d’exécution, la variable Compt_la contiendra le nombre de ‘la’ dans la phrase.
Le registre d’index SI sera utilisé pour indexer directement les éléments du tableau ‘phrase’ composés des caractères
(c-à-d de type Byte) donc SI sera incrémenté de 1 pour passer d’un élément i à l’élément suivant du tableau.

SI=XX .............................

. . . . . . . . . . . l a . . . . . . . . . . . . . . . $

phrase[SI]=‘$’? : oui Fin du programme


Solution: Algorithme

Initialiser SI à 0
Tant que T[SI]≠ ‘$’
si T[SI]=‘l’ alors
si T[SI+1] = ‘a’ alors
Compt_la  Compt_la +1
SI  SI + 1
fin si
fin si
SI  SI + 1
Fin tant que

0 1 2 3 4 5 6 7 8 9 A B C D E F 10 11 12 13 14 15 16 17 18 191A1B 1C1D1E 1F 20 21 22 23 24 25 26 27 28 292A2B 2C2D2E 2F 30


l a p r o g r a mm a t i o n e n a s s e m b l e u r e s t f a c i l e l a l a l a $
Solution: Programme
Solution: avant Exécution
Solution: après Exécution
EXO6: Partie 3
Écrire un programme en assembleur pour mettre les initiales des mots en majuscule . On suppose que la première lettre
est en majuscule et les mots sont séparés par un seul espace. le caractère ‘$’ est utilisé pour marquer la fin de la chaine
de caractère.
Exemple : ‘’ La programmation en assembleur est facile$’’ → ‘’ La Programmation En Assembleur Est Facile$’’
Solution: Explication
Le principe est de détecter d’abords les initiales des mots d’une‘phrase’; Ce ci revient à détecter les espaces. Une fois
l’espace détecté, la lettre suivante est mise en majuscule. Pour mettre une lettre en majuscule il suffit de modifier son
code selon la table ascii (voir TP1). En effet la différence entre les codes des lettres miniscules (a,b,c,…,z = 61h,62h,63h, …,
7Ah) et les codes des mêmes lettres en majuscules (A,B,C,…,Z = 41h,42h,43h, …, 5Ah) est toujours la même (égales à 20h).
Donc ‘A’=‘a’-20h (conversion minuscule  majuscule) et ‘a’=‘A’+20h (conversion majuscule  minuscule)

Donc, chaque élément phrase[i] est comparé d'abords à espace =20h:


- Si l’élément phrase[i] est égale à 20h, la lettre phrase[i+1]  phrase[i+1]-20h
- sinon, on passe à l’élément suivant.
Le programme répète ces comparaisons et modifications tant que la fin de la phrase n’est pas atteinte. Cette fin est
marqué par le caractère ‘$’.
Solution: Programme
Solution: avant Exécution
Solution: après Exécution
EXO6: Partie 1
Écrire un programme en assembleur pour trier par ordre alphabétique les lettres d’une chaine de caractère. le caractère
‘$’ est utilisé pour marquer la fin de la chaine de caractère.
exemple : "programme$" → "aegmmoprr$".

Solution: Explication
Trier par ordre alphabétique les lettres d’un ‘mot’; revient à trier un tableau de valeurs par ordre croissant. Il existe
plusieurs algorithmes de tri ( par sélection, fusion, insertion….) . Pour cette exercice nous utilisons la méthode de tri par
sélection qui consiste à:
1. rechercher le plus petit élément du tableau, et l'échanger avec l'élément d'indice 0 ;
2. rechercher le second plus petit élément du tableau, et l'échanger avec l'élément d'indice 1 ;
3. continuer de cette façon jusqu'à ce que le tableau soit entièrement trié.
Donc, pour n éléments, on a besoin de n-1 étape (itérations) pour chercher les minimums:
4. étape 1 : chercher l’indice (ind) du minimum des éléments mot[0], mot[1], … , mot[n-1] (n éléments),
puis permuter mot[0] mot[ind]
5. étape 2 : chercher l’indice (ind) du minimum des éléments mot[1], … , mot[n-1] (n-1 éléments), puis
permuter mot[1] mot[ind]
6. ……………..
7. dernière étape : chercher l’indice (ind) du minimum des éléments mot[n-2], mot[n-1] (2 éléments), puis
permuter mot[n-1] mot[ind]
La recherche du minimum se fait par des comparaisons successives. Pour m éléments, on effectue m-1 comparaisons. Le
programme répète ces comparaisons et les permutations tant que la fin du mot n’est pas atteinte. Cette fin est marquée
par le caractère ‘$’.
Solution: Explication
Solution: Programme
Solution: avant Exécution
Solution: après Exécution