Aller au contenu

Un mot pour Fahmio

Tu écris. Tu continues.

Un problème, une idée — assez pour qu’on comprenne, puis tu retournes à ta copie.

On lit. Tu n’as rien d’autre à faire.

Où veux-tu aller ?

↑ ↓ pour parcourir · Entrée pour ouvrir · Échap pour fermer

Fahmio
Fahmio
Bac Tunisie
SD-IStructures de données et modularité

Problème modulaire : deux tableaux parallèles, cumul pondéré et affichage de tous les ex æquo

Idée directrice

Ce problème de traitement de tableaux parallèles : deux tableaux de même longueur liés par l'indice, l'un portant des libellés, l'autre un cumul chiffré. Trois décisions le caractérisent : contrôler chaque saisie, mettre à jour le second tableau à travers l'indice rendu par un module de recherche, puis afficher tous les ex æquo et non le premier trouvé. L'attendu de la première question n'est pas du code mais l'analyse modulaire avec ses tableaux de déclaration.

Ce qui aide à reconnaître la démarche

« Ecrire un algorithme du programme principal, solution à ce problème, en le décomposant en modules » ; « TS[i] est le total des points cumulés du joueur ayant pour nom TJ[i] » ; « d'afficher le score MVP de la saison, ainsi que le nom de chaque joueur ayant ce score » ; « composés uniquement de lettres alphabétiques et d'espaces »

Besoin d’un point de départ ? Voir la méthode
  • Écrire l'analyse du programme principal avant tout code : nom, appels, flux de résultats, dans l'ordre inverse de l'exécution comme le font les corrigés officiels.
  • Les types tableaux se déclarent dans le tableau des nouveaux types, les variables et les modules dans celui des objets globaux, avec leur rôle.
  • Deux tableaux parallèles se manipulent toujours par l'indice commun : chercher le libellé, garder l'indice, écrire dans l'autre tableau.
  • Chaque contrainte chiffrée de l'énoncé devient une boucle de contrôle de saisie ; le barème les compte une par une.
  • Un maximum à afficher avec ses ex æquo se traite en deux parcours : calcul du maximum, puis collecte de toutes les cases égales.
Les pièges à vérifier dans ta démarche

Si la consigne demande tous les projets de score maximal, afficher seulement le premier ne répond pas à la demande. Initialiser TC avant le dépouillement et contrôler que les titres existent et sont distincts pour un même votant. Fournir l’analyse et les tableaux de déclaration lorsque les questions les demandent.

Sujet principal

Problème — élection du projet primé par un jury

5 questionsCorrigé masqué

Problème (13 points) — dans l'esprit du problème de la session principale 2024

En fin d'année, un jury d'enseignants élit le meilleur projet parmi ceux soutenus par les élèves. Chaque enseignant classe trois projets par ordre de préférence : le premier choix rapporte 5 points, le deuxième 3 points, le troisième 1 point. Le projet totalisant le plus grand nombre de points est primé ; en cas d'égalité, tous les projets concernés le sont.

On veut écrire une solution algorithmique permettant :

  • de remplir un tableau TP par n titres de projets distincts, chaque titre étant une chaine de caracteres formée uniquement de lettres et d'espaces, avec 5 ≤ n ≤ 40 ;
  • de déterminer, dans un tableau TC, le cumul des points de chaque projet d'après les votes des m enseignants, avec 3 ≤ m ≤ 60, sachant que chaque enseignant doit citer trois titres distincts et présents dans TP, et que TC[i] est le cumul du projet dont le titre est TP[i] ;
  • d'afficher le score maximal, puis le titre de chaque projet ayant atteint ce score, au format : Score maximal : valeur puis Projet(s) primé(s) : titre1, titre2, ....

Exemple. Pour n = 5 et TP = ["Serre connectee", "Bras robotise", "Bus scolaire", "Tri des dechets", "Ruche numerique"], TC part de [0,0,0,0,0]. Après le vote d'un premier enseignant classant Bras robotise, Serre connectee, Ruche numerique, on obtient TC = [3,5,0,0,1]. Après un deuxième vote classant Serre connectee, Bras robotise, Bus scolaire, on obtient TC = [8,8,1,0,1]. L'affichage attendu est alors :

Score maximal : 8
Projet(s) prime(s) : Serre connectee, Bras robotise

Travail demandé :

  1. Analyser le problème en le décomposant en modules, et donner les tableaux de déclaration des nouveaux types et des objets globaux.
  2. Écrire l'algorithme du module de dépouillement des votes et celui du module d'affichage, avec leurs objets locaux.

N.B. On utilisera sans les développer les deux modules suivants : Alpha(ch), fonction booléenne vraie si la chaîne ch ne contient que des lettres et des espaces ; Rang(ch, T, k), fonction retournant l'indice de la case de T contenant ch parmi ses k premières cases, ou -1 si ch n'y figure pas.

Voir la correction commentéeAprès avoir posé votre démarche

1. Analyse du programme principal

Nom : Palmares
  Resultat = PROC Afficher(TP, TC, n)
  TC = PROC Depouiller(TP, TC, n, m)
  (TP, n) = PROC Remplir(TP, n)
Fin Palmares

La décomposition suit les trois demandes de l'énoncé : un module de saisie contrôlée, un module de dépouillement qui alimente TC, un module d'affichage qui ne dépend que des deux tableaux remplis. Aucun module ne recalcule ce qu'un autre a déjà produit.

TDNT

  • TabCh = Tableau [1..40] de chaine de caractères
  • TabEnt = Tableau [1..40] d'entiers

TDOG

  • TP — Type/Nature : TabCh — Rôle : contenant les titres des projets
  • TC — Type/Nature : TabEnt — Rôle : contenant le cumul des points de chaque projet
  • n — Type/Nature : entier — Rôle : le nombre de projets
  • m — Type/Nature : entier — Rôle : le nombre d'enseignants votants
  • Remplir — Type/Nature : procédure — Rôle : saisir n et les titres, chaque titre étant contrôlé et non déjà présent
  • Depouiller — Type/Nature : procédure — Rôle : lire les votes et cumuler les points dans TC
  • Afficher — Type/Nature : procédure — Rôle : afficher le score maximal puis tous les projets qui l'atteignent

2. Algorithme du module de dépouillement

DEF PROC Depouiller (TP : TabCh ; var TC : TabEnt ; n : entier ; var m : entier)
0) Pour i de 1 à n faire
     TC[i] ← 0
   FinPour
1) Répéter
     Ecrire("Nombre d'enseignants : ") ; Lire(m)
   Jusqu'à (m dans [3..60])
2) Pour j de 1 à m faire
     C[1] ← 0 ; C[2] ← 0
     Pour r de 1 à 3 faire
       Répéter
         Ecrire("Choix n° ", r, " de l'enseignant ", j, " : ") ; Lire(t)
         p ← Rang(t, TP, n)
       Jusqu'à (p ≠ -1) ET (p ≠ C[1]) ET (p ≠ C[2])
       C[r] ← p
       Si (r = 1) Alors TC[p] ← TC[p] + 5
       Sinon Si (r = 2) Alors TC[p] ← TC[p] + 3
             Sinon TC[p] ← TC[p] + 1
             FinSi
       FinSi
     FinPour
   FinPour
3) Fin Depouiller

TDOL de Depouiller : i, j, r, p entiers, p recevant l'indice rendu par Rang ; t chaîne, le titre saisi ; C tableau de 3 entiers, indices des projets déjà cités par l'enseignant en cours (remis à 0 à chaque enseignant ; un indice valant 0 ne correspond à aucun projet). La mise à jour passe toujours par p : c'est l'indice, et non le titre, qui relie TP à TC.

Algorithme du module d'affichage

DEF PROC Afficher (TP : TabCh ; TC : TabEnt ; n : entier)
1) max ← TC[1]
   Pour i de 2 à n faire
     Si (TC[i] > max) Alors max ← TC[i] FinSi
   FinPour
2) Ecrire("Score maximal : ", max)
   ch ← ""
   Pour i de 1 à n faire
     Si (TC[i] = max) Alors
       Si (ch = "") Alors ch ← TP[i]
       Sinon ch ← ch + ", " + TP[i]
       FinSi
     FinSi
   FinPour
3) Ecrire("Projet(s) prime(s) : ", ch)
4) Fin Afficher

TDOL de Afficher : i entier ; max entier, le plus grand cumul ; ch chaîne, la liste en construction. Deux parcours sont nécessaires et non un seul : tant que le maximum n'est pas connu, on ne peut pas savoir quels projets l'atteignent, et un affichage au fil du premier parcours imprimerait des titres finalement battus.

Changer d’énoncé, garder le raisonnement

Choisis un seul transfert après le sujet principal. Qu’est-ce qui change ? Quel résultat ou quelle méthode peux-tu réutiliser ? Les autres exercices restent disponibles pour une prochaine séance.

Exercices d'entraînement — une nuance à la fois

1 Drill SD-I.1 — tableaux de déclaration d'un problème à deux tableaux parallèles
Entraînement 01 / 08

Drill SD-I.1 — tableaux de déclaration d'un problème à deux tableaux parallèles

3 questionsCorrigé masqué

Une bibliothèque scolaire suit ses emprunts. Un tableau AD contient les noms de na adhérents, chaque nom étant une chaine de caracteres, avec 5 ≤ na ≤ 100. Un tableau NB de même longueur contient, à l'indice correspondant, le nombre de livres empruntés par l'adhérent. Une procedure Remplir saisit les noms, une procédure Compter met NB à jour à partir de ne fiches d'emprunt, et une procédure Editer affiche les adhérents ayant emprunté le plus de livres.

  1. Donner le tableau des nouveaux types nécessaires à cette solution.
  2. Donner le tableau des objets globaux, avec pour chacun son type ou sa nature et son rôle.
  3. Dire pourquoi le type des deux tableaux ne peut pas figurer dans le tableau des objets globaux.
Voir la correction commentéeAprès avoir posé votre démarche

1. TDNT

  • TabNom = Tableau [1..100] de chaine de caractères
  • TabEnt = Tableau [1..100] d'entiers

2. TDOG

  • AD — TabNom — contenant les noms des adhérents
  • NB — TabEnt — contenant le nombre de livres empruntés par chaque adhérent
  • na — entier — le nombre d'adhérents
  • ne — entier — le nombre de fiches d'emprunt à dépouiller
  • Remplir — procédure — saisir na et les noms des adhérents
  • Compter — procédure — mettre à jour NB à partir des fiches
  • Editer — procédure — afficher les adhérents au plus grand nombre d'emprunts

3. Le tableau des objets globaux décrit des objets déjà typés : il attribue un type existant à chaque nom. Tableau [1..100] de chaine de caractères n'existe pas dans le langage algorithmique, il faut le créer ; c'est précisément l'office du tableau des nouveaux types. Y renoncer laisse AD et NB sans type déclaré, et les en-têtes de procédures ne peuvent alors plus nommer leurs paramètres.

2 Drill SD-I.2 — module de remplissage : contrôles de saisie et unicité
Entraînement 02 / 08

Drill SD-I.2 — module de remplissage : contrôles de saisie et unicité

2 questionsCorrigé masqué

On veut remplir un tableau TP par n titres de projets. Chaque titre est une chaine de caracteres ne comportant que des lettres et des espaces, sa longueur est comprise entre 4 et 30, et deux projets ne peuvent pas porter le même titre. Le nombre de projets n doit être compris entre 5 et 40.

On dispose des deux modules suivants, à utiliser sans les développer : Alpha(ch), fonction booléenne vraie si ch ne contient que des lettres et des espaces ; Rang(ch, T, k), fonction retournant l'indice de la case de T contenant ch parmi ses k premières cases, ou -1 si ch n'y figure pas.

  1. Écrire l'algorithme de la procedure Remplir(TP, n) respectant toutes les contraintes.
  2. Donner son tableau des objets locaux.
Voir la correction commentéeAprès avoir posé votre démarche

Chaque contrainte de l'énoncé devient une boucle à test final : on redemande la valeur tant qu'elle est refusée.

DEF PROC Remplir (var TP : TabCh ; var n : entier)
1) Répéter
     Ecrire("Nombre de projets : ") ; Lire(n)
   Jusqu'à (n dans [5..40])
2) Pour i de 1 à n faire
     Répéter
       Ecrire("Titre du projet n° ", i, " : ") ; Lire(t)
     Jusqu'à Alpha(t) ET (Long(t) dans [4..30]) ET (Rang(t, TP, i-1) = -1)
     TP[i] ← t
   FinPour
3) Fin Remplir

TDOL de Remplir : i — Type/Nature : entier — Rôle : compteur de la boucle de saisie ; t — Type/Nature : chaîne — Rôle : le titre en cours de saisie, avant validation.

Le test d'unicité porte sur Rang(t, TP, i-1) et non sur Rang(t, TP, n) : au tour i, seules les i-1 premières cases sont remplies, et interroger au-delà reviendrait à comparer le titre saisi avec des cases dont le contenu est indéterminé.

3 Drill SD-I.3 — validation « lettres et espaces seulement » avec arrêt au premier caractère invalide
Entraînement 03 / 08

Drill SD-I.3 — validation « lettres et espaces seulement » avec arrêt au premier caractère invalide

4 questionsCorrigé masqué

On veut remplir un tableau T de type TabCh par n noms (3 ≤ n ≤ 25), chaque nom étant une chaîne non vide composée uniquement de lettres alphabétiques et d'espaces.

  1. Écrire une fonction booléenne Alphabetique(ch) qui parcourt ch et s'arrête dès le premier caractère qui n'est ni une lettre ni un espace.
  2. Combien de caractères la fonction examine-t-elle pour "Ben Ali", pour "Ali2" et pour "R2D2 Robot" ? Quel résultat retourne-t-elle dans chaque cas ?
  3. Que retourne Alphabetique pour la chaîne vide ? En déduire la condition de la boucle de saisie.
  4. Écrire la procédure Remplir(@T, @n) qui saisit n puis les n noms en respectant toutes les contraintes.
Voir la correction commentéeAprès avoir posé votre démarche

1. Idée : une boucle Tant que pilotée par un booléen : on sort dès que ok devient faux, inutile de lire la suite.

Fonction Alphabetique (ch : Chaîne) : Booléen
DEBUT
    ok ← Vrai
    i ← 0
    Tant que (i < Long(ch)) Et ok Faire
        ok ← (Majus(ch[i]) ∈ ["A".."Z"])
             Ou (ch[i] = " ")
        i ← i + 1
    Fin Tant que
    Retourner ok
FIN

2. "Ben Ali" : 7 caractères examinés, Vrai. "Ali2" : 4 caractères, Faux (le 2 est le dernier). "R2D2 Robot" : 2 caractères seulement, Faux — la boucle s'arrête sur le 2 d'indice 1.

3. Pour la chaîne vide, la boucle ne s'exécute pas et ok garde sa valeur initiale : la fonction retourne Vrai. La saisie doit donc aussi exiger Long(T[i]) > 0.

4.

Procédure Remplir (@T : TabCh, @n : Entier)
DEBUT
    Répéter
        Ecrire("n = ")
        Lire(n)
    Jusqu'à (n ≥ 3) Et (n ≤ 25)
    Pour i de 0 à n-1 Faire
        Répéter
            Ecrire("Nom ", i+1, " : ")
            Lire(T[i])
        Jusqu'à (Long(T[i]) > 0)
                Et Alphabetique(T[i])
    Fin Pour
FIN

T et n sont passés par référence (@) : la procédure les remplit pour le programme appelant. Objet local : i (Entier).

4 Drill SD-I.4 — identifiant de 8 chiffres : parcours caractère par caractère, ou Long et Estnum
Entraînement 04 / 08

Drill SD-I.4 — identifiant de 8 chiffres : parcours caractère par caractère, ou Long et Estnum

5 questionsCorrigé masqué

Une société enregistre les identifiants de n cartes (3 ≤ n ≤ 40) dans un tableau ID de chaînes ; un identifiant est une chaîne formée d'exactement 8 chiffres, par exemple "01234567".

  1. Écrire une fonction booléenne Est8Chiffres(ch) qui vérifie, par un parcours caractère par caractère, que ch est formée d'exactement 8 chiffres.
  2. Proposer une seconde écriture de la même condition, en une seule expression, avec les fonctions prédéfinies Long et Estnum.
  3. Donner le résultat de Est8Chiffres pour "01234567", "1234567", "1234567A" et "12 45678".
  4. Pourquoi l'identifiant est-il rangé dans une chaîne et non dans un entier ?
  5. Écrire la procédure RemplirID(@ID, @n).
Voir la correction commentéeAprès avoir posé votre démarche

1. Idée : tester la longueur d'abord ; on ne lit ch[i] que si la chaîne a bien 8 caractères, et on s'arrête au premier caractère qui n'est pas un chiffre.

Fonction Est8Chiffres (ch : Chaîne) : Booléen
DEBUT
    ok ← (Long(ch) = 8)
    i ← 0
    Tant que ok Et (i < 8) Faire
        ok ← ch[i] ∈ ["0".."9"]
        i ← i + 1
    Fin Tant que
    Retourner ok
FIN

2. (Long(ch) = 8) Et Estnum(ch).

3. "01234567" : Vrai ; "1234567" : Faux (7 caractères) ; "1234567A" : Faux (le A) ; "12 45678" : Faux (l'espace).

4. Un entier perd les zéros de tête : "01234567" deviendrait 1234567, qui n'a plus que 7 chiffres ; de plus, un identifiant ne sert à aucun calcul.

5.

Procédure RemplirID (@ID : TabCh, @n : Entier)
DEBUT
    Répéter
        Ecrire("n = ")
        Lire(n)
    Jusqu'à (n ≥ 3) Et (n ≤ 40)
    Pour i de 0 à n-1 Faire
        Répéter
            Ecrire("Identifiant ", i+1, " : ")
            Lire(ID[i])
        Jusqu'à Est8Chiffres(ID[i])
    Fin Pour
FIN
5 Drill SD-I.5 — date « J/M » saisie comme une chaîne : Pos, Sous_chaine, Estnum puis Valeur
Entraînement 05 / 08

Drill SD-I.5 — date « J/M » saisie comme une chaîne : Pos, Sous_chaine, Estnum puis Valeur

3 questionsCorrigé masqué

Une date de création est saisie comme une chaîne de caractères formée de deux parties, le jour J et le mois M, séparées par le caractère / (par exemple "8/11"). On ne tient compte que des contrôles suivants : J est un entier compris entre 1 et 31 et M un entier compris entre 1 et 12.

  1. Écrire une fonction booléenne DateValide(dt) qui vérifie ces contraintes, sans jamais appeler Valeur sur une chaîne non numérique.
  2. Donner le résultat de DateValide pour : "8/11", "0/5", "12/13", "5/", "/7", "3-4", "1/2/3", "31/2".
  3. Écrire la procédure RemplirDates(@D, @n) qui remplit un tableau D par n dates valides, avec 3 ≤ n ≤ 50.

N.B. Les indices commencent à 0 ; Pos retourne −1 en cas d'absence et Sous_chaine(ch, d, f) retourne les caractères d'indices d à f − 1.

Voir la correction commentéeAprès avoir posé votre démarche

1. Idée : Pos donne le séparateur ; s'il manque (−1) ou s'il est en tête (0), la date est refusée. Sinon on découpe, on vérifie que les deux morceaux sont numériques, et seulement alors on convertit.

Fonction DateValide (dt : Chaîne) : Booléen
DEBUT
    ok ← Faux
    p ← Pos("/", dt)
    Si p ≥ 1 Alors
        j ← Sous_chaine(dt, 0, p)
        m ← Sous_chaine(dt, p+1, Long(dt))
        Si Estnum(j) Et Estnum(m) Alors
            ok ← (Valeur(j) ≥ 1)
                 Et (Valeur(j) ≤ 31)
                 Et (Valeur(m) ≥ 1)
                 Et (Valeur(m) ≤ 12)
        FinSi
    FinSi
    Retourner ok
FIN

Objets locaux : p (Entier, position du /), j et m (Chaîne, les deux parties), ok (Booléen).

2.

  • "8/11" : Vrai.
  • "0/5" : Faux, J = 0.
  • "12/13" : Faux, M = 13.
  • "5/" : Faux, la partie mois est vide et Estnum la refuse.
  • "/7" : Faux, p = 0.
  • "3-4" : Faux, p = -1.
  • "1/2/3" : Faux, la partie mois "2/3" n'est pas numérique.
  • "31/2" : Vrai — l'énoncé limite les contrôles aux intervalles de J et de M, il ne demande pas la cohérence entre le jour et le mois.

3.

Procédure RemplirDates (@D : TabCh, @n : Entier)
DEBUT
    Répéter
        Ecrire("n = ")
        Lire(n)
    Jusqu'à (n ≥ 3) Et (n ≤ 50)
    Pour i de 0 à n-1 Faire
        Répéter
            Ecrire("Date ", i+1, " (J/M) : ")
            Lire(D[i])
        Jusqu'à DateValide(D[i])
    Fin Pour
FIN
6 Drill SD-I.6 — entier de 3 à 6 chiffres, positif ou négatif : bornes sur Abs ou longueur de Convch
Entraînement 06 / 08

Drill SD-I.6 — entier de 3 à 6 chiffres, positif ou négatif : bornes sur Abs ou longueur de Convch

2 questionsCorrigé masqué

On veut remplir un tableau T par n entiers (5 ≤ n ≤ 20), sachant que chaque élément du tableau doit être un entier, positif ou négatif, composé de 3 chiffres au minimum et de 6 chiffres au maximum (par exemple −450 et 123456 conviennent, 99 et −1000000 non).

  1. Pour chacune des conditions suivantes, dire si elle traduit exactement la contrainte ; sinon, donner un entier mal classé : (a) (x ≥ 100) Et (x ≤ 999999) ; (b) (Long(Convch(x)) ≥ 3) Et (Long(Convch(x)) ≤ 6) ; (c) (Abs(x) ≥ 100) Et (Abs(x) ≤ 999999) ; (d) (NbChiffres(x) ≥ 3) Et (NbChiffres(x) ≤ 6), où NbChiffres(x) retourne Long(Convch(Abs(x))).
  2. Écrire la fonction NbChiffres(x), puis la procédure Remplir(@T, @n).
Voir la correction commentéeAprès avoir posé votre démarche

1. Idée : le signe moins n'est pas un chiffre, mais Convch l'écrit ; il faut raisonner sur la valeur absolue.

  • (a) Non : −450 a 3 chiffres mais est refusé.
  • (b) Non : Convch(-12) = "-12" compte 3 caractères, donc −12 est accepté alors qu'il n'a que 2 chiffres (et −123456, 7 caractères, est refusé à tort).
  • (c) Oui.
  • (d) Oui.

2.

Fonction NbChiffres (x : Entier) : Entier
DEBUT
    Retourner Long(Convch(Abs(x)))
FIN

Procédure Remplir (@T : TAB, @n : Entier)
DEBUT
    Répéter
        Ecrire("n = ")
        Lire(n)
    Jusqu'à (n ≥ 5) Et (n ≤ 20)
    Pour i de 0 à n-1 Faire
        Répéter
            Ecrire("T[", i, "] = ")
            Lire(T[i])
        Jusqu'à (NbChiffres(T[i]) ≥ 3)
                Et (NbChiffres(T[i]) ≤ 6)
    Fin Pour
FIN
7 Drill SD-I.7 — noms uniques d'au moins 3 caractères commençant par une majuscule : Existe sur la partie remplie
Entraînement 07 / 08

Drill SD-I.7 — noms uniques d'au moins 3 caractères commençant par une majuscule : Existe sur la partie remplie

3 questionsCorrigé masqué

On veut remplir un tableau A par les noms d'utilisateurs de na adhérents (5 ≤ na ≤ 50), sachant qu'un nom est unique, formé d'au minimum 3 caractères, et commence obligatoirement par une lettre majuscule.

  1. Écrire une fonction booléenne Existe(ch, T, k) qui vérifie si la chaîne ch figure parmi les k premiers éléments T[0], …, T[k − 1] du tableau T.
  2. Écrire la procédure RemplirA(@A, @na). Au moment de saisir A[i], quel troisième paramètre faut-il passer à Existe, et pourquoi pas na ?
  3. Pour na = 5, l'utilisateur tape successivement sami, Sa, Sami, Sami, Salma, Ali. Indiquer pour chaque saisie si elle est acceptée et dans quelle case elle est rangée.
Voir la correction commentéeAprès avoir posé votre démarche

1.

Fonction Existe (ch : Chaîne, T : TabCh,
                 k : Entier) : Booléen
DEBUT
    i ← 0
    Tant que (i < k) Et (T[i] ≠ ch) Faire
        i ← i + 1
    Fin Tant que
    Retourner i < k
FIN

2. Idée : au moment de saisir A[i], seules les cases 0 à i − 1 sont remplies ; on passe donc i. Avec na, Existe comparerait aussi les cases pas encore saisies, dont le contenu est indéterminé.

Procédure RemplirA (@A : TabCh, @na : Entier)
DEBUT
    Répéter
        Ecrire("na = ")
        Lire(na)
    Jusqu'à (na ≥ 5) Et (na ≤ 50)
    Pour i de 0 à na-1 Faire
        Répéter
            Ecrire("Nom ", i+1, " : ")
            Lire(nom)
        Jusqu'à (Long(nom) ≥ 3)
                Et (nom[0] ∈ ["A".."Z"])
                Et Non(Existe(nom, A, i))
        A[i] ← nom
    Fin Pour
FIN

Objets locaux : i (Entier), nom (Chaîne). Lorsque Existe retourne l'indice trouvé ou −1 (forme de la session principale 2024), la dernière condition devient Existe(nom, A, i) = -1.

3.

  • sami : refusé, pas de majuscule initiale.
  • Sa : refusé, 2 caractères.
  • Sami : accepté, rangé dans A[0].
  • Sami : refusé, il figure déjà parmi A[0..0].
  • Salma : accepté, rangé dans A[1].
  • Ali : accepté, rangé dans A[2].
8 Drill SD-I.8 — taille paire dans un intervalle et tableau strictement croissant
Entraînement 08 / 08

Drill SD-I.8 — taille paire dans un intervalle et tableau strictement croissant

4 questionsCorrigé masqué

On veut saisir la taille n d'un tableau T, avec n un entier pair et 6 ≤ n ≤ 30, puis remplir T par n entiers positifs ou nuls rangés dans l'ordre strictement croissant (chaque élément est strictement supérieur au précédent).

  1. Écrire la condition de contrôle de la saisie de n. Parmi 4, 7, 6 et 32, lesquelles sont acceptées ?
  2. Un élève propose : Pour i de 0 à n-1 Faire Répéter Lire(T[i]) Jusqu'à T[i] > T[i-1] Fin Pour. Expliquer pourquoi cette proposition est incorrecte.
  3. Écrire la procédure Remplir(@T, @n).
  4. Pour n = 6, l'utilisateur tape successivement 3, −1, 3, 8, 5, 9, 9, 12, 20, 21. Donner le contenu final de T.
Voir la correction commentéeAprès avoir posé votre démarche

1. (n Mod 2 = 0) Et (n ≥ 6) Et (n ≤ 30). Seul 6 est accepté : 4 est trop petit, 7 est impair, 32 est trop grand.

2. Pour i = 0, la condition lit T[-1], qui n'existe pas ; et rien ne contrôle que le premier élément est positif ou nul. Le premier élément se saisit à part, la comparaison au précédent commence à i = 1.

3.

Procédure Remplir (@T : TAB, @n : Entier)
DEBUT
    Répéter
        Ecrire("n = ")
        Lire(n)
    Jusqu'à (n Mod 2 = 0) Et (n ≥ 6)
            Et (n ≤ 30)
    Répéter
        Ecrire("T[0] = ")
        Lire(T[0])
    Jusqu'à T[0] ≥ 0
    Pour i de 1 à n-1 Faire
        Répéter
            Ecrire("T[", i, "] = ")
            Lire(T[i])
        Jusqu'à T[i] > T[i-1]
    Fin Pour
FIN

4. 3 est rangé dans T[0] ; pour T[1], −1 et 3 sont refusés (pas strictement supérieurs à 3), 8 est accepté ; pour T[2], 5 est refusé et 9 accepté ; pour T[3], 9 est refusé et 12 accepté ; puis 20 et 21. D'où T = [3, 8, 9, 12, 20, 21].

Relier ce raisonnement au bac

Choisis une filière pour voir les sujets qui étayent ce scénario.