Bases de programmation - TD 3 : Tableaux et types complexes Exercice 1.

Exercice 1.2 : Ecrire un algorithme qui prends en entre deux matrices 2 dimensions et calcule leur produit.
Rappel : Soit mat1 une matrice de taille l m et mat2 une matrice de taille m c, le produit des deux matrices, not
IUT Aix-Marseille / DUT R&T 1ire anne mat1 mat2 est une matrice de taille l c tel que chaque case dindex (i, j) pour valeur :
m 1
J. Seinturier (http://www.seinturier.fr) mat1 mat2 (i, j )= mat (i, k) mat (k, j)
k =0
1 2

1. Tableaux plusieurs dimensions

Exercice 1.1 : Ecrire un algorithme qui demande lutilisateur un nombre de lignes et un nombre de colonnes et algorithme mulmat
qui ensuite fait la saisie de toutes les valeurs dun tableau dentiers en 2 dimensions ayant le bon nombre de lignes entres
et de colonnes. mat1 : entier[][]
mat2 : entier[][]
algorithme saisieDynamique donnes
donnes resultat : entier[][]
ligne : entier i : entier
colonne : entier j : entier
tab : entier[][] m : entier
dbut k : entier
ligne lire() dbut
colonne lire() i dimension(mat1, 0)
tab entier[ligne][colonne] j dimension(mat2, 1)
ligne 0 m dimension(mat1, 1)
tantque ligne < dimension(tab, 0) faire resultat entier[i][j]
colonne 0
tantque colonne < dimension(tab, 1) faire i 0
tab[ligne][colonne] lire() tantque i < dimension(resultat, 0) faire
colonne colonne + 1 j 0
fintq tantque j < dimension(resultat, 1) faire
ligne ligne + 1 k 0
fintq resultat[i][j] 0;
fin
tantque k < m faire
resultat[i][j] resultat[i][j] + mat1[i][k] mat2[k][j]
k k + 1
fintq

j j + 1
fintq

i i + 1
fintq
fin
Exercice 1.3 : Ecrire un algorithme qui prend en entre un tableau de chaines de caractre 2 dimensions et qui Exercice 2.2 : Ecrire la dfinition dun type complexe Adresse qui permettra de reprsenter une adresse postale.
retourne les indexes de ligne et de colonne de la premire case contenant le mot Bonjour trouve. Si le mot Une adresse postale est compose dun numro de rue (entier), dun nom de voie (chaine), dun code postal
nest pas trouv, les indexes renvoys doivent tre -1. (entier) et dune ville (chaine)

algorithme recherche type Adresse

entres donnes
texte : chaine[][] numero_rue : entier
sortie voie : chaine
indexLigne : entier code : entier
indexColonne : entier ville : chaine
donnes fintype
lignes : entier
colonne : entier Exercice 2.3 : Ecrire un algorithme lirePersonne qui retourne une valeur de type Personne dont les champs ont t
trouve : boolen saisis par lutilisateur.
dbut
indexLigne -1 algorithme lirePersonne
indexColonne -1 sortie
personne : Personne
trouve faux dbut
personne nouveau Personne
ligne 0 personne.nom lire()
tantque ligne < dimension(texte , 0) et non trouve faire personne.prenom lire()
colonne 0 personne.secu lire()
tantque colonne < dimension(texte , 1) et non trouve faire fin
si texte[ligne][colonne] = Bonjour alors
indexLigne ligne Exercice 2.4 : Ecrire un algorithme lireAdresse qui retourne une valeur de type Adresse dont les champs ont t
indexColonne colonne saisis par lutilisateur.
trouve vrai
finsi algorithme lireAdresse
colonne colonne + 1 sortie
fintq adresse : Adresse
ligne ligne + 1 dbut
fintq adresse Adresse
adresse.numero_rue lire()
fin adresse.voie lire()
adresse.code lire()
2. Types complexes et oprations simples adresse.ville lire()
fin
Exercice 2.1 : Ecrire la dfinition dun type complexe permettant de reprsenter une personne. Le type sera
nomm Personne et devra contenir : un nom (chaine), un prnom (chaine) et un numro de scurit sociale Exercice 2.5 : En gnral, une personne peut galement tre identifie par une adresse postale. Modifier le type
(entier). Personne afin dintgrer une adresse postale dans la description dune personne. (Penser limbrication)

type Personne type Personne

donnes donnes
nom : chaine nom : chaine
prenom : chaine prenom : chaine
secu : entier secu : entier
fintype adresse : Adresse
fintype
Exercice 2.6 : Modifier lalgorithme lirePersonne afin de lire galement ladresse de la personne en cours de saisie. Exercice 2.9 : Ecrire un algorithme memeAdresse qui prends en entre deux Personne et qui retourne vrai celles-
Conseil : Nhsitez pas appeler des algorithmes existants sous forme de fonctions. ci habitent la mme adresse et faux sinon.

algorithme lirePersonne algorithme memeAdresse

sortie entres
personne : Personne p1 : Personne
dbut p2 : Personne
personne nouveau Personne sortie
personne.nom lire() ok : boolen
personne.prenom lire() dbut
personne.secu lire() ok p1.adresse.numero_rue = p2.adresse.numero_rue
ok ok et p1.adresse.voie = p2.adresse.voie
personne.adresse lireAdresse() ok ok et p1.adresse.code = p2.adresse.code
fin ok ok et p1.adresse.ville = p2.adresse.ville
fin
Exercice 2.7 : Ecrire un algorithme ecrireAdresse qui prend en entre une Adresse et permet den crire toutes les
donnes. 3. Types complexes et collections
algorithme ecrireAdresse Exercice 3.1 : Nous souhaitons maintenant reprsenter un voisinage de personnes. Nous nous limiterons ici
entres dcrire un voisinage comme un ensemble de personnes habitant de faon contigu dans la mme rue. Afin de
adresse : Adresse
reprsenter un voisinage, crire la dfinition du type Voisin compos :
dbut
ecrire(adresse.numero_rue)
dune variable pers de type Personne qui dcrit lhabitant actuel
ecrire(adresse.voie)
ecrire(adresse.code) dune variable gauche de type Voisin qui dcrit le voisin habitant dans la maison gauche de la maison
ecrire(adresse.ville) actuelle ;
fin dune variable droite de type Voisin qui dcrit le voisin habitant dans la maison droite de la maison
actuelle ;
Exercice 2.8 : Ecrire un algorithme ecrirePersonne qui prends en entre une Personne et permet den crire toutes
les donnes, y compris ladresse postale. Conseil : Lappel de fonctions est toujours votre ami. Nous considrerons pour le reste du TD que la rue est compose de maisons toutes contigus et que chaque
maison nest habite que par une seule personne.
algorithme ecrirePersonne
entres Les voisins habitants aux extrmits dune rue nont pas de voisin droit ou gauche. Afin de reprsenter cela, les
personne : Personne variables correspondantes recevront pour valeur null.
dbut
ecrire(personne.nom) type Voisin
ecrire(personne.prenom) donnes
ecrire(personne.secu) pers : Personne
gauche : Voisin
ecrireAdresse(personne.adresse) droite : voisin
fin fintype
Exercice 3.2 : En utilisant les types appropris, crire un algorithme population qui permet de saisir le voisinage Exercice 3.4 : Ecrire un algorithme distanceDroite qui prend en entre une variable de type Voisin et qui
dune rue. Cet algorithme saisira les voisins de la droite vers la gauche. A chaque saisie de voisin, lalgorithme compte le nombre de voisin sa droite avant darriver lextrmit de la rue.
devra demander lutilisateur sil souhaite ajouter un autre voisin ou sil sarrte l. Penser bien respecter les
conditions dcrivant un voisin (et penser surtout grer les extrmits de rue). Conseil : Penser utiliser les algorithme distanceDroite
algorithmes de la section 2 comme fonctions de saisies. entres
v : Voisin
algorithme population donnes
donnees voisinCourant : Voisin
courant : Voisin nbVoisins : entier
encore : boolen dbut
dbut voisinCourant = v
courant nouveau Voisin tantque voisinCourant.droite null faire
courant.pers lirePersonne() nbVoisins = nbVoisins + 1
courant.droite null voisinCourant = voisinCourant.droite
ecrire(Saisir un autre voisin ?) fintq
encore lire() fin
tantque encore = vrai faire
courant.gauche nouveau Voisin
courant.gauche.pers lirePersonne() Exercice 3.5 : Ecrire un algorithme recensement qui prend en paramtre une variable de type Voisin et qui
courant.gauche.droite courant retourne le nombre total de voisins prsents dans la rue.
courant courant.gauche
ecrire(Saisir un autre voisin ?) algorithme recensement
encore lire() entres
fintq v : Voisin
donnes
courant.gauche null nbVoisins : entier
fin dbut
nbVoisins = distanceGauche(v)
nbVoisins = nbVoisins + distanceDroite(v)
Exercice 3.3 : Ecrire un algorithme distanceGauche qui prend en entre une variable de type Voisin et qui nbVoisins = nbVoisins + 1
compte le nombre de voisin sa gauche avant darriver lextrmit de la rue. fin

algorithme distanceGauche
entres Exercice 3.6 : Ecrire un algorithme insrerGauche qui prend en entre une variable de type Voisin et qui demande
v : Voisin lutilisateur de saisir un nouveau voisin avant de linsrer la gauche du voisin donn en entre. Conseil : Bien
donnes faire attention mettre jour tout ce qui est ncessaire dans le voisinage.
voisinCourant : Voisin
nbVoisins : entier algorithme insrerGauche
dbut entres
voisinCourant = v v : Voisin
tantque voisinCourant.gauche null faire donnes
nbVoisins = nbVoisins + 1 personne : Personne
voisinCourant = voisinCourant.gauche voisin : Voisin
fintq dbut
fin personne lirePersonne()
voisin nouveau Voisin
voisin.pers personne
voisin.droite v
voisin.gauche v.gauche
v.gauche voisin
fin
Exercice 3.7 : Ecrire un algorithme supprimerVoisin qui prend en entre une variable de type Voisin et qui le retire
du voisinage. On suppose que le voisin donn fait bien partie du voisinage. Conseil : Bien faire attention mettre
jour tout ce qui est ncessaire dans le voisinage.

algorithme supprimerVoisin
entres
v : Voisin
dbut
si v.gauche null alors
v.gauche.droite = v.droite
finsi
si v.droite null alors
v.droite.gauche = v.gauche
finsi
fin