Algorithmique-Programmation Orientée Objet Semestre 2 ST - Les types agrégés - Exercices PDL

Algorithmique & Programmation Orientée Objet
Semestre 2 ST
Les types agrégés

Cours

Tous les exercices sont à réaliser en langage algorithmique.

Exercice n°1

Pour une fédération sportive, on souhaite développer un programme de gestion des licences.
Concevoir un type agrégé "licence" de stockage des informations relatives à un licencié:
- nom,
- prénom,
- numéro de licence,
- club,
- vétéran ou non.

TypeLicence.lda

{ Type agrege de stockage des informations     }
{ relatives a un licencie sportif              }

structure licence
  chaine nom                <- ""
  chaine prenom             <- ""
  entier numeroLicence      <- 0
  chaine club               <- ""
  caractere categorieAge    <- ' '
  booleen sexe              <- vrai
fin structure

Exercice n°2

a) Concevoir un type agrégé "position3D" de stockage d'une position définie dans un espace à trois dimensions réelles.

b) Concevoir un algorithme de lecture au clavier d'une variable de type position3D, puis d'affichage à l'écran de cette variable.

LectureEcriturePosition3D.lda

{ Type agrege de stockage des informations     }
{ relatives a une position en trois dimensions }

structure position3D
  reel x <- 0.0
  reel y <- 0.0
  reel z <- 0.0
fin structure

action principale()
  position3D pos
  pos.x <- saisir()
  pos.y <- saisir()
  pos.z <- saisir()
  afficher("(",pos.x,",",pos.y,",",pos.z,")")
fin action

Exemple d'exécution

Exercice n°3

a) Concevoir un type agrégé "temps" de stockage d'une heure représentée par un nombre d'heures, de minutes et de secondes.

b) Concevoir un algorithme réalisant les traitements suivants:
- Lecture au clavier de deux variables de type temps.
- Affichage de l'heure la plus tardive parmis les deux, puis affichage de l'autre heure.
- Affichage du nombre de secondes entre les deux.

Pour comparer deux temps, on pourra les convertir en secondes et effectuer la comparaison sur les nombres de secondes obtenus.

ManipulationTemps.lda

{ Type agrege de stockage des informations     }
{ relatives a un temps code sous la forme      }
{ heure, minute, seconde                       }

structure temps
  entier h <- 0
  entier mn <- 0
  entiers <- 0
fin structure

{ Programme principal                          }

action principale()
  temps t1
  temps t2
  booleen inferieurEgalT1T2
  entier difference
  entier s1
  entier s2
  afficherln("SVP, t1 (h, mn & s)?")
  t1.h <- saisir()
  t1.mn <- saisir()
  t1.s <- saisir()
  afficherln("SVP, t2 (h, mn & s)?")
  t2.h <- saisir()
  t2.mn <- saisir()
  t2.s <- saisir()
  s1 <- 3600*t1.h+60*t1.mn+t1.s
  s2 <- 3600*t2.h+60*t2.mn+t2.s
  inferieurEgalT1T2 <- (s1 <= s2)
  si inferieurEgalT1T2 == vrai alors
    difference <- s2-s1
    afficherln("[",t2.h,":",t2.mn,":",t2.s,"]")
    afficherln("[",t1.h,":",t1.mn,":",t1.s,"]")
    sinon
    difference <- s1-s2
    afficherln("[",t1.h,":",t1.mn,":",t1.s,"]")
    afficherln("[",t2.h,":",t2.mn,":",t2.s,"]")
  fsi
  afficherln("Ecart : ",difference," secondes")
fin action

Exemple d'exécution

Exercice n°4

a) Concevoir un type agrégé "couleur" de stockage d'une couleur représentée par une valeur de rouge, une valeur de vert et une valeur de bleu. Ces trois valeurs sont de type entier. Usuellement en informatique, elles sont comprises entre 0 et 255 (8 bits).
Exemples: (255,255,255) -> blanc, (0,0,0) -> noir, (255,0,0) -> rouge, (255,255,0) -> jaune

b) Concevoir un algorithme réalisant les traitements suivants:
- Lecture au clavier d'une variable de type couleur.
- Lecture au clavier d'un pourcentage d'assombrissement.
- Calcul et affichage de cette couleur après assombrissement de la valeur lue.
- Lecture au clavier d'un pourcentage d'éclaircissement.
- Calcul et affichage de cette couleur après éclaircissement de la valeur lue.

Pour assombrir une composante de couleur de n %, on poura la multiplier par (1.0-n/100.0).
Pour éclaircir une composante de couleur c de n %, on pourra lui appliquer la formule f(c) = 255.0-((255.0-c)*(1.0-n/100.0)).

ManipulationCouleurs.lda

{ Type agrege de stockage des informations     }
{ relatives a une couleur RVB                  }

structure couleur
  entier r <- 0
  entier v <- 0
  entier b <- 0
fin structure

{ Programme principal                          }

action principale()
  couleur c
  reel assombrissement
  couleur ca
  reel eclaircissement
  couleur ce
  reel fa
  reel fe
  afficherln("SVP, r, v & b?")
  c.r <- saisir()
  c.v <- saisir()
  c.b <- saisir()
  afficherln("SVP, assombrissement?")
  assombrissement <- saisir()
  afficherln("SVP, eclaircissement?")
  eclaircissement <- saisir()
  fa <- 1.0-assombrissement/100.0
  ca.r <- round(fa*c.r)
  ca.v <- round(fa*c.v)
  ca.b <- round(fa*c.b)
  fe <- 1.0-eclaircissement/100.0
  ce.r <- 255-round(fe*(255-c.r))
  ce.v <- 255-round(fe*(255-c.v))
  ce.b <- 255-round(fe*(255-c.b))
  afficherln("[",c.r,":",c.v,":",c.b,"]")
  afficherln("[",ca.r,":",ca.v,":",ca.b,"]")
  afficherln("[",ce.r,":",ce.v,":",ce.b,"]")
fin action

Exemple d'exécution

Exercice n°5

a) Concevoir un type agrégé "position2D" de stockage d'une position définie dans un espace à deux dimensions réelles.

b) Concevoir un type agrégé "triangle2D" de stockage d'un triangle de 3 position2D.

c) Concevoir un algorithme réalisant les traitements suivants:
- Lecture au clavier d'un triangle2D.
- Calcul et affichage de la surface de ce triangle2D.

Pour calculer la surface d'un triangle défini par les 3 sommets (x1,y1), (x2,y2) et (x3,y3), on pourra utiliser la formule suivante:
surface = abs((x1+x2)*(y1-y2)+(x2+x3)*(y2-y3)+(x3+x1)*(y3-y1))/2.0

ManipulationTriangle2D.lda

{ Type agrege de stockage des informations     }
{ relatives a une position en deux dimensions  }

structure position2D
  reel x <- 0.0
  reel y <- 0.0
fin structure

{ Type agrege de stockage des informations     }
{ relatives a un triangle en deux dimensions   }

structure triangle2D
  position2D p0
  position2D p1
  position2D p2
fin structure

{ Programme principal                          }

action principale()
  triangle2D t
  reel surface
  afficherln("SVP, x & y du sommet 1?")
  t.p0.x <- saisir()
  t.p0.y <- saisir()
  afficherln("SVP, x & y du sommet 2?")
  t.p1.x <- saisir()
  t.p1.y <- saisir()
  afficherln("SVP, x & y du sommet 3?")
  t.p2.x <- saisir()
  t.p2.y <- saisir()
  surface <- (t.p0.x-t.p1.x)*(t.p0.y+t.p1.y)+
             (t.p1.x-t.p2.x)*(t.p1.y+t.p2.y)+
             (t.p2.x-t.p0.x)*(t.p2.y+t.p0.y)
  surface <- abs(surface)/2.0
  afficherln("Surface: ",surface)
fin action

Exemple d'exécution

Exercice n°6

a) Concevoir un type agrégé "parallelepipede" de stockage des caractéristiques d'un parallélépipède rectangle à faces perpendiculaires aux axes.

b) Concevoir un algorithme réalisant les traitements suivants:
- Lecture d'un parallelepipede.
- Calcul et affichage du volume de ce parallelepipede.

Le volume d'un parallelepipede est égal au produit de la longueur de ses cotés.

Plusieurs solutions sont possibles. Il est intéressant de choisir la plus pratique vis à vis des traitements qui seront réalisés.

ManipulationCube.lda

{ Type agrege de stockage des informations      }
{ relatives a une position en trois dimensions  }

structure position3D
  reel x <- 0.0
  reel y <- 0.0
  reel z <- 0.0
fin structure

{ Type agrege de stockage des informations      }
{ relatives a un parallelepipede rectangle      }
{ a faces orthogonales aux axes                 }
{ min: sommet ou les x, y et z sont minimum     }
{ max: sommet ou les x, y et z sont maximum     }

structure parallelepipede
  position3D min
  position3D max
fin structure

{ Type agrege de stockage des informations      }
{ relatives a un parallelepipede rectangle      }
{ a faces orthogonales aux axes                 }
{ centre: position du centre du parallelepipede }
{ largeur, hauteur et profondeur:               }
{ longueurs des cotes selon les axes x, y, et z }

structure parallelepipede2
  position3D centre
  reel largeur <- 0.0
  reel hauteur <- 0.0
  reel profondeur <- 0.0
fin structure

{ Type agrege de stockage des informations      }
{ relatives a un parallelepipede rectangle      }
{ a faces orthogonales aux axes                 }
{ min: sommet ou les x, y et z sont minimum     }
{ largeur, hauteur et profondeur:               }
{ longueurs des cotes selon les axes x, y, et z }

structure parallelepipede3
  position3D min
  reel largeur <- 0.0
  reel hauteur <- 0.0
  reel profondeur <- 0.0
fin structure

{ Type agrege de stockage des informations     }
{ relatives a un parallelepipede rectangle     }
{ a faces orthogonales aux axes                }
{ s1: un sommet quelconque du parallelepipede  }
{ s2: le sommet oppose de s1                   }

structure parallelepipede4
  position3D s1
  position3D s2
fin structure

{ Programme principal                          }

action principale()
  parallelepipede cb
  reel volume
  afficherln("SVP, x, y & z du sommet min?")
  cb.min.x <- saisir()
  cb.min.y <- saisir()
  cb.min.z <- saisir()
  afficherln("SVP, x, y & z du sommet max?")
  cb.max.x <- saisir()
  cb.max.y <- saisir()
  cb.max.z <- saisir()
  volume <- (cb.max.x-cb.min.x)*
            (cb.max.y-cb.min.y)*
            (cb.max.z-cb.min.z)
  afficherln("Volume: ",volume)
fin action

Exemple d'exécution

Exercice n°7

a) Concevoir un type agrégé "date" de stockage d'une date représentée par un numéro de jour, un numéro de mois et un numéro d'année.

b) Concevoir un algorithme réalisant les traitements suivants:
- Lecture d'une date.
- Calcul de la date du lendemain.
- Affichage de cette date.

Etablir la date du lendemain à partir d'une date quelconque nécessite une analyse pour savoir si le jour est le dernier du mois au quel cas, il faudra passer au premier du mois suivant. Le passage au mois suivant peut lui-même entraîner le passage à l'année suivante.
Etablir le nombre de jours d'un mois est un traitement relativement complexe car ce nombre est égal à 31 pour les mois de janvier, mars, mai, juillet, aout, octobre et décembre, à 30 pour les mois d'avril, juin, septembre et novembre, à 28 pour le mois de février des années non bissextiles et à 29 pour le mois de février des années bissextiles.
Une année n'est pas bissextile si son numéro n'est pas divisible par 4. Si son numéro est divisible par 4, une année est bissextile. Cette règle admet comme exceptions les années dont le numéro est divisible par 100 (qui ne sont donc pas bissextiles). Cette règle admet elle-même comme exceptions les années dont le numéro est divisible par 400 (qui sont donc bissextiles).
Exemples: 1983 n'est pas bissextile, 1980 est bissextile, 2100 n'est pas bissextile, 2000 est bissextile.

ManipulationDates.lda

{ Type agrege de stockage des informations     }
{ relatives a une date codee sous la forme     }
{ jour, mois, annee                            }

structure date
  entier j <- 1
  entier m <- 1
  entier a <- 1901
fin structure

{ Programme principal                          }

action principale()
  date dt
  entier nbJours
  afficherln("SVP, j, m & a?")
  dt.j <- saisir()
  dt.m <- saisir()
  dt.a <- saisir()
  dans le cas de dt.m
    2 :
      si ( (dt.a modulo 400) == 0 ) ou
         ( ( (dt.a modulo 4) == 0 ) et
           ( (dt.a modulo 100) <> 0 ) ) alors
        nbJours <- 29
        sinon
        nbJours <- 28
      fsi
    4  :
    6  :
    9  :
    11 :
      nbJours <- 30
    autres cas :
      nbJours <- 31
  fcas
  dt.j <- dt.j+1
  si dt.j > nbJours alors
    dt.j <- 1
    dt.m <- dt.m+1
    si dt.m > 12 alors
      dt.m <- 1
      dt.a <- dt.a+1
    fsi
  fsi
  afficherln(dt.j,"/",dt.m,"/",dt.a)
fin action

Exemple d'exécution

Exercice n°8

a) Concevoir un type agrégé quadrilatère (polygone à 4 sommets) en trois dimensions.

b) Concevoir un algorithme réalisant les traitements suivants:
- Lecture au clavier d'un quadrilatère
- Calcul puis affichage du périmètre de ce quadrilatère

ManipulationQuadrilatere.lda

{ Manipulations sur une classe quadrlatere   }

{ Type agrege de stockage des informations   }
{ relatives a une position en 3 dimensions   }

structure position3D
  reel x <- 0.0
  reel y <- 0.0
  reel z <- 0.0
fin structure

{ Type agrege de stockage des informations   }
{ relatives a un quadrilatere en 3D          }

structure quadrilatere3D
  position3D p1
  position3D p2
  position3D p3
  position3D p4
fin structure

{ Programme principal                        }

action principale()
  reel perimetre
  quadrilatere3D q
  perimetre <- 0.0
  afficherln("SVP, les coordonnees du quadrilatere")
  afficherln("Sommet 1")
  q.p1.x <- saisir()
  q.p1.y <- saisir()
  q.p1.z <- saisir()
  afficherln("Sommet 2")
  q.p2.x <- saisir()
  q.p2.y <- saisir()
  q.p2.z <- saisir()
  afficherln("Sommet 3")
  q.p3.x <- saisir()
  q.p3.y <- saisir()
  q.p3.z <- saisir()
  afficherln("Sommet 4")
  q.p4.x <- saisir()
  q.p4.y <- saisir()
  q.p4.z <- saisir()
  perimetre <- perimetre + sqrt(pow(q.p1.x-q.p2.x,2.0)+
                                pow(q.p1.y-q.p2.y,2.0)+
                                pow(q.p1.z-q.p2.z,2.0))
  perimetre <- perimetre + sqrt(pow(q.p2.x-q.p3.x,2.0)+
                                pow(q.p2.y-q.p3.y,2.0)+
                                pow(q.p2.z-q.p3.z,2.0))
  perimetre <- perimetre + sqrt(pow(q.p3.x-q.p4.x,2.0)+
                                pow(q.p3.y-q.p4.y,2.0)+
                                pow(q.p3.z-q.p4.z,2.0))
  perimetre <- perimetre + sqrt(pow(q.p4.x-q.p1.x,2.0)+
                                pow(q.p4.y-q.p1.y,2.0)+
                                pow(q.p4.z-q.p1.z,2.0))
  afficherln("Perimetre : ",perimetre)
fin action

Exemple d'exécution

Exercice n°9

a) Concevoir un type agrégé "temps" de stockage d'une heure représentée par un nombre d'heures, de minutes et de secondes.

b) Concevoir un algorithme réalisant les traitements suivants:
- Lecture au clavier d'un temps t
- Lecture au clavier d'un nombre de secondes nbs
- Modification du temps t par incrémentation de nbs secondes
- Affichage écran de t

IncrementationTemps.lda

{ Type agrege de stockage des informations     }
{ relatives a un temps code sous la forme      }
{ heure, minute, seconde                       }

structure temps
  entier h <- 0
  entier mn <- 0
  entier s  <- 0
fin structure

{ Programme principal                          }

action principale()
  temps t
  entier nbs
  afficherln("SVP, t (h, mn & s)?")
  t.h <- saisir()
  t.mn <- saisir()
  t.s <- saisir()
  afficherln("SVP, increment?")
  nbs <- saisir()
  si nbs >= 0 alors
    t.s <- t.s+nbs
    sinon
    t.s <- t.s+nbs+86400*(-nbs/86400)+86400
  fsi
  si t.s >= 60 alors
    t.mn <- t.mn+(t.s/60)
    t.s <- t.s modulo 60
    si t.mn >= 60 alors
      t.h <- (t.h+(t.mn/60))%24
      t.mn <- t.mn modulo 60
    fsi
  fsi
  afficherln("[",t.h,":",t.mn,":",t.s,"]")
fin action

Exemple d'exécution

Exercice n°10

a) Concevoir un type agrégé "localisation géographique" avec nombres de degrés en entier, de minutes en entier et de secondes en réel.
Exemple: Horloge astronomique de la cathédrale de Besançon: Longitude 6°01'49.08", latitude 47°14'00.96"

b) Concevoir un algorithme permettant de convertir une localisation géographique en un nombre de degrés en réel (lecture au clavier de la localisation géographique, conversion et affichage du résultat de conversion). Concevoir un algorithme permettant de convertir un nombre de degrés en réel en une localisation géographique (lecture au clavier du nombre de degrés réel, conversion et affichage de la localisation géographique).

c) Concevoir un type agrégé "localisation GPS" avec longitude et latitude.

d) Concevoir un algorithme de calcul de la distance "à vol d'oiseau" existant entre deux localisations GPS définies à l'altitude 0.0.
Le rayon terrestre est de 6378.137 km. La formule de calcul est la suivante:
    dlo = (lo2-lo1)/2.0;
    dla = (la2-la1)/2.0;
    a = sin(dla)² + cos(la1)*cos(la2)*sin(dlo)²;
    d = 2.0*atan2(sqrt(a), sqrt(1.0-a))*rayonTerrestre;
Où lo1, lo2, la1 et la2 sont les longitudes et latitudes en réel des localisations GPS.

ManipulationCoordonneesGPS.lda

{ Manipulations sur une classe               }
{ coordonnees GPS                            }

{ Type agrege de stockage des informations   }
{ relatives a une localisation codee         }
{ sous la forme degres, minutes, secondes    }

structure localisation
  entier d <- 0
  entier mn <- 0
  reel s <- 0.0
fin structure

{ Type agrege de stockage des informations   }
{ relatives a une localisation GPS           }

structure localisationGPS
  localisation lon
  localisation lat
fin structure

{ Programme principal                        }

action principale()
  constante reel PI <- 3.14159
  localisationGPS l1
  localisationGPS l2
  reel lo1
  reel lo2
  reel la1
  reel la2
  reel dlo
  reel dla
  reel a
  reel distance
  { Lecture clavier des 2 coordonnees GPS    }
  afficherln("SVP, P1?")
  afficherln("Longitude :")
  l1.lon.d <- saisir()
  l1.lon.mn <- saisir()
  l1.lon.s <- saisir()
  afficherln("Latitude :")
  l1.lat.d <- saisir()
  l1.lat.mn <- saisir()
  l1.lat.s <- saisir()
  afficherln("SVP, P2?")
  afficherln("Longitude :")
  l2.lon.d <- saisir()
  l2.lon.mn <- saisir()
  l2.lon.s <- saisir()
  afficherln("Latitude :")
  l2.lat.d <- saisir()
  l2.lat.mn <- saisir()
  l2.lat.s <- saisir()
  { Conversion en valeurs reelles            }
  { des longitudes et latitudes              }
  lo1 <- l1.lon.d+((l1.lon.s/60.0)+l1.lon.mn)/60.0
  lo2 <- l2.lon.d+((l2.lon.s/60.0)+l2.lon.mn)/60.0
  la1 <- l1.lat.d+((l1.lat.s/60.0)+l1.lat.mn)/60.0
  la2 <- l2.lat.d+((l2.lat.s/60.0)+l2.lat.mn)/60.0
  { Conversion en radians des valeurs        }
  { en degres                                }
  lo1 <- lo1*PI/180.0
  lo2 <- lo2*PI/180.0
  la1 <- la1*PI/180.0
  la2 <- la2*PI/180.0
  { Calcul de la distance en kilometres      }
  dlo <- (lo2-lo1)/2.0
  dla <- (la2-la1)/2.0
  a <- (sin(dla)*sin(dla))+cos(la1)*cos(la2)*(sin(dlo)*sin(dlo))
  distance <- 2.0 * atan2(sqrt(a),sqrt(1.0-a)) * 6378.137
  { Affichage final                          }
  afficherln("Distance : ",distance," km")
fin action

Exemple d'exécution