## **PARTIE 1 : MODELISATION STRUCTUREE « MERISE » (25 points)**
### 1. Réaliser le MCC (Modèle Conceptuel de Données) (5 points)
Le MCC est une représentation abstraite des données de la bibliothèque.
Voici les entités et leurs relations :
- **Entités :**
- Exemplaire (CodeExemplaire, DateAcquisition, DureeVieEstimee)
- Ouvrage (CodeOuvrage, Auteur, Titre, ValeurRemplacement, Resume,
MotsCles)
- Emprunteur (CodeEmprunteur, Nom, Prenom, Adresse, Email)
- Pret (CodePret, CodeExemplaire, CodeEmprunteur, DateRetourPrevu)
- **Relations :**
- Un **Exemplaire** est lié à un **Ouvrage** (1:1).
- Un **Pret** est lié à un **Exemplaire** et un **Emprunteur** (1:1 pour
chaque relation).
- Un **Emprunteur** peut emprunter jusqu'à 3 **Exemplaires** (1:N).
### 2. Réaliser le MCD (Modèle Conceptuel de Données) (8 points)
Le MCD est une représentation graphique des entités et de leurs relations.
Voici une description textuelle (vous pouvez le dessiner pour une meilleure
visualisation) :
- **Exemplaire** (CodeExemplaire, DateAcquisition, DureeVieEstimee,
CodeOuvrage)
- **Ouvrage** (CodeOuvrage, Auteur, Titre, ValeurRemplacement, Resume,
MotsCles)
- **Emprunteur** (CodeEmprunteur, Nom, Prenom, Adresse, Email)
- **Pret** (CodePret, CodeExemplaire, CodeEmprunteur, DateRetourPrevu)
- **Relations :**
- **Exemplaire** → **Ouvrage** (1:1)
- **Pret** → **Exemplaire** (1:1)
- **Pret** → **Emprunteur** (1:1)
- **Emprunteur** → **Pret** (1:N)
### 3. Réaliser le MCT pour Inscription, Prêt et Retour (12 points)
Le MCT (Modèle Conceptuel de Traitements) décrit les traitements associés
aux opérations de la bibliothèque.
#### a. Inscription (4 points)
- **Entrées :** Nom, Prénom, Adresse, Email
- **Sorties :** CodeEmprunteur
- **Traitement :** Enregistrer les informations de l'emprunteur dans la
base de données et générer un CodeEmprunteur unique.
#### b. Prêt (4 points)
- **Entrées :** CodeExemplaire, CodeEmprunteur
- **Sorties :** DateRetourPrevu
- **Traitement :**
1. Vérifier que l'emprunteur n'a pas déjà 3 exemplaires empruntés.
2. Calculer la DateRetourPrevu (DateEmprunt + 3 semaines).
3. Enregistrer le prêt dans la base de données.
#### c. Retour (4 points)
- **Entrées :** CodeExemplaire
- **Sorties :** Confirmation de retour
- **Traitement :**
1. Vérifier l'état de l'exemplaire.
2. Si l'exemplaire est en bon état, supprimer l'enregistrement du prêt.
3. Si l'exemplaire est perdu, envoyer un courrier à l'emprunteur pour
demander le paiement de la valeur de remplacement.
---
## **PARTIE II : MODELISATION ORIENTEE OBJET « UML » (25 points)**
### 1. Réaliser le Diagramme de classe (8 points)
Les classes principales sont :
- **OuvrierAgricole** (id, nom, prenom, tempsTravail)
- **OperationCulturale** (id, typeOperation, description)
- **OperationPhytosanitaire** (id, operationCulturale, maladiesVisees,
stadePhenologique, methodeTraitement, observation)
- **ChefExploitation** (id, nom, prenom)
- **Chercheur** (id, nom, prenom)
- **Exploitation** (id, nom, chefExploitation)
Les relations :
- **OuvrierAgricole** → **OperationCulturale** (1:N)
- **OperationPhytosanitaire** → **OperationCulturale** (1:1)
- **ChefExploitation** → **Exploitation** (1:1)
- **Chercheur** → **Exploitation** (1:N)
### 2. Réaliser le diagramme de cas d'utilisation (8 points)
Les cas d'utilisation principaux sont :
- **Saisir temps de travail** (OuvrierAgricole)
- **Valider saisie mensuelle** (ChefExploitation)
- **Notifier validation** (Chercheur)
- **Imprimer état des travaux** (ChefExploitation)
- **Analyser données annuelles** (Chercheur)
### 3. Réaliser le diagramme de séquence (9 points)
Pour le cas d'utilisation "Valider saisie mensuelle" :
1. Le **ChefExploitation** vérifie les temps de travail saisis par les
ouvriers.
2. Il corrige les erreurs éventuelles.
3. Il saisit les opérations du mois dans l'application.
4. Le **Chercheur** reçoit une notification par email.
5. Le **Chercheur** valide les données.
6. Le **ChefExploitation** imprime les états mensuels.
---
## **PARTIE 3 : ALGORITHMIQUE ET STRUCTURE DE DONNEES (20
points)**
### A. Écriture d'algorithmes (9 points)
#### 1. Détermination du prix à payer (4 points)
```pseudo
Fonction prixapayer(qte : entier, pu : reel) : reel
tot = qte * pu
Si tot > 500 Alors
port = 0
Sinon
port = 0.02 * tot
FinSi
Si tot >= 200 et tot <= 1000 Alors
rem = 0.05 * tot
SinonSi tot > 1000 Alors
rem = 0.1 * tot
Sinon
rem = 0
FinSi
pap = (tot + port) - rem
Retourner pap
FinFonction
```
#### 2. Calcul de la factorielle (2 points)
```pseudo
Fonction facto(n : entier) : entier
Si n < 0 Alors
Afficher "Erreur : nombre négatif"
Retourner 0
FinSi
resultat = 1
Pour i de 1 à n Faire
resultat = resultat * i
FinPour
Retourner resultat
FinFonction
```
#### 3. Détermination de la note maximale et minimale (3 points)
```pseudo
Procedure maximini(tab : reel, n : entier)
max = tab[0]
min = tab[0]
somme = 0
produit = 1
Pour i de 0 à n-1 Faire
Si tab[i] > max Alors
max = tab[i]
FinSi
Si tab[i] < min Alors
min = tab[i]
FinSi
somme = somme + tab[i]
produit = produit * tab[i]
FinPour
moyenne = somme / n
Afficher "Max : ", max
Afficher "Min : ", min
Afficher "Somme : ", somme
Afficher "Produit : ", produit
Afficher "Moyenne : ", moyenne
FinProcedure
```
### B. Structures de données avancées (11 points)
#### 1. Insertion en queue de liste chaînée (3 points)
```pseudo
Procedure insererEnQueue(liste : listeChainee, element : entier)
nouveauNoeud = CreerNoeud(element)
Si [Link] = NULL Alors
[Link] = nouveauNoeud
[Link] = nouveauNoeud
Sinon
[Link] = nouveauNoeud
[Link] = nouveauNoeud
FinSi
FinProcedure
```
#### 2. Insertion à une position donnée (5 points)
```pseudo
Procedure insererAPosition(liste : listeChainee, element : entier, position :
entier)
nouveauNoeud = CreerNoeud(element)
Si position = 1 Alors
[Link] = [Link]
[Link] = nouveauNoeud
Sinon
courant = [Link]
Pour i de 1 à position-2 Faire
courant = [Link]
FinPour
[Link] = [Link]
[Link] = nouveauNoeud
FinSi
FinProcedure
```
#### 3. Suppression à une position donnée (4 points)
```pseudo
Procedure supprimerAPosition(liste : listeChainee, position : entier)
Si position = 1 Alors
[Link] = [Link]
Sinon
courant = [Link]
Pour i de 1 à position-2 Faire
courant = [Link]
FinPour
[Link] = [Link]
FinSi
FinProcedure
```
---
## **PARTIE 4 : MANIPULATION DES DONNEES (10 points)**
### A. Questions de cours (4 points)
#### 1. SGBD (2.5 points)
- **Définition :** Un SGBD (Système de Gestion de Base de Données) est
un logiciel permettant de stocker, manipuler et gérer des données de
manière structurée.
- **Fonctions :**
- Création et gestion des bases de données.
- Insertion, mise à jour, suppression et recherche de données.
- Sécurité et gestion des accès.
- **Exemples :** MySQL, PostgreSQL.
#### 2. Formes normales (1.5 points)
- **1FN :** Chaque colonne contient des valeurs atomiques (indivisibles).
- **2FN :** Chaque colonne non-clé dépend de la clé primaire entière.
- **3FN :** Chaque colonne non-clé dépend uniquement de la clé primaire
(pas de dépendances transitives).
### B. Langage SQL (6 points)
#### 1. Vérification de la 3FN (1 point)
Les relations respectent la 3FN car :
- Chaque colonne non-clé dépend uniquement de la clé primaire.
- Il n'y a pas de dépendances transitives.
#### 2. Liste des clients par ordre alphabétique (1 point)
```sql
SELECT * FROM Client ORDER BY nom ASC;
```
#### 3. Liste des produits non commandés (2 points)
```sql
SELECT * FROM Produit
WHERE numproduit NOT IN (SELECT numproduit FROM Commander);
```
#### 4. Liste des clients et produits ayant fait l'objet d'une commande (2
points)
```sql
SELECT DISTINCT [Link], [Link], [Link], [Link],
[Link]
FROM Client c
JOIN Commander co ON [Link] = [Link]
JOIN Produit p ON [Link] = [Link];
```
---
## **PARTIE 5 : INGENIERIE DU LOGICIEL (20 points)**
### SECTION 1 : INITIATION AU GENIE LOGICIEL (10 points)
#### A. Langage de spécification Z (2.5 points)
1. **Syntaxe de déclaration d'une variable :**
```z
varName : Type
```
2. **Éléments de spécification :**
- Déclarations de variables.
- Préconditions et postconditions.
- Invariants.
- Schémas.
3. **Démarche de spécification :**
- Définir les exigences.
- Modéliser les données et les opérations.
- Vérifier les propriétés avec des preuves formelles.
4. **Traduction de l'entité PATIENT en Z :**
```z
PATIENT
------
Numero : ℕ
Nom : String
Prenom : String
Adresse : String
------
```
#### B. Concepts du génie logiciel (5 points)
1. **Cycle de vie :** Le cycle de vie d'un logiciel décrit les phases de
développement, de maintenance et de mise à jour d'un logiciel.
2. **Exemples de cycles de vie :**
- **Cycle en V :** Phases séquentielles avec validation à chaque étape.
- **Agile :** Développement itératif et incrémental.
3. **Test de logiciel :**
- **Boîte noire :** Test basé sur les spécifications sans connaissance du
code interne.
- **Boîte blanche :** Test basé sur le code interne et la structure du
logiciel.
### SECTION 2 : NEGOCIATION ET GESTION DE PROJETS INFORMATIQUES
(5 points)
#### A. Connaissances de cours (3 points)
1. **Définitions :**
- **Projet :** Ensemble d'activités planifiées pour atteindre un objectif.
- **Négociation informatique :** Processus de discussion pour définir les
termes d'un projet.
- **Appel d'offre :** Demande formelle de propositions pour un projet.
2. **Étapes du développement d'un logiciel :**
- Analyse des besoins.
- Conception.
- Développement.
- Test.
- Déploiement.
- Maintenance.
3. **Acteurs :**
- Chef de projet.
- Développeurs.
- Testeurs.
- Clients.
#### B. Étude de cas (5 points)
Pour évaluer le projet avec la méthode COCOMO 81 (type médian) :
1. **Estimer la taille du projet** (en KLOC).
2. **Appliquer la formule COCOMO :**
```
Effort (personnes-mois) = a * (KLOC)^b
```
- Pour un projet médian : \( a = 3.2 \), \( b = 1.05 \).
3. **Calculer le coût et la durée** en fonction de l'effort estimé.
