Partie A : Syntaxe d’algorithme (5 points)

A.1 Définitions :

Algorithmique : Science de l’organisation des séquences d’instructions pour résoudre un problème;
Procédure : Un bloc d’instructions nommé qui exécute une tâche spécifique sans obligatoirement renvoyer une valeur au programme principal;
Tableau : Structure de données permettant de stocker plusieurs valeurs de même type dans une seule variable indexée;
Enregistrement : Type de donnée personnalisé qui regroupe plusieurs informations (champs) de types différents sous un seul nom;

A.2 Syntaxe TantQue : TantQue <condition> Faire; <instructions>; FinTantQue;

A.3 Syntaxe Si : Si <condition> Alors; <instructions>; Sinon; <instructions>; FinSi;

Partie B : Écriture d’algorithmes (7 points)

B1. Algorithme des mentions

Algorithme Calcul_Mention;
Variables
    note : Réel;
Début
    Ecrire("Veuillez saisir la note : ");
    Lire(note);
    Si (note < 0 OU note > 20) Alors;
        Ecrire("Erreur : La note doit être entre 0 et 20;");
    SinonSi (note < 10) Alors;
        Ecrire("Mention : Insuffisant;");
    SinonSi (note < 12) Alors;
        Ecrire("Mention : Passable;");
    SinonSi (note < 14) Alors;
        Ecrire("Mention : Assez bien;");
    SinonSi (note < 16) Alors;
        Ecrire("Mention : Bien;");
    Sinon;
        Ecrire("Mention : Très bien;");
    FinSi;
Fin.

Explication : Cet algorithme utilise une structure conditionnelle imbriquée (Si...SinonSi). On vérifie d’abord si la note est valide (entre 0 et 20). Ensuite, on teste les paliers du plus petit au plus grand. Dès qu’une condition est vraie, l’algorithme affiche la mention et s’arrête.

B2. Algorithme de contrôle de saisie (Boucle Jusqu’à)

Algorithme Saisie_1_3;
Variables
    n : Entier;
Début
    Répéter;
        Ecrire("Entrez un nombre compris entre 1 et 3 : ");
        Lire(n);
        Si (n < 1 OU n > 3) Alors;
            Ecrire("Réponse incorrecte, recommencez;");
        FinSi;
    Jusqu'à (n >= 1 ET n <= 3);
    Ecrire("Merci, vous avez saisi : ", n);
Fin.

Explication : On utilise ici une boucle Répéter...Jusqu'à. Elle garantit que l’utilisateur saisira au moins une fois un nombre. La boucle tourne “tant que” la réponse ne convient pas (donc elle s’arrête “jusqu’à” ce que le nombre soit 1, 2 ou 3).

B3. Recherche des occurrences dans un tableau

Algorithme Chercher_Occurrences;
Variables
    T : Tableau[1..50] d'Entiers;
    valeur, i, taille : Entier;
Début
    Ecrire("Entrez le nombre d'éléments du tableau : ");
    Lire(taille);
    Ecrire("Entrez la valeur à rechercher : ");
    Lire(valeur);
    Pour i de 1 à taille Faire;
        Si (T[i] = valeur) Alors;
            Ecrire("Valeur trouvée à l'indice : ", i);
        FinSi;
    FinPour;
Fin.

Explication : Pour trouver toutes les occurrences, on doit obligatoirement parcourir le tableau du début à la fin avec une boucle Pour. Si l’élément à l’indice i (T[i]) correspond à la valeur cherchée, on affiche sa position.

Partie C : Structures de données avancées (8 points)

C.1 & C.2 Déclaration des types Enregistrements

Type Activite = Enregistrement;
    type_activite : Chaîne; // "fonctionnaire", "salarié privé", "libérale"
    revenu_annuel : Réel;
FinEnregistrement;

Type Actif = Enregistrement;
    diplome : Chaîne;
    anciennete : Entier; // durée sur le marché du travail
    infos : Activite; // On utilise l'enregistrement Activite ici
FinEnregistrement;

Explication : Ici, on définit des types “sur mesure”. Actif est un enregistrement complexe car l’un de ses champs (infos) est lui-même un enregistrement (Activite). C’est ce qu’on appelle l’imbrication.

C.3 Fonction Compter Fonctionnaires

Fonction Compter_Anciens_Fonctionnaires(T : Tableau d'Actifs, n : Entier, nb_elem : Entier) : Entier;
Variables
    i, compteur : Entier;
Début
    compteur <- 0;
    Pour i de 1 à nb_elem Faire;
        // Accès imbriqué : T[i] (l'actif) -> infos (son activité) -> type_activite
        Si (T[i].infos.type_activite = "fonctionnaire" ET T[i].anciennete > n) Alors;
            compteur <- compteur + 1;
        FinSi;
    FinPour;
    Retourner compteur;
Fin;

Explication : Cette fonction parcourt un tableau de structures. Pour accéder au type d’activité d’un actif, on utilise le point (.) successivement. On vérifie deux critères simultanément avec l’opérateur ET.

C.4 Fonction Majorité Fonctionnaire

Fonction Est_Majorite_Fonctionnaire(T : Tableau d'Actifs, diplome_recherche : Chaîne, nb_elem : Entier) : Booleen;
Variables
    i, f, nf : Entier;
Début
    f <- 0; // Compteur fonctionnaires
    nf <- 0; // Compteur non-fonctionnaires
    Pour i de 1 à nb_elem Faire;
        Si (T[i].diplome = diplome_recherche) Alors;
            Si (T[i].infos.type_activite = "fonctionnaire") Alors;
                f <- f + 1;
            Sinon;
                nf <- nf + 1;
            FinSi;
        FinSi;
    FinPour;
    Retourner (f > nf); // Renvoie Vrai si f > nf, sinon Faux
Fin;

Explication : On utilise deux compteurs. On filtre d’abord par diplôme. Ensuite, on sépare les fonctionnaires des autres (secteur concurrentiel). Enfin, on compare les deux totaux pour renvoyer un résultat de type Booleen.

Guide de l’Expert : Tableaux et Enregistrements

1. Le Tableau (Structure Homogène)

Déclaration : On définit le nom, l’intervalle des indices et le type.
- Exemple : Variable T : Tableau[1..10] d'Entiers;
Utilisation : On utilise l’indice entre crochets pour lire ou écrire.
- Ecriture : T[5] <- 20; (met 20 dans la 5ème case).
- Lecture : Si (T[i] > 10)...

2. L’Enregistrement (Structure Hétérogène)

Déclaration : Se fait généralement dans une section Type avant les variables.

Type Etudiant = Enregistrement;
    nom : Chaîne;
    age : Entier;
FinEnregistrement;

Utilisation : On déclare une variable de ce nouveau type : Variable e1 : Etudiant;
Accès aux champs : On utilise l’opérateur point (.).
- Exemple : e1.nom <- "Jean"; ou Lire(e1.age);

3. Tableau d’Enregistrements (Le plus puissant)

C’est ce qui est utilisé dans la Partie C. Chaque case du tableau contient un enregistrement complet.

Accès : Tableau[indice].Champ
Exemple : T[i].diplome accède au diplôme de la personne située à la position i.
Imbrication : Si un champ est lui-même un enregistrement : T[i].infos.revenu_annuel. On part du général (le tableau) pour aller vers le très précis (le champ de l’enregistrement imbriqué).