Bac math Page No.

info I
1 sp2021 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
2 sp2020 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
3 sp2019 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
4 sp-c2019 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
5 sp2018 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
6 sp-c2018 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
7 sp2017 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
8 sp-c2017 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
9 sp2016 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
10 sp-c2016 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
11 sp2015 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
12 sp-c2015 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58
Page 2
Page 3
Page 4
Page 5
Page 6
Page 7
Page 8
Page 9
Page 10
Page 11
Page 12
Page 13
Page 14
 Section : . . . . . . . . . . . . . . . . . . . . N° d’inscription : . . . . . . . . . . . . . . . Série : . . . . . . . . . . . Signature des
surveillants
Nom et Prénom : ..................................................... ....... . . . . . . . . . . . .. . .
. . . . . . . . . . . .. . .
Date et lieu de naissance : . . . . . . . . . . . . . . . . . . . . ....... ............................

--------------------------------------------------------------------------

Épreuve : INFORMATIQUE
Sections: Mathématiques, Sciences expérimentales et Sciences techniques
Session 2019

.Le sujet comporte 4 pages numérotées de 1/4 à 4/4.

Les pages 1/4 et 2/4 sont à remplir par le candidat et à rendre avec sa copie.
.

Exercice 1 (4 points)
Dans un contexte informatique et pour chacune des propositions ci-dessous, mettre dans la case
correspondante la lettre "V" si la proposition est correcte ou la lettre "F" dans le cas contraire.
1) Soit l’algorithme suivant :
0) Début Inconnu
1) Lire (C1)
2) Lire (C2)
3) C3  0
Pour i de 1 à Long(C2) faire
Si (Majus(C2[i]) = Majus(C1))
Alors C3  C3 + 1
Fin si
Fin pour
4) Ecrire (C3)
5) Fin Inconnu
a) Ci-dessous des extraits de propositions de tableaux de déclaration des objets utilisés. La
déclaration correspondante à l’algorithme Inconnu est :

Objet Type/nature Objet Type/nature Objet Type/nature Objet Type/nature

C1 Chaîne C1 Caractère C1 Chaîne C1 Caractère
C2 Chaîne C2 Caractère C2 Caractère C2 Chaîne
C3 Entier C3 Entier C3 Réel C3 Entier

b) Afin d’améliorer le message d’affichage du résultat de l’algorithme précédent et de le rendre

significatif relativement au traitement effectué, l’instruction numéro 4 sera remplacée par
l’instruction suivante :
Ecrire ("Le nombre de caractères majuscules de ",C1," et ",C2," est : ",C3)
Ecrire ("Le nombre d’occurrences de ",C1," dans ",C2," est : ",C3)
Ecrire ("Le nombre de chiffres dans ",C2," est : ",C3)
Ecrire ("Le nombre de caractères communs entre ",C1," et ",C2," est : ",C3)

Page 1 sur
INFORMATIQUE – Sections :Mathématiques, Sciences expérimentales et Sciences techniques - Session 2019 / Corrigé et barème de notation 12
Page 15
 2) Soit la suite U définie par U0 = 1
Un = 1+1/Un-1 pour tout n > 0
a) La séquence algorithmique qui permet de déterminer le terme Un avec n ≥ 0 est :
T[1]  1 U0  1 Un  1 U0  1
Pour i de 2 à n+1 faire Pour i de 1 à n faire Pour i de 1 à n faire Pour i de 1 à n faire
T[i]  1+1/T[i-1] Un  1+1/U0 Un  1+1/Un Un  1+1/U0
Fin pour Fin pour Fin pour U0  Un
Un  T[n+1] Fin pour
Un  U0

b) L’entête de la fonction qui permet de déterminer le terme Un avec n ≥ 0 est :

DEF FN Suite (n : Réel) : Réel DEF FN Suite (n : Entier) : Entier

DEF FN Suite (n : Entier) : Réel DEF FN Suite (n : Réel) : Entier
Exercice 2 (3 points)
Soit la séquence algorithmique ci-dessous, où x est un entier naturel :
nb  1
Tant que (x Div 10 ≠ 0) faire
nb  nb + 1
x  x Div 10
Fin tant que

1) Compléter le tableau ci-contre par la valeur finale x nb

de nb suite à l’exécution de cette séquence pour 5403
chacune des valeurs de x. 176
3
2) Donner le rôle de cette séquence.

3) Ecrire une séquence algorithmique équivalente à celle donnée précédemment sans utiliser une
structure itérative.

Page 2 sur
INFORMATIQUE – Sections :Mathématiques, Sciences expérimentales et Sciences techniques - Session 2019 / Corrigé et barème de notation 12
Page 16
 Session 2019
RÉPUBLIQUE TUNISIENNE Sections :
MINISTÈRE DE L’ÉDUCATION Épreuve : Mathématiques,
EXAMEN DU INFORMATIQUE Sciences expérimentales et
BACCALAURÉAT Sciences techniques

Durée : 1h 30 Coefficient de l’épreuve : 0.5

     

Le sujet comporte 4 pages numérotées de 1/4 à 4/4.

Les pages 1/4 et 2/4 sont à remplir par le candidat et à rendre avec sa copie.

Problème (13 points)

Une société commerciale cherche à automatiser l'accès à ses services via des cartes à puces. Chaque carte est
caractérisée par un identifiant unique, une date de création et un code d’accès. Pour cela, on propose d’écrire
un programme permettant de :
1. Stocker les identifiants de N cartes dans un tableau IDENT (avec 3 ≤ N ≤ 50), sachant que l'identifiant
est une chaîne formée de 8 chiffres,
2. Stocker les dates de création de ces N cartes d'accès dans un tableau DATE, sachant qu’une date de
création est une chaîne de caractères formée de deux parties : le jour J et le mois M séparés par le
caractère "/" (On ne tiendra compte que des contrôles suivants : J est un entier compris entre
1 et 31 et M est un entier compris entre 1 et 12).
3. Déterminer dans un tableau CODE les N codes à partir du tableau DATE en utilisant le principe ci-après,
sachant qu’un code est une chaîne de 4 chiffres :
 Concaténer J et M pour former un nombre de 2, 3 ou 4 chiffres.
 Multiplier ce nombre par un entier aléatoire X compris entre 5 et 64 afin d’obtenir un nouveau nombre
Y.
 Former le code de quatre chiffres comme suit :
 Si Y est un entier de 4 chiffres, déplacer le chiffre des milliers vers la droite de ce nombre.
 Si Y est inférieur à 1000, ajouter des zéros (0) à droite de ce nombre pour que sa longueur soit
égale à 4.
 Si Y est supérieur à 9999, additionner le nombre formé des 4 chiffres de gauche au nombre formé
des chiffres restants à droite jusqu’à ce que sa longueur soit égale à 4.
4. Afficher les informations relatives à chacune des cartes sous la forme suivante :

Identifiant de la carte : Date de sa création correspondante : Code correspondant

NB : Le candidat n’est pas appelé à vérifier l’unicité des identifiants dans le tableau IDENT.

Page 3 sur
INFORMATIQUE – Sections :Mathématiques, Sciences expérimentales et Sciences techniques - Session 2019 / Corrigé et barème de notation 12
Page 17
 Exemple :
Pour N=3 et les deux tableaux IDENT et DATE suivants :
IDENT 12345678 23456789 34567891
1 2 3

DATE 8/11 2/1 24/12

1 2 3

 On obtient le tableau CODE suivant :

CODE 1108 6720 1314
1 2 3

En effet, les codes des cartes sont obtenus comme suit :

 Pour la carte N°1, la concaténation de J et de M donne le nombre 811. En supposant que l’entier
aléatoire X = 10, le nombre obtenu est égal à 8110 (811 * 10) qui est composé de 4 chiffres. En
déplaçant le chiffre des milliers (8) vers la droite, on obtient le code 1108.
 Pour la carte N°2, la concaténation de J et de M donne le nombre 21. En supposant que l’entier
aléatoire X = 32, le nombre obtenu est égal à 672 (21 * 32) qui est inférieur à 1000. En ajoutant
un zéro à droite pour que sa longueur soit égale à 4, on obtient le code 6720.
 Pour la carte N°3, la concaténation de J et de M donne le nombre 2412. En supposant que l’entier
aléatoire X = 53, le nombre obtenu est égal à 127836 (2412 * 53) qui est supérieur à 9999.
Le nombre formé des 4 chiffres de gauche (1278) sera additionné au nombre formé des chiffres
restants à droite (36), on obtient le code 1314 (1278 + 36).
 Le programme affiche :
12345678 : 8/11 : 1108
23456789 : 2/1 : 6720
34567891 : 24/12 : 1314
Travail demandé :
1. Analyser le problème en le décomposant en modules.
2. Ecrire les algorithmes et les tableaux de déclaration des objets relatifs aux modules envisagés.

Page 4 sur
INFORMATIQUE – Sections :Mathématiques, Sciences expérimentales et Sciences techniques - Session 2019 / Corrigé et barème de notation 12
Page 18
 Session 2019
RÉPUBLIQUE TUNISIENNE Sections :
MINISTÈRE DE L’ÉDUCATION Épreuve : Mathématiques,
EXAMEN DU INFORMATIQUE Sciences expérimentales et
BACCALAURÉAT Sciences techniques
Durée : 1h 30 Coefficient de l’épreuve : 0.5

Recommandations, explications, corrigé et barème de notation

Exercice 1 (4 points = 0.25 16)

(Recommandations et explications)
1)
a)
 Il est fortement recommandé de lire rapidement l’algorithme proposé et de voir ce qui est demandé
de faire dans les questions.
 Il s’agit de répondre si des propositions de types de variables sont correctes ou fausses.
il faut à ce moment après avoir lu les questions entrer dans les détails de l’algorithme proposé et
remarquer les différentes manipulations sur les variables :

Remarquer que :
La variable C2 est parcourue via des indices dans Majus(C2[i]), ne peut pas être de type tableau sinon on ne
peut pas faire lire(C2) et donc le type possible pour cette variable est chaine de caractère.
 Ce qui élimine la proposition 2

Majus(C1) témoigne que la fonction Majus est appliquée sur une variable de type caractère (C1)  Ce qui
élimine les propositions 1 et 3
La variable C3 est initialisée à 0 elle ne peut être qu’entière ou réelle.
La proposition 3 est correcte d’après les remarques citées supra.

b)
Remarquer d’après les propositions qu’on s’intéresse à la variable C3, la valeur de cette variable est
déterminée par l’expression C3  C3 + 1. Cette expression est exécuté dans la boucle chaque fois qu’on
trouve le caractère donné par la variable C1 dans une position dans la variable C2 (Majus(C2[i]) =
Majus(C1) ) ce qui permet de compter alors le nombre de fois ou le caractère défini par C1 apparait
dans C2.
On n’a pas le problème de majuscule/minuscule puisque tout est mis en majuscule.  La deuxième
proposition est vraie
Les autres propositions ne sont pas correctes :
Le nombre de chiffres… : aucune indication sur les chiffres
Caractères en communs… : C1 présente un seul caractère
Le nombre de caractères majuscules de… : Ne peut être vraie puisque Majus() transforme en
majuscule déjà après quoi on effectue le compte.

Page 5 sur
INFORMATIQUE – Sections :Mathématiques, Sciences expérimentales et Sciences techniques - Session 2019 / Corrigé et barème de notation 12
Page 19
 2)
a)
Remarquer que la suite est définie par son premier terme U0 et le Terme général Un. Ce dernier est défini
par le terme qui le précède Un-1.

1)
T[1]  1
Pour i de 2 à n+1 faire
T[i]  1+1/T[i-1]
Fin pour
Un  T[n+1]
 remarquer qu’on a mis le premier élément U0 de la suite dans la première case du tableau T[1], l’élément
U1 sera mis dans la case T[2]…l’élément Un sera mis dans la case T[n+1]
Donc cette suite d’instruction donne bien le résultat et calcule le terme Un

2)
U0  1
Pour i de 1 à n Faire
Un  1+1/U0
Fin pour
 Cette suite d’instruction ne peut pas donner le résultat puisque le terme (Un) sera toujours égal à 2
du début jusqu’à la fin..

3)
Un  1
Pour i de 1 à n Faire
Un  1+1/Un
Fin pour
 Cette suite d’instruction donne bien le résultat puisque le terme (Un) change à chaque fois et le
nouveau terme est bien donné en fonction du terme précédent. Exemple : pour i=1 ; la première
exécution de la boucle donne Un = 1+1/1 = 2 ; la deuxième exécution donne Un=1+1/2 …etc. Ce qui
donne bien le résultat.

4)
U0  1
Pour i de 1 à n Faire
Un  1+1/U0
U0  Un
Fin pour
Un  U0
 Cette suite d’instruction donne bien le résultat puisque à chaque exécution de la boucle le terme U0
prend la valeur du terme précédent et (Un) est calculé en fonction du terme précédent.

b)
La seule entête qui donne le résultat est bien DEF FN Suite (n : Entier) : Réel
Puisque n est entier et le résultat de calcul du nième terme de la suite est bien réel.

Page 6 sur
INFORMATIQUE – Sections :Mathématiques, Sciences expérimentales et Sciences techniques - Session 2019 / Corrigé et barème de notation 12
Page 20
 CORRIGÉ
Exercice 1 (4 points)
1)
a)
Objet Type/nature Objet Type/nature Objet Type/nature Objet Type/nature
C1 Chaîne C1 Caractère C1 Chaîne C1 Caractère
C2 Chaîne C2 Caractère C2 Caractère C2 Chaîne
C3 Entier C3 Entier C3 Réel C3 Entier
F F F V
b)
F Ecrire ("Le nombre de caractères majuscules de ",C1," et ",C2," est : ",C3)

V Ecrire ("Le nombre d’occurrences de ",C1," dans ",C2," est : ",C3)

F Ecrire ("Le nombre de chiffres dans ",C2," est : ",C3)

F Ecrire ("Le nombre de caractères communs entre ",C1," et ",C2," est : ",C3)

2)
a) La séquence algorithmique qui permet de déterminer le terme Un avec n ≥ 0 est :
T[1]  1 U0  1 Un  1 U0  1
Pour i de 2 à n+1 faire Pour i de 1 à n Faire Pour i de 1 à n Faire Pour i de 1 à n Faire
T[i]  1+1/T[i-1] Un  1+1/U0 Un  1+1/Un Un  1+1/U0
Fin pour Fin pour Fin pour U0  Un
Un  T[n+1] Fin pour
Un  U0
V F V V
b) L’entête de la fonction qui permet de déterminer le terme Un avec n ≥ 0 est :
DEF FN Suite (n : Réel) : Réel F DEF FN Suite (n : Entier) : Entier F
DEF FN Suite (n : Entier) : Réel V DEF FN Suite (n : Réel) : Entier F

Page 7 sur
INFORMATIQUE – Sections :Mathématiques, Sciences expérimentales et Sciences techniques - Session 2019 / Corrigé et barème de notation 12
Page 21
 Exercice 2 (3 points = 0.5  3 + 0.5 + 0,52)
(Recommandations et explications)

1)
x nb
5403 4
176 3
3 1

2)
Chaque fois que le quotient de la division de x par 10 est différent de zéro on ajoute 1 à nb et on aura un nouveau
quotient x  x Div 10 cela se termine lorsque ce dernier (le quotient )sera égal à zéro
Exemple 8 div 10 = 0
Donc cela calcule bien le nombre de chiffres(ou digit) qui composent un nombre.

3)
On convertit le nombre en une chaine et puis on compte le nombre de caractères qui sera la longueur de la
chaine..

CORRIGÉ
1)
x nb
5403 4
176 3
3 1
2) Cette séquence permet de déterminer le nombre de chiffres d’un entier x donné.
3) Convch(x, xch)
nb  Long(xch)
NB. -0,25 par erreur

Page 8 sur
INFORMATIQUE – Sections :Mathématiques, Sciences expérimentales et Sciences techniques - Session 2019 / Corrigé et barème de notation 12
Page 22
 Problème :
(Recommandations et explications)

Lire attentivement l’énoncé du problème et dégager le résultat final demandé 

Il s’agit d’afficher les informations relatives à chacune des cartes comme c’est demandé dans l’étape 4

On pourra créer un module pour l’affichage des : Identifiant de la carte, de la Date de sa création
correspondante et le Code correspondant. Puisque d’après l’énoncé toutes ces informations sont à extraire à
partir des tableaux. Appelons ce module Afficher
Remarque : Il faut voir le problème dans son globalité et remarquer qu’il s’agit bien en fin de compte de trois
tableaux : Un pour stocker les identifiants, un pour stocker les dates et un pour stocker les codes.
Le parcours de ces tableaux en même temps donne le résultat voulu : Pour un indice i qui va de 1 à n on
parcourt simultanément les trois tableaux.
Si on cherche dans l’énoncé on trouve bien les façons pour remplir ces 3 tableaux
Le tableau des identifiants c’est à remplir comme indiqué dans l’étape 1 dans l’énoncé
Le tableau des dates c’est à remplir comme indiqué dans l’étape 2 de l’énoncé
Le tableau des codes c’est à remplir comme indiqué dans l’tape 3 de l’énoncé

Pour les deux premiers tableaux on pourra se servir d’un seul module pour le remplissage. Appelons le
Remplir
Pour le troisième tableau on pourra se servir d’un module pour le remplir. Appelons le Coder

Remarques :
- Des contrôles de saisie sont à prévoir dans le module Remplir pour le remplissage des tableaux des
identifiants et le tableau des dates.
(On pourra aussi créer des modules de remplissage pour chaque tableau mais cette solution est à éviter pour
gagner du temps, un seul module est suffisant)
- Il est à dire que les contrôles de saisie empêchent les utilisateurs des programmes de saisir des données en
dehors de ce qui est permis ou des valeurs permises comme par exemple saisir le mois numéro 15 qui n’existe
pas bien sûr.
- Remarquer aussi que dans le cadre des contrôles de saisie que dans la première étape de l’énoncé il y a la
phrase : sachant que l'identifiant est une chaîne formée de 8 chiffres donc on doit vérifier après chaque
saisie si la chaine saisie par l’utilisateur est formée seulement par des chiffres. On pourra prévoir un module
pour la vérification si le numéro saisi contient seulement des chiffres, appelons ce module Verifnum, ce dernier
va être utilisé dans le module Remplir.

Maintenant qu’on a compris de quoi il s’agit il est simple de passer à l’élaboration des différents modules.

Commençons par le programme principal puis élaborons les différents modules :

Page 9 sur
INFORMATIQUE – Sections :Mathématiques, Sciences expérimentales et Sciences techniques - Session 2019 / Corrigé et barème de notation 12
Page 23
 CORRIGÉ

1) Analyse du programme principal :

Nom : Validation
Résultat = PROC Afficher (IDENT, DATE, CODE, n)
(IDENT, DATE, CODE, n) = PROC Remplir (IDENT, DATE,n)
PROC Coder (CODE, DATE, n)
Fin Validation
TDNT
Type
tab= tableau de 50 chaînes

TDOG
Objet Type/Nature Rôle
IDENT tab Contient les identifiants des cartes
DATE tab Contient les dates de création des cartes
CODE tab Contient les codes des cartes
n Entier Le nombre de cartes
Remplir Procédure Saisir n et remplir les tableaux Ident et Date
Coder Procédure Déterminer les codes des différentes cartes
Afficher Procédure Afficher les éléments des trois tableaux

2) Les algorithmes des modules :

0) DEF PROC Remplir (var Id,D:tab ; var n:entier)

1) Répéter
Ecrire ("Donner le nombre de cartes : ")
Lire(n)
Jusqu’à (n dans [3..50])
2) Pour i de 1 à n faire
Répéter
Ecrire ("Donner l’identifiant de la carte n° ",i, " : ")
Lire(Id[i])
Jusqu’à (Long(Id[i]=8)) et (FN Verifnum(Id[i]))
Ecrire ("Donner la date en jour et en mois de la carte n° ",i, " : ")
Répéter
Ecrire ("Donner J : ")
Lire(j)
Jusqu’à ( j dans [1..31])
Répéter
TDOL
Ecrire ("Donner M : ")
Lire(m) Objet Type/Nature Rôle
Jusqu’à (m dans [1..12]) i Entier Compteur
Convch(j,jch) m Entier Contient le mois
Convch(m,mch) j Entier Contient le jour
D[i]  jch+"/"+mch jch chaîne Résultat de la conversion du jour en chaîne
Fin pour mch chaîne Résultat de la conversion du mois en chaîne
3) Fin Remplir Verifnum Fonction Vérifier si une chaîne est numérique

Page 10 sur
INFORMATIQUE – Sections :Mathématiques, Sciences expérimentales et Sciences techniques - Session 2019 / Corrigé et barème de notation 12
Page 24
 DEF FN Verifnum (ch:chaine) : booléen
0) k0 TDOL
Répéter Objet Type/Nature Rôle
k k+1 k Entier Compteur
Jusqu’à (non ch[k] dans ["0". ."9"]) ou (k=Long(ch))
1) Verifnum  ch[k] dans ["0". ."9"]
2) Fin Verifnum

0) DEF PROC Coder (var C:tab ; D:tab ; n:entier)

1) Pour i de 1 à n faire
ch D[i]
Efface (ch,Pos("/",ch),1)
Valeur (ch,r,e)
x5+ Aléa(60)
nb r*x
Convch(nb,nbch)
Si (Long (nbch)=4)
Alors C[i]  Sous_chaine(nbch,2,4) + nbch[1]
Sinon
Si (Long(nbch) < 4)
Alors
Répéter
nbch  nbch +"0"
Jusqu’à (Long(nbch) = 4)
C[i] nbch
Sinon
Valeur(Sous_chaine(nbch,1,4),nb1)
Valeur(Sous_chaine(nbch,5,Long(nbch)),nb2)
Convch(nb1+nb2, C[i])
Fin si
Fin si TDOL
Fin pour Objet Type/Nature Rôle
2) Fin Coder i Entier Compteur
r Entier Contient les chiffres relatifs à la date
x Entier Entier aléatoire
e Entier Position de l’erreur
nb Entier long Résultat de la multiplication de r par x
nb1 Entier Les quatre chiffres de gauche de nb
nb2 Entier Le reste des chiffres de nb
ch Chaîne Une date du tableau D
nbch Chaîne Résultat de la conversion de nb en chaîne

0) DEF PROC Afficher (Id,D,C:tab ; n:entier)

1) Pour i de 1 à n faire
Ecrire (Id[i], " : ", D[i], " : ", C[i]) TDOL
Fin pour Objet Type/Nature Rôle
2) Fin Afficher i Entier Compteur

Page 11 sur
INFORMATIQUE – Sections :Mathématiques, Sciences expérimentales et Sciences techniques - Session 2019 / Corrigé et barème de notation 12
Page 25
 Barème détaillé :

Programme principal : 1.5 points =

- Modularité 0.5
- Cohérence (appels + conformité des paramètres) 1 = (0.5+0.5)
Saisie du nombre de cartes N : 0.5 point =
- Lecture 0.25
- Contrôle de la contrainte 0.25
Remplissage du tableau IDENT : 1.75 points =
- Parcours du tableau 0.25
- Lecture de IDENT[i] 0.25
- Contrôle des contraintes : 8 chiffres (chiffres + longueur) 1.25 = (1+0.25)
Remplissage du tableau DATE : 2 points =
- Parcours du tableau 0.25
- Lecture de J + contrôle des contraintes 0.25+0.25
- Lecture de M + contrôle des contraintes 0.25+0.25
- Remplissage d’un élément date (conversion + concaténation + affectation) 0.75 = (0.25*3)
Formation du tableau CODE : 4.25 points =
- Parcours du tableau 0.25
- Concaténation de J et M 0.5
- Lecture aléatoire de X 0.5
- Détermination du nombre Y 0.25
- Formation du code (cas 1 + cas 2 + cas 3) 2.5 = (0.5+0.75+1.25)
- Remplissage d’un élément Code 0.25
Affichage des éléments des tableaux : 1.25 points =
- Parcours des tableaux 0.25
- Affichage des éléments + respect de la forme 1 = (0.25*3 + 0.25)
TDNT + TDOG 0.75 point = (0.25+0.5)
TDOL 1 point

-0,25 par erreur.

Page 12 sur
INFORMATIQUE – Sections :Mathématiques, Sciences expérimentales et Sciences techniques - Session 2019 / Corrigé et barème de notation 12
Page 26
Page 27
Page 28
Page 29
Page 30
 RESUME
Ceci est une proposition d’un corrigé avec des
commentaires de l’épreuve d’informatique de la

CORRIGE DE L’EPREUVE
session 2018 concernant les sections scientifiques :
Sciences expérimentales, Maths et Sciences
techniques.

THEORIQUE DE LA
Corrigé
MATIERE INFORMATIQUE
POUR LES SECTIONS
SCIENTIFIQUES
Session 2018

Page 31
 RÉPUBLIQUE TUNISIENNE Épreuve : INFORMATIQUE
MINISTÈRE DE L’ÉDUCATION Sections : Mathématiques, Sciences
 Expérimentales et Sciences Techniques
EXAMEN DU BACCALAURÉAT
Durée : 1 H 30 Coefficient : 0.5
Corrigé

Exercice 1 (4 points= 1*4)

Instruction à exécuter Valeur finale de la variable

Ch Concat(Ch1, " ", Ch2) Ch contient "Bac 2017/2018"

Q  Tronc (P) Q contient 19

Valeur (sous-chaine(Ch2,1,4),R,e) R contient 2017

Effacer (Ch,5,5) Ch contient "Bac 2018"

NB :

 On acceptera toute autre solution correcte.

 -0.25 par erreur (de syntaxe, ordre de paramètres, confusion
Pascal/Algorithmique, etc.)
Exercice 2 (4 points = (0.2*5 )*4)

Pour cet exercice, seules les réponses V, F, Vrai, Faux ont été acceptées.

Valider chacune des propositions suivantes en mettant dans la case correspondante la lettre V si elle est
correcte ou la lettre F si elle est fausse.

a. Pour calculer le produit de a par b, on peut faire appel à la (aux) fonction(s) :

F1 V F2 F F3 F F4 F F5 F

b. Pour calculer ab , on peut faire appel à la (aux) fonction(s) :

F1 F F2 V F3 F F4 F F5 F

c. Pour calculer le PGCD des deux entiers a et b, on peut faire appel à la (aux) fonction(s) :

F1 F F2 F F3 F F4 V F5 V

d. Pour calculer la somme des entiers de l’intervalle [a..b], on peut faire appel à la (aux)
fonction(s) :

F1 F F2 F F3 V F4 F F5 F
Page 1|5

Page 32
Problème :

1. Analyse du programme principal :

Nom : Groupe
Resultat = PROC Recherche(M,A, na,nm)
PROC Inactifs (Occ, A, na)
M, nm, Occ= PROC RemplirM (M,Occ,na,nm)
A,na=PROC RemplirA(A,na)
Fin Groupe

TDNT
Tab1= Tableau [1..100] de chaine de caractères
Tab2 = Tableau [1..100] d’entiers

TDOG
Objet Type/Nature Rôle
M Tab1 Contenant les messages
A Tab1 Contenant les noms des adhérents
Occ Tab2 Contenant le nombre de messages par adhérent
nm Entier Le nombre de messages
na Entier Le nombre d’adhérents du groupe
Inactifs Procédure Permet d’afficher les membres inactifs
Recherche Procédure Permet d’afficher l’adhérent qui a envoyé un message
donné
RemplirM Procédure remplir les messages et déterminer le nombre de
messages par adhérent.
RemplirA Procédure Permet de saisir les noms des membres

2) Les algorithmes
a. Algorithme de la procédure RemplirA
0) DEF PROC RemplirA (var A:Tab1 ; var na : entier)
1) Répéter
Ecrire ("donner le nombre d'adhérents du groupe :")
Lire(na)
Jusqu’à (na dans [5..50])
2) Pour i de 1 à na faire
Répéter
Ecrire("Donner le nom de l'adhérant numéro", i, " : ")
Lire(A[i])
Jusqu’a ((A[i][1] dans ["A".. "Z"]) ET (long(A[i]) ≥3) ET((i>1) ET NON(FN Existe(A[i],A,i-1))
FinPour
4) Fin RemplirA
TDOL
Objet Type/Nature Rôle
i entier compteur
Existe fonction Vérifier l’existence d’un adhérant dans A

Page 2|5

Page 33
 0)DEF FN Existe(ch: chaine ; t:Tab1; indice: entier):boolean
1) i0
2) Répéter
i i+1
Jusqu’à ((t[i]=ch) ou( i=indice)
3) Existe (t[i]=ch) TDOL
Objet Type/Nature Rôle
4) Fin Existe
i entier compteur

b. Algorithme de la procédure RemplirM

0) DEF PROC RemplirM (A : Tab1 ;var M:Tab1 ; var Occ:Tab2; na:entier; var nm:entier)
1) Répéter
Ecrire ("donner le nombre de commentaires : ")
Lire (nm)
Jusqu’à (nm dans [3..100])
2) Pour i de 1 à na faire
Occ[i] 0
Fin pour
3) Pour i de 1 à Nm faire
Ecrire ("donner le commentaire")
Lire (message)
Répéter
Ecrire ("donner le numéro de l’émetteur")
Lire (NumE)
Jusqu’à (NumE dans [1..Na])
Convch(NumE,ch)
M[i]  Concat (ch ,"#",message)
Occ[NumE]  Occ[NumE] +1
Fin pour
4) Fin RemplirM
TDOL
Objet Type/Nature Rôle
NumE entier Numéro de l’émetteur
i entier compteur
message Chaine de caractères Message à envoyer
c. Algorithme de la procédure Inactifs

0) DEF PROC Inactifs (Occ:Tab2; A:tab1 ; na:entier)

1) Ecrire ("la liste des adhérents inactifs est : ")
2) Pour i de 1 à na faire
Si(Occ[i]= 0) Alors
Ecrire (A[i]) TDOL
FinSi Objet Type/Nature Rôle
Fin Pour i entier compteur
3) Fin Inactifs

Page 3|5

Page 34
d. Algorithme de la procédure Recherche

0) DEF PROC Recherche (M,A:Tab1; na,nm :entier )

1) Ecrire ("Donner le commentaire à chercher :"), lire(msg)
2) Pour i de 1 à nm faire
Si (Sous-chaine(M[i], pos("#",M[i])+1, long(M[i])- pos("#",M[i]))= msg) alors
Valeur(Sous-chaine(M[i],1, pos("#",M[i])-1) ,Nume,e)
Ecrire(A[Nume])
Fin si
Fin pour
3) Fin PROC Recherche
TDOL
Objet Type/Nature Rôle
i entier compteur
Nume entier Numéro émetteur
e entier Position de l’erreur
msg chaine Message à chercher

NB :

 Il est à noter que ceci n’est qu’une proposition de solution.

 Il existe d’autres solutions possibles pour résoudre ce problème et qui ont été
acceptées.

Page 4|5
Page 35
Barème détaillé du problème :

P. P : 1.5 points =
- Modularité 0.5
- Cohérence (appels + conformité des paramètres))
1=(0.5 appels +0.5 conformité)

Le remplissage du tableau A avec respect des contraintes : 1.75 points =

- La saisie du nombre d’adhérents avec respect de la 0.5= 0.25 saisie+ 0.25
contrainte contrainte
- Parcours du tableau 0.25
- Lecture de A[i] + Respect des contraintes (1er caractère, 1 = 0.25 + 0.25*3
longueur, unicité)

Traitement de l’unicité 1.25 point (-0.25 par erreur)

Le remplissage du tableau M avec respect des contraintes : 2 points =

- La saisie du nombre de commentaires avec respect des 0.5 = 0.25 + 0.25
contraintes
- Parcours du tableau 0.25
- Lecture de M[i] : Test du numéro de l’émetteur+ # 1.25 = 0.5 +0.25+ 0.25+0.25
+lecture du commentaire+ affectation

Affichage : 4 points =
- Détermination des adhérents inactifs (2 parcours+ test+ 1.75 =0.5*2+0.5+0.25
affichage)
- Saisie du commentaire 0.25
- Recherche des adhérents qui ont envoyé le commentaire 2=0.25+1+0.5+0.25
donné (parcours+ test + extraction de l’indice +
affichage)

TDNT + TDOG 0.75 points = 0.25 + 0.5

TDOL 0.75 points

NB : -0.25 par type erreur.

Page 5|5
Page 36
Page 37
Page 38
Page 39
 Corrigé Informatique Sections : Mathématiques, Sciences
expérimentales, Sciences Techniques

Session principale Baccalauréat 2017

Exercice N°1 :

Réécrire dans la colonne « Correction », les phrases données dans la colonne

« Proposition » en apportant les modifications nécessaires afin qu’elles soient correctes :

Proposition Correction

 La recherche dichotomique est une

méthode de recherche appliquée sur un
La recherche dichotomique est une méthode de tableau trié.
recherche appliquée sur un tableau quelconque.  La recherche séquentielle est une
méthode de recherche appliquée sur un
tableau quelconque.
Un tableau est une structure de données Un tableau est une structure de données
permettant de regrouper plusieurs éléments de permettant de regrouper plusieurs
types différents. éléments de même type.
 Les paramètres formels sont utilisés lors
de la définition d’un sous-programme
Les paramètres formels sont utilisés lors de
(au niveau de l’entête).
l’appel d’un sous-programme.
 Les paramètres effectifs sont utilisés lors
de l’appel d’un sous programme.
L’évaluation d’une expression formée par des L’évaluation d’une expression formée par
opérateurs ayant la même priorité se fait de des opérateurs ayant la même priorité se
gauche à droite ou de droite à gauche. fait de gauche à droite.
 Le type scalaire énuméré définit un
ensemble ordonné et fini de valeurs
Le type scalaire énuméré définit un ensemble n’appartenant pas à un type prédéfini
ordonné et fini de valeurs appartenant à un type dites identificateurs.
prédéfini.  Le type intervalle définit un ensemble
ordonné et fini de valeurs appartenant à
un type prédéfini.

Page 1 sur 4

Page 40
 Exercice 2 :
a) Tableau de déclaration des objets de l’algorithme « Exercice »

T.D.O
Objet Type/nature Rôle
ch1 Chaîne La première chaîne à saisir
ch2 Chaîne La deuxième chaîne à saisir
p Entier Position
ch Chaîne Chaîne intermédiaire
i Entier Compteur

b) expression équivalente utilisant un ou plusieurs modules prédéfinis

Séquence n°2 : ch Sous-chaine (ch1, 1, p-1)

Séquence n°4 : ch Concat (ch, Sous-chaine (ch1,p, Long(ch1)-p+1))
c) Le programme affiche : BAC 2016/2017
d) Cet algorithme permet d’insérer une chaine ch2 dans une chaine ch1 à une position p.
e) le module prédéfini qui peut jouer le même rôle est : Insère (ch2, ch1, p)

Problème :
1) Analyse du programme principal

Nom : Hitparade TDNT

Résultat= PROC Afficher (T1, T2)
Type
(T1,T2)= [PROC Chanson (T1)
Tab1= tableau de 5 chaînes
PROC Score (T2,N)]
Tab2= tableau de 5 entiers
PROC Trier (T1,T2)
N= PROC Saisir(N)
Fin Hitparade
TDOG
Nom Nature/Type Rôle
T1 Tab1 Tableau des chansons
T2 Tab2 Tableau des scores
N Entier Nombre de participants
Saisir Procédure Saisir le nombre des participants
Chanson Procédure Remplir le tableau des chansons
Score Procédure Comptabiliser les scores
Trier Procédure Trier les scores et les chansons
Afficher Procédure Afficher le résultat

Page 2 sur 4

Page 41
2) Les algorithmes des modules envisagés :

a) Module Chanson :
0) DEF PROC Chanson (Var T1 : Tab1)
1) Pour i de 1 à 5 faire
Répéter
Ecrire (" Saisir le titre de la chanson n°", i, " :")
Lire (T1[i])
Jusqu’à (FN Verif (T1[i]))
Fin pour
2) Fin Chanson
TDOL
Nom Nature/Type Rôle
i Entier Compteur
Verif Fonction Vérifier si une chaîne est composée
uniquement de lettres et des espaces

b) Module Verif :
0) DEF FN Verif (ch : chaine) : booléen
1) j  0
Répéter
j j + 1
Jusqu’à (NON (Majus (ch[j]) dans ["A".."Z", " "])) OU ( j=Long(ch))
2) Verif (Majus (ch[j]) dans ["A".."Z", " "]
3) Fin Verif

TDOL
Nom Type Rôle
j Entier Compteur

c) Module Saisir :
0) DEF PROC Saisir (Var N : entier)
1) Répéter
Ecrire (" Saisir le nombre de participants : ")
Lire (N)
Jusqu’à (N dans [5..100])
2) Fin Saisir

d) Module Score :
0) DEF PROC Score (Var T2 : Tab2 ; N : entier )
1) Pour i de 1 à 5 faire
T2[i]  0
Fin pour
2) Pour i de 1 à N faire
Répéter
Ecrire (" Saisir le numéro de la chanson :")
Lire (num)
Jusqu’à (num dans [1..5])
TDOL
T2[num]  T2[num] + 3
Nom Nature/Type Rôle
Fin pour
i Entier Compteur
3) Fin Score
num Entier Numéro de la chanson choisie

Page
Page3 sur
42 4
e) Module Trier :
0) DEF PROC Trier (Var T2 : Tab2 ; Var T1 : Tab1 )
1) Pour i de 1 à 4 faire TDOL
PmaxFN Posmax (T2, i) Nom Type Rôle
Si ( T2[Pmax]<>T2[i]) i Entier Compteur
Alors Pmax Entier Position maximum
Aux1 T2[Pmax] Aux1 Entier Variable intermédiaire
T2[Pmax]  T2[i] Aux2 Chaine Variable intermédiaire
T2[i]  Aux1 Posmax Fonction Renvoie la position du
Aux2 T1[Pmax] maximum
T1[Pmax]  T1[i]
T1[i]  Aux2
Fin Si
Fin pour
2) Fin Trier

f) Module Posmax :

0) DEF FN Posmax (T2 : Tab2 ; i : entier)

1) Pmi
2) Pour j de i+1 à 5 faire TDOL
Si (T2[Pm] < T2[j]) Nom Nature/Type Rôle
Alors Pmj j Entier Compteur
Fin Si Pm Entier Position maximum
Fin pour
3) Posmax  Pm
4) Fin Posmax

g) Module Afficher :

0) DEF PROC Afficher (T1 : Tab1;T2 : Tab2 )

1) Ecrire ("le classement est :")
Rang1
Ecrire ("Rang ",Rang, " :", T1[1]) TDOL
Pour i de 2 à 5 faire Nom Nature/Type Rôle
Si (T2[i-1] =T2[i] ) i Entier Compteur
Alors Ecrire (" , ",T1[i]) Rang Entier Rang de la chanson
Sinon
Rang Rang+1
Ecrire ("Rang ",Rang, " :",T1[i])
Fin Si
Fin pour
2) Fin Afficher

Page
Page4 sur
43 4
Page 44
Page 45
Page 46
Page 47
Page 48
Page 49
Page 50
Page 51
Page 52
 Devoirs et examens sur : www.Kiteb.net

Page 53
 REPUBLIQUE TUNISIENNE Épreuve : Informatique
MINISTRÉPUBLIQUE DE L’ÉDUCATION
Durée : 1 H 30 mn
EXAMEN DU BACCALAURÉAT
SESSION 2015 Coefficient : 0,5

Sections : Mathématiques, Sciences expérimentales et Sciences Techniques

Le sujet comporte 4 pages numérotées de 1/4 à 4/4.

Les réponses à l'exercice 1 et 2 doivent être rédigées sur cette même feuille
qui doit être remise à la fin de l'épreuve

Exercice 1 (3,75 points)

Afin de réaliser les tâches décrites dans la première colonne du tableau suivant, un élève
fournit les propositions suivantes. Remplir la colonne "Correction'' en apportant les
corrections nécessaires pour que ces propositions soient les plus adéquates relativement au
choix de la structure itérative.
Tâche Proposition Correction
n= [n= donnée ("Saisir un entier positif :")] ..................................................
Tant que (n 0) faire ..................................................
Saisir un entier n= donnée ("Saisir un entier positif :")
positif n .....................................................
Fin tant que
.....................................................

Max = [ i  1, Max  T[1] ]

Répéter .....................................................
Chercher la valeur [ ] Si (T [i]> Max) alors
.....................................................
maximale dans un Max T[i]
Fin Si .....................................................
tableau T de taille n.
Ii+1 .....................................................
Jusqu’à (i > n)
Trouve = [Trouve faux]
Pour i de 1 à n faire .....................................................
Vérifier l'existence
d'un caractère C dans [ ]Si (T[i] = C) .....................................................
un tableau T de n Alors Trouve Vrai .....................................................
caractères. Fin si .....................................................
Fin pour

Page 1 / 4

Page 54
 Exercice 2 (5,25 points)
Soit U0 un entier naturel de quatre chiffres. A l’aide de ses quatre chiffres, on compose le plus
grand entier et le plus petit entier formés par ces chiffres.
La différence de ces deux nombres donne U1, qui sera soumis au même traitement pour
donner U2, etc. Jusqu’à ce que la suite U devienne stationnaire, c'est-à-dire, à un certain
terme elle devient constante (ne change plus de valeur).
Soit l’algorithme suivant nommé Suite et permettant de déterminer les termes d’une suite U
ayant comme premier terme U0, de les ranger dans un tableau T et de l’afficher (avec Max
et Min sont deux modules qui déterminent respectivement le plus grand entier et le plus petit
entier formés à partir des chiffres de Ui avec i >0).
0- Début Suite Répéter ii+1
1- Répéter T[i]  FN Max(U0) – FN Min(U0)
Lire(U0) U0 T[i]
Jusqu’à (U0 ≥ 1000) et (U0 ≤ 9999) Jusqu’à (T[i] = T[i-1])
2- i 1 T[1]U0 3- Proc Afficher (T, i)
4- Fin Suite

Travail demandé :
Pour chacune des questions suivantes, cocher la ou les bonnes réponses.
1- Par quel appel peut-on remplacer la séquence 1 de l'algorithme Suite ?
 Proc Saisir (N)  Proc Saisir (U0)
 Procédure Saisir (Var N : entier)  U0 Proc saisir (N)
2- Quels sont les en-têtes qui correspondent à la déclaration de la procédure Afficher ?
 DEF Proc Afficher (Var T : tab)
 DEF Proc Afficher (T : tab ; N : entier)
 DEF Proc Afficher (i : entier ; T : tab)
 DEF Proc Afficher (T[i] : entier)
3- L’en-tête suivant de la fonction Max est erroné : DEF FN Max (X : entier) Quel est l’origine de
l’erreur ?
 Le mode de passage des paramètres est erroné.
 Le nom du paramètre effectif est différent du nom du paramètre formel.
 Le type du résultat est manquant.
 Le type du paramètre effectif est incompatible avec celui du paramètre formel.

4- Si on veut remplacer la séquence 2 par l’appel d’un module :

a. Quelle sera sa nature ?

 Une procédure  Une fonction

b. Quels seront les paramètres effectifs à utiliser ?

 T, i et U0  T[i] et U0
 T et U0
 T et i
Page 2 / 4

Page 55
5- Quel sera le tableau de déclaration des objets de l’algorithme Suite ?

 T.D.O.G  T.D.O.G
Objet Type Objet Type
T Tab T Tab
U0 Entier I, U0 Entier
Max, Min Fonction
Afficher Procédure

6- Pour U0 égale à 5360, quel sera le résultat de l’affichage de l’algorithme Suite ?

T
5843 5085 7992 7173 6354 3087 8352 6147 6174

T 5843 5085 2970 6930 5940 4950 4950

Problème (11 points)

Un nombre M est dit « nombre premier sûr », s’il est un nombre premier de la forme 2*p + 1
avec p un nombre premier.
Exemples :
 Si M = 11, alors M est un nombre premier sûr. En effet, 11 est premier et il peut s’écrire sous la
forme 2*p+1 où p = 5 qui est un nombre premier.
 Si M = 31, alors M n’est pas un nombre premier sûr. En effet, 31 est premier et il peut s’écrire sous
la forme 2*p+1 où p = 15 qui n’est pas un nombre premier.
NB : Un nombre entier supérieur à 1 est dit premier s’il n’est divisible que par 1 et par lui-même.

On se propose d’écrire un programme qui permet de :

1. Remplir un tableau T par N entiers strictement supérieurs à 1 (avec 10 ≤ N < 45).
2. Trier dans l’ordre croissant les éléments premiers sûrs du tableau T suivis du reste des éléments sans
tri.
3. Afficher le tableau T résultant.
Exemple : Pour N = 10 et le tableau T suivant :

Page 3 / 4

Page 56
le contenu du tableau suivant :

T 5 25 59 23 13 47 31 100 7 107
1 2 3 4 5 6 7 8 9 10
Le programme affichera

T 5 7 23 47 59 107 25 13 31 100

1 2 3 4 5 6 7 8 9 10

Eléments premiers sûrs triés Eléments non premiers sûrs

dans un ordre croissant

Travail demandé :

1) Analyser le problème en le décomposant en modules.

2) Analyser chacun des modules envisagés.

Page 4 / 4

Page 57
 Bac 2015
Corrigé : Informatique
Sections : Math, Techniques et Sciences Expérimentales

Exercice 1 (1.25 x 3 = 3.75 points)

Afin de réaliser les tâches décrites dans la première colonne du tableau suivant, un élève fournit les
propositions suivantes. Apporter les corrections nécessaires pour que ces propositions soient les plus
adéquates relativement au choix de la structure itérative.

Tâche Proposition Correction

n= [n= donnée ("Saisir un entier positif :")] n=[ ]
Saisir un entier n Tant que (n0) faire Répéter
positif. n= donnée ("Saisir un entier positif :") n= donnée ("Saisir un entier positif :")
Fin tant que Jusqu’à (n ≥ 0)
Max = [ i  1, Max t[1] ] Max = [Max T[1] ]
Répéter
Pour i de 2 à n faire
Chercher la [ ] Si (T [i]> Max) alors
valeur maximale Max T[i] Si (T[i]> Max) alors
dans un tableau T Fin Si Max T[i]
de taille n. ii+1 Fin Si
Jusqu’à (i > n) Fin pour
Trouve= [Trouve faux] Trouve= [i  0]
Vérifier Pour i de 1 à n faire Répéter
l'existence d'un [ ] Si (T[i] = C) ii+1
caractère C dans
un tableau T de n Alors Trouve Vrai Trouve  T[i] = C
caractères. Fin si Jusqu’à (Trouve) ou (i= n )
Fin pour

Page 1 sur 4

Page 58
Exercice 2 (0.75 x 7 = 5.25 points)
Pour chacune des questions suivantes, cochez la ou les bonnes réponses.
1- Par quel appel peut-on remplacer la séquence 1 de cet algorithme ?
Proc Saisir (N)
Procedure Saisir (Var N : entier)

Proc Saisir (U0)
U0 Proc saisir (N)
2- Quelles sont les entêtes qui correspondent à la procédure Afficher?
DEF Proc Afficher (Var T : tab)
 DEF Proc Afficher (T : tab ; N : entier)
DEF Proc Afficher (i : entier ; T : tab)
DEF Proc Afficher (T[i] : entier)
3- L’entête suivante de la fonction Max est erronée : DEF FN Max (X : entier)
Quel est l’origine de l’erreur ?
Le mode de passage des paramètres est erroné.
Le nom du paramètre effectif est différent du nom du paramètre formel.
 Le type du résultat manque.
Le type du paramètre effectif est incompatible avec celui du paramètre formel.
4- Si on veut remplacer la séquence 2 par l’appel d’un module :
a. Quelle sera sa nature ?

Procédure Fonction
b. Quels seront les paramètres à utiliser ?
 T, i et U0
T[i] et U0
T et U0
T et i
5- Quel sera le tableau de déclaration des objets de l’algorithme Suite ?


Objet Type Objet Type

T Tab T Tab
U0 Entier I, U0 Entier
Max, Min Fonction
Afficher Procédure
6- Pour une valeur donnée d’U0 égale à 5360. Quel sera le résultat de l’affichage de
l’algorithme Suite ?


T 5843 5085 7992 7173 6354 3087 8352 6147 6174

T 5843 5085 2970 6930 5940 4950 4950

Page 2 sur 4

Page 59
Problème (11 points) TDNT

a) ANALYSE DU PROGRAMME PRINCIPAL Type

Résultat = PROC afficher (T, n) Vect = tableau de 44 entiers

T = PROC trier (T, nb)
T, nb = PROC ranger (T, n, nb)
T, n = PROC remplir (T, n)
TDOG

Objet T/N
T Vect
n, nb Entier
Remplir Procédure
Ranger Procédure
Trier Procédure
Afficher Procédure
b) ANALYSE DE LA PROCEDURE REMPLIR
DEF PROC remplir (var t : vect ; var n : entier)
Résultat = t, n
t= [ ]
Pour i de 1 à n faire
Répéter Objet Type
t[i]= donnée ("saisir un entier :") i Entier
Jusqu’à (t [i]>1)
Fin pour
n= [ ]
Répéter
n= donnée ("saisir un entier :")
Jusqu’à (n dans [10..44])

c) ANALYSE DE LA PROCEDURE RANGER

DEF PROC Ranger (Var t : vect ; n : entier ; Var nb: entier)
Résultat = t, nb
(t, nb) = [nb0]
Pour i de 1 à n faire
Si (FN Premier (t[i]) et (FN Premier ((t[i]-1) div 2) alors
Objet Type
nb nb+1
Premier Fonction
aux t[i]
PremSur Fonction
t[i]  t[nb]
i, j Entier
t[nb]  aux
aux Entier
Fin si
Fin pour
Fin Ranger

Page 3 sur 4

Page 60
d)ANALYSE DE LA FONCTION
DEF FN Premier (r : entier) : booléen
Résultat = premier  (r mod d=0)
d = [d 1] Objet Type
Répéter d Entier
dd+1
Jusqu’à (r mod d =0) ou (d > racinecarré(r))
Fin premier

e) ANALYSE DE LA PROCEDURE TRIER

Def Proc TRIER (VAR T : VECT ; N : ENTIER)
Résultat = T
T = [ ] Répéter
Echange  faux
Objet Type
Pour i de 1 à n-1 faire
Aux Entier
Si (T[i] > T[i+1]) alors
i Entier
AuxT[i]
Echange booléen
T[i]T[i+1]
T[i+1]Aux
Echange  vrai
Fin si
Fin pour
nn-1
Jusqu’à (n=1) ou (Echange = faux)

Page 4 sur 4

Page 61