Série de révision n°1 : Correction

Exercice 1 :
1- Compléter le tableau ci-dessous par la valeur de la variable c après exécution de chaque séquence, et ce pour
n=4.
Séquence Valeur de la variablec
1 3
2 2
3 3
2- Donner le numéro de la séquence qui ne permet pas d’afficher le nombre de diviseurs. Justifier votre
réponse. La séquence 2 : car elle détermine et affiche les diviseurs de N, moins 1
Exercice 2 :

1- Compléter la séquence algorithmique présentée ci-dessous afin de vérifier l’existence d’un nom donné NOM
dans un tableau T non vide.

Algorithme recherche
Début
Écrire ("Donner le nom à chercher : ")
Lire ( NOM)
Existe Faux
i 0
Répéter
Si (T[i] = NOM) alors
Existe Vrai
Sinon
ii+1.
Finsi
Jusqu’à (i=N) ou (Existe)
Si (Existe) alors
Écrire ("Le nom recherché existe dans ce tableau.")
Sinon
Écrire ("Le nom recherché n’existe pas dans ce tableau.")
Finsi
Fin

2- Maintenant, le médecin veut chercher les numéros des fiches de ses patients ayant le même nom. Modifier la
séquence algorithmique présentée ci-dessus afin d’afficher ces numéros.
Algorithme recherche
Début
Ecrire ("entrer le nom à chercher :") ;
Lire(NOM) ;
Pour i de 0 à N-1 Faire
Si T[i] = NOM alors
Ecrire ("Fiche n° : ", i)
Fin si
Fin pour
Fin

Page 5 sur 52
Exercice 3 :
Fonction Covid (X, N : entier) : réel
Début
f←1 /* représente i !
e←1 /*valeur initiale de e pour i=0
Px←1 /*puissance de X pour i=0
Pour i de 1 à N Faire
f← f * i
Px←Px*X
e←e+ Px /f
FinPour
Retourner e
Fin
Exercice 4 :
Algorithme du programme principal
Tableau de déclaration de nouveaux types (TDNT)
Algorithme TRADUCTION Types
Début TAB = Tableau de Nmax Chaines de caractères
Saisir (N, FR, ENG)
SaisirPH (PHF)
Traduire (N, FR, ENG, PHF, PHG, NbErreur)
Afficher (PHG , NbErreur)
Fin
TDOG :
Objet Type/Nature
Nmax Constante = 100
N, NbErreur : Nombre de mots non traduits Entier
FR, ENG TAB
PHF : phrase en français, PHG : phrase en anglais Chaine de caractère
Saisir, SaisiePH, Traduire, Afficher Procédures

Procedure Saisir (@N: entier, @FR: TAB, @ENG: TAB)

Début
Répéter
Ecrire ("Donnez le nombre de mots du dictionnaire : ") ;
Lire (N)
Jusqu’à (2 <=N<=100) TDOL
Pour i de 0 à N-1 faire Objet Type/Nature
Répéter I entier
Ecrire ("Donnez un mot en français : "); Alpha fonction
Lire (FR[i])
Jusqu'à (0<long (FR[i])<=15) et (alpha(FR[i]))
Répéter
Ecrire ("Donnez la traduction en anglais du ", FR[i], " : ");
Lire (ENG[i])
Jusqu'à (0<long (ENG[i]) <=15) et (alpha (ENG[i]))
Fin pour
Fin

Page 6 sur 52
Fonction alpha (ch : chaine) : booléen
Début
i0
test Vrai
Tantque (i<long (ch)) et (test=Vrai) faire TDOL
test Majus(ch[i]) ["A".."Z"] Objet Type/Nature
i i+1 i Entier
FinTantque test Booléen
Retourner test
Fin
********************************************************************************************
Procédure SaisirPH( @PHF:chaine)
Début
Répéter
Ecrire ("Donnez une phrase en français : ")
Lire(PHF)
Jusqu'à valide(PHF)
Fin
*******************************************************************************************
Fonction Valide (ch : chaine) : booléen
Début
i1
test Vrai TDOL
Tantque (i<long (ch) et (test=Vrai) faire Objet Type/Nature
test  (Majus(ch[i])["A".."Z"]) ou (ch[i] = " ") i entier
i  i+1 Test booléen
Fintanque
Retourner test
Fin
********************************************************************************************

Page 7 sur 52
ProcedureTraduire (N: entier, FR: Tab, ENG: Tab, PHF: chaine, @PHG: chaine, @NbErreur:entier)
Début
NbErreur 0
PHG""
Tantque(PHF ≠"") Faire
pPos (" ", PHF)
Si (p ≠ -1) alors TDOL
motSous_chaine(PHF, 0, p) Objet Type/Nature
PHF Effacer (PHF, 0, p+1) p, ind Entier
Sinon mot Chaine
mot  PHF chercher fonction
PHF""
Finsi
indChercher (mot, FR, N)
Si ind = N alors
PHGPHG+"{"+ mot + "}"+" "
NbErreurNbErreur + 1
Sinon
PHGPHG +ENG [ind]+ " "
Finsi
FinTanque
PHGsous_chaine(PHG, 0, long(ch)-1)
Fin
********************************************************************************************
Fonction Chercher (mot : Chaine, FR : Tab, N : entier): entier
Début
i0
TDOL
Tantque (i<N) et (FR[i] ≠ mot) faire Objet Type/Nature
ii+1 i Entier
FinTanque
Retourner i
Fin
********************************************************************************************
Procédure Afficher (PHG : chaine, NbErreur :entier)
Début
Si (NbErreur = 0) alors
Ecrire (PHG, " : Traduction totale")
Sinon
Ecrire (PHG, " : Traduction partielle", NbErreur, "Mot(s) non traduit(s) ")
Fin si
Fin

Page 8 sur 52
 Série de révision n°2 : Correction
Exercice 1 :
Dans un contexte algorithmique et pour chacune des propositions ci-dessous, cochez, en mettant une crois (X) dans
la case qui correspond à l’unique bonne réponse.
1) Quelle est la valeur de Z après l'instruction suivante :
Z10 / 5 + 10 div 5 + 10mod 5 ;

X Z=4
Z=2
Z=3

2) Quelle est l'instruction erronée parmi les suivantes ?

X X + 2
X X
X 2X
3) quelle est la valeur finale de A et B après exécution de la séquence suivante :
A←50
B←30
A←B
B←A
X A=30 et B=30
A=30 et B=40
A=40 et B=30

4) A quelle condition la boucle suivante s'arrête-t-elle ?

Répéter
..
Jusqu’à (x=b) Ou Non(x=0)

x différent de b ou égale à zéro

X x égale à b ou différent de zéro
x égale à b et différent de zéro

5) Laquelle des instructions suivantes est fausse ?

X Lire (5)
Ecrire(5)
Ecrire ("5")

Page 13 sur 52
Exercice 2 :
Fonction heureux (n : entier) : booléen
Début
chconvch(n)
test faux
limite  faux
Tantque (test = faux) et (limite = faux) faire TDO
s0 Objet Type/Nature
Pour i de 0 a long(ch)-1 faire test, limite Booléen
ss+ valeur(ch[i])*valeur(ch[i]) ch Chaine
FinPour s, i Entier
Si s=1 alors
test vrai
FinSi
Si s<10 alors
limite  vrai
FinSi
ch convch(s)
FinTantque
Retourner test
Fin

Exercice 3 :

3- Donner le contenu du tableau L après exécution du code ci-dessus.

"un", "deux", "deux", "deux", "cinq"
4- Corriger le code précédent de sorte que dans le tableau T on aura le contenu suivant :
"un", "trois", "quatre", "deux", "cinq"

Pour i de 0 à 3 faire
mi i
Pour j de i+1 à 4 faire
Si L[mi] < L [j] alors
mi j
Fin SI
Fin Pour
e L [mi]
L [mi]  L [i]
L[i]  e
Fin Pour

Page 14 sur 52
Exercice 4 :
Algorithme de programme principal :
Algorithme bonus
Début Tableau de déclaration de nouveaux types (TDNT)
Saisir (n) Types
RemplirT (T, n) Tab1= Tableau de 100 Chaines de caractères
RemplirC (C, n) Tab2= Tableau de 100 réels
Afficher (T, C, n)
Fin
TDOG :
Objet Type/Nature
N Entier
T Tab1
C Tab2
Saisir , RemplirT, RemplirC , Afficher Procédures
Procedure Saisir(@n:entier)
Début
Répéter
Ecrire ("Donnez le nombre de clients : ") ;
Lire (n)
Jusqu’à (10 <=n<=100)
Fin
*******************************************************************************************
Procedure RemplirT(@T:Tab1, n:entier) TDOL
Début Objet Type/Nature
i entier
Pour i de 0 à n-1 faire Existe fonction
Répéter
Ecrire ("Donnez le numéro de téléphone de client n° ", i+1, " : ");
Lire(T[i])
Jusqu'à (Estnum(T[i])=vrai) et (long(T[i])=8) et (sous_chaine(T[i], 0, 2)  ["65", " 66"]) et (Existe(T[i], T, i)=faux)

Fin pour
Fin
*******************************************************************************************
Fonction Existe (ch :chaine, T :Tab1, i :entier) :booléen
Début
testfaux
j0
Tantque (test=faux) et (j<i) faire TDOL
Si T[j]=ch alors Objet Type/Nature
test vrai j Entier
Sinon test Booléen
jj+1
FinSi
FinTantque
Retourner test
Fin

Page 15 sur 52
Procédure RemplirC(@C:Tab2, n:entier)
Début TDOL
Objet Type/Nature
Pour i de 0 à n-1 faire i entier
Répéter
Ecrire ("Donnez la consommation téléphonique de client n° ", i+1, " : ");
Lire(C[i])
Jusqu'à (C[i] ≥ 0)
Fin pour
Fin
********************************************************************************************
Procédure Afficher(T :Tab1, C :Tab2, n :entier) TDO
Début Objet Type/Nature
mMoyenne(C, n) i Entier
Écrire ("Le montant moyen des consommations est :", m) Moyenne Fonction
Pour i de 0 à n-1 faire Bonus Fonction
Si C[i] ≥ m alors
Ecrire ("Le numéro ", T[i], "a gagné :", Bonus(T[i]), "DT")
FinSi
FinPour
Fin
********************************************************************************************
Fonction Moyenne(C :Tab2, n :entier) :réel
Début
s0
Pour i de 0 à n-1 faire
TDOL
ss + C[i] Objet Type/Nature
FinPour i Entier
Retourner s/n s Réel
Fin
********************************************************************************************
Fonction Bonus (ch: chaine): entier
Début
TDOL
s 0
Objet Type/Nature
Pour i de 2 à long(ch)-1 faire
i Entier
ss + valeur(ch[i]) s Entier
FinPour
Retourner s*20
Fin

Page 16 sur 52
Exercice 5 :
Algorithme de programme principal :
Algorithme
Début Tableau de déclaration de nouveaux types (TDNT)
Saisir (N) Types
Remplir (TL, TP, N) Tab= Tableau de 50 Chaines de caractères
SaisirCarte(NCIN)
Afficher (NCIN, TL, TP, N)
Fin
TDOG :
Objet Type/Nature
N Entier
NCIN Chaine de caractères
TL, TP Tab
Saisir , Remplir ,SaisirCarte, Afficher Procédures

*******************************************************************************************
Procedure Saisir(@N:entier)
Début
Répéter
Ecrire ("Donnez le nombre d’utilisateurs: ") ;
Lire (N)
Jusqu’à (4 <=N<=50)
Fin
*******************************************************************************************
Procedure Remplir(@TL, @TP :Tab, N:entier) Objet Type/Nature
Début
i Entier
num, pw Chaine
Pour i de 0 à N-1 faire
Existe fonction
Répéter
Ecrire ("Donnez le NCIN de l’utilisateur n° ", i+1, " : ");
Lire(num)
Jusqu'à (Estnum(num)=vrai) et (long(num)=8) et (Existe(num, TL, i)=faux)
TL[i]"CIN"+num
pw""
Pour j de 0 à long(num)-1 faire
pwpw+ chr(ord("A")+valeur(num[j]))
FinPour
TP[i]pw
Fin pour
Fin

Page 17 sur 52
Fonction Existe (num :chaine, TL :Tab, i :entier) :booléen
Début
testfaux
j0
Tantque (test=faux) et (j<i) faire Objet Type/Nature
Si sous_chaine(TL[j], 3, 11)=num alors i Entier
test vrai test Booléen
Sinon
jj+1
FinSi
FinTantque
Retourner test
Fin
********************************************************************************************
Procédure SaisirCarte(@NCIN:entier)
Début
Répéter
Ecrire ("Donnez le NCIN :");
Lire(NCIN)
Jusqu'à (Estnum(NCIN)=vrai) et (long(NCIN)=8)
Fin
********************************************************************************************
Procédure Afficher (NCIN : chaine, TL, TP :Tab, N :entier)
Début Objet Type/Nature
p Chercher (NCIN, TL, N) p Entier
Si p = N alors Chercher Fonction
Ecrire ("Vérifier le NCIN")
Sinon
Ecrire ("Login :", TL[p], "Mot de passe :", TP[p])
FinSi
Fin
*****************************************************************************************
Fonction Chercher (NCIN : chaine, TL :Tab, N :entier) :entier
Début
i0
Tantque (i<N) et (sous_chaine(TL[i], 3, 11)≠ NCIN) faire TDOL
i i+1 Objet Type/Nature
FinTantque i Entier
Retourner i
Fin

Page 18 sur 52
 Série de révision N°3 : Correction
Exercice 1

1) Compléter le tableau ci-dessous par la valeur de la variable ok après exécution de chaque séquence, et
ce pour ch="Sweet".
Séquence Valeur de la variable ok
1 vrai
2 faux
3 faux

2) Donner le numéro de la ou (les) séquence(s) qui ne permet pas de vérifier si la chaine est distincte.
Justifier votre réponse.
La séquence n°1 : car elle permet de vérifier si le dernier caractère est différent des autre caractères de la
chaine.

Exercice2 :
1- Peut-on admettre le tableau T comme résultat possible de l’algorithme inconnu ? Justifier votre réponse.

Non : Car les éléments du tableau ne sont pas distincts. 1111 et 2344 se répètent deux fois dans le tableau.
2- Déduire le rôle de l’algorithme inconnu.

Remplir le tableau T par n nombres aléatoires distincts composés de quatre chiffres.

3- Compléter les tableaux des déclarations des objets et des nouveaux types de l’algorithme ci-dessus :
T contient 30 éléments au maximum.
TDO
TDNT T/N
Objet
T Tab
Type
Ch chaine
Tab = tableau de 30 entiers ch1 chaine
N entier
I entier
4- Ecrire l’algorithme d’un module qui permet d’afficher les éléments automorphes du tableau T. Un entier N
est dit automorphe si son carré N2 se termine par N.

Procédure afficher(T :tab, n :entier)

Début
Pour i de 0 à n-1 faire
sT[i]*T[i]
chconvch(s)
Effacer (ch, 0, long(ch)-4)
Si valeur(ch)=T[i] alors
Ecrire(T[i])
FinSi
FinPour
Fin

Page 22 sur 52
Exercice 3 :
Algorithme de programme principal :
Algorithme Covid
Début Tableau de déclaration de nouveaux types
Saisir (n) (TDNT)
Remplir (CODES, VACCINATION, n) Types
SaisirEssai(essai) tab1= Tableau de 1000 Chaines de caractères
Afficher (CODES, VACCINATION, n, essai)
tab2= Tableau de 1000 entiers
Fin
TDOG :
Objet Type/Nature
n Entier
CODES tab1
VACCINATION tab2
Essai Chaine
Saisir, Remplir, SaisirEssai, Afficher Procédures

********************************************************************************************
Procedure Saisir(@n:entier)
Début
Répéter
Ecrire ("Donnez le nombre de personnes: ") ;
Lire (n)
Jusqu’à (1 <=n<=1000)
Fin
****************************************************************************************
Procedure Remplir(@CODES:tab1, @VACCINATION:tab2, n:entier)
Début

Pour i de 0 à n-1 faire

Répéter
Ecrire ("Donnez le code d’inscription de personne n° ", i+1, " : ")
Lire(CODES[i])
Jusqu'à (Estnum(CODES [i])) et (long(CODES[i])=9) et (CODES [0]≠"0") et (Existe(CODES [i], CODES, i)=faux)

Répéter
Ecrire ("Donnez l’état de vaccination de personne n° ", i+1, " : ")
Lire (VACCINATION[i])
Jusqu'à VACCINATION[i] [0, 1, 2]
Fin pour
TDOL
Fin
Objet Type/Nature
i Entier
Existe Fonction

Page 23 sur 52
Fonction Existe (ch :chaine, CODES :tab1, i :entier) :booléen
Début
testfaux
j0
Tantque (test=faux) et (j<i) faire TDOL
Si CODES[j]=ch alors Objet Type/Nature
test vrai j Entier
Sinon test Booléen
jj+1
FinSi
FinTantque
Retourner test
Fin
********************************************************************************************
Procédure SaisirEssai(@essai: chaine)
Début
Répéter
Ecrire ("Donnez un essai :");
Lire(essai)
Jusqu'à (sous_chaine(essai,0, 6)="*2021*") et (essai[long(essai)-1]="#")
Fin
********************************************************************************************
Procédure Afficher (CODES : tab1, VACCINATION: tab2, n : entier, essai : chaine)
Début
code sous_chaine (essai, 6, long (essai)-1) TDOL
Si NON (Estnum(code) et long(code)=9 et code[0]≠ "0") alors Objet Type/Nature
Ecrire ("Erreur code")
code chaine
Sinon
p entier
pChercher (code, CODES, n)
Chercher fonction
Si p = N alors
Ecrire ("Vérifiez votre code d’inscription ou bien il se peut que vous n’êtes pas encore inscrit")
Sinon Si VACCINATION[p] =0 alors
Ecrire ("Vous n’êtes pas encore vacciné")
Sinon Si VACCINATION[p] =1 alors
Ecrire ("Vous avez reçu la première dose de vaccin")
Sinon
Ecrire ("Vous avez reçu les deux doses de vaccin" )
FinSi
FinSi
Fin
Fonction Chercher (code : Chaine, CODES : tab1, n : entier): entier
Début
i0
TDOL
Tantque (i<N) et (CODES[i] ≠ code) faire Objet Type/Nature
ii+1 i entier
FinTantque
Retourner i
Fin

Page 24 sur 52
 Série de révision N°4 : correction
Exercice 1 :
Mettre une croix  dans les propositions correctes.
b- Soit l’instruction C  SOUS-CHAINE ("informatique", 0, 4).

Elle permet d’affecter à C la valeur "infor"

La variable C doit être de type caractère
X La variable C doit être de type chaine de caractère

f- X  Arrondi(2.51) - 1 * 65 mod 2*3

X=10
X X=0
X=6
X=-2

g- Soit l’instruction A Alea (0, 10) – 5 permet d’affecter à la variable A une valeur aléatoire de l’intervalle :

[0..5]
[5..10]
X [-5..5]
[-5..10]

h- Soit la séquence d’instructions ci-dessous. Combien de fois s’exécute le bloc d’instructions

Traitement sachant qu’il ne modifie pas le contenu de la variable a ?

a 1, b  0
Répéter
Traitement
b a+4
Jusqu’à a = 10

1 fois
3 fois
5 fois
X A l’infini

i- Soit le bloc d’instructions suivant :

Pour K de 0 à 4 Faire
Instruction_Cle
Fin Pour

Page 29 sur 52
 Déterminer à chaque fois le rôle de ce bloc d’instructions lorsqu’on remplace "Instruction_Cle" par une
instruction donnée. (T est un tableau de 5 entiers positifs)

- Instruction_Cle = T[K]  T[k]*2

Diviser par deux les éléments de T.
Calculer le produit des éléments de T.
X Multiplier par deux les éléments de T.
Calculer la somme des éléments de T.

- Instruction_Cle = Si ((K MOD 2) = 0) Alors T[k]  T[k] DIV 2 Fin Si

Multiplier par deux les éléments d’indice pair de T.

Diviser par deux les éléments d’indice impair de T.
Multiplier par deux les éléments d’indice impair de T.
Diviser par deux les éléments d’indice pair de T.
X

- Instruction_Cle = Si ((K MOD 2) = 0) Alors T[k]  T[k] + 2 Fin Si

X Ajouter deux aux éléments d’indice pair de T.

Ajouter deux aux éléments impairs de T.
Ajouter deux aux éléments d’indice impair de T.
X Ne changer pas les éléments impairs du T.

Exercice 2 :
Questions :
1) a- Compléter les tableaux de déclaration des nouveaux types et des objets. T est un tableau qui contient au
maximum 30 éléments.

TDNT
Type
TAB = Tableau de 30 chaines de caractères

TDO
Objets Type / Nature
T TAB
N entier
i entier
ch chaine

b- Compléter le tableau suivant, soit par les résultats générés par le bloc algorithmique relatif aux éléments de
tableau T, soit par des éléments de T permettant d’aboutir aux résultats mentionnés dans le tableau.

Tableau T "Baccalauréat" "Examen" "Net@" "Informatique" "Bac2022" "Graphique"

Résultats OUI OUI NON OUI NON OUI

Page 30 sur 52
c- Déduire le rôle de ce bloc algorithmique.
Permet de déterminer et afficher si chaque élément du tableau T est une chaine de caractères
alphabétiques ou non.
2- On désire modifier l’affichage dans le bloc algorithmique ci-dessus de telle sorte que si la condition est vérifiée,
on affiche l’élément de tableau T, sinon on élimine tous les caractères non alphabétiques de cet élément puis on
l’affiche.

Ancien affichage Nouvel affichage

Si ch="" Alors
Si ch="" Alors Ecrire (T[i])
Ecrire ("OUI") Sinon
Sinon ch1T[i]
Ecrire ("NON") j0
Fin Si Tantque j<long (ch1) faire
Si NON (Majus(ch1[j]) ["A".."Z"]) alors
Effacer (ch1, j, j+1)
Sinon
jj+1
FinSi
FinTantque
T[i]ch1
Ecrire (T[i])
Fin Si

Exercice 4 :
Algorithme du programme principal
Algorithme EXAMEN
Début Tableau de déclaration de nouveaux types (TDNT)
Saisir (N) Types
Remplir (M, S, N) TAB = Tableau de 100 Chaines de caractères
Ecrire ("Donner un symptôme :")
Lire(Sym)
Afficher (M, S, N, Sym)
Fin
TDOG :
Objet Type/Nature
N Entier
M, S TAB
Sym Chaine de caractère
Saisir , Remplir, Afficher Procédures
Procedure Saisir(@N:entier)
Début
Répéter
Ecrire ("Donnez le nombre de maladies: ")
Lire (N)
Jusqu’à (2 <=N<=100)
Fin

Page 31 sur 52
Procedure Remplir(@M:TAB, @)S:TAB, N:entier)
Début TDOL
Pour i de 0 à N-1 faire Objet Type/Nature
Répéter i Entier
Ecrire ("Donnez une maladie : "); alpha Fonction
Lire(M[i]) valide Fonction
Jusqu'à (0<long(M[i])) et (alpha(M[i]))
Répéter
Ecrire ("Donnez les symptômes relatifs au maladie ", M[i], " : ");
Lire(S[i])
Jusqu'à ( 0<long(S[i])) et (valide(S[i]))
Fin pour
Fin
********************************************************************************************
Fonction alpha (ch : chaine) : booléen
Debut
i0
test Vrai
Tantque (i<long(ch)) et (test=Vrai) faire TDOL
test ch[i] ["A".."Z", " "] Objet Type/Nature
i i+1 i Entier
Fin tantque test Booléen
Retourner test
Fin
********************************************************************************************
Fonction valide(ch : chaine) : booléen
Debut
i0 TDOL
test Vrai Objet Type/Nature
Tantque (i<long(ch)) et (test=Vrai) faire i entier
test ch[i] ["A".."Z", " ", "#"] test booléen
i i+1
Fin tantque
Retourner (test ) et (ch[0] ≠ "#") et (ch[long(ch)-1] ≠ "#")
Fin
***************************************************************************************************

Procédure Afficher (M, S :TAB , N :entier, Sym :chaine)

Début
Pour i de 0 à N-1 faire TDOL
Objet Type/Nature
Si pos (Sym, S[i]) ≠ -1 alors i entier
Ecrire (M[i])
Fin Si
Fin Pour
Fin

Page 32 sur 52
 Série de révision N°5 - Correction
Exercice 1 :

1- Compléter le tableau ci-dessous par la valeur de la variable n après exécution de chaque séquence, et ce pour
ch= "Python est un langage de programmation".

Séquence Valeur de la variable n

1 6
2 5
3 6

2- Donner le numéro de la séquence qui ne permet pas d’afficher le nombre de mots. Justifier votre réponse.

Séquence 2 : car elle permet de déterminer et afficher le nombre de mots dans ch, moins 1. En effet
le dernier mot ne sera pas pris en compte.

Exercice 2 :
1- Quelle est la valeur de Res pour chacun des cas suivants :
ch= "aaDDDkkkkkgGGw" Res= "1a2D4k0g1G"
ch="tttTThhhhpxxxxnNjjjjjjj" Res="2t1T3h0p3x0n0N"
2- Corriger le code précédent pour avoir le résultat attendu.

Res ""
s1
Pour i de 0 à long(ch)-2 faire
Si ch[i]=ch[i+1] alors
ss+1
Sinon
Res Res + convch(s)+ch[i]
s1
FinSi
FinPour
Res Res + convch(s)+ch[long(ch)-1]

Page 38 sur 52
Exercice 3 :

Fonction multiplication (A, B :entier) :entier

Debut
s0
Tantque A≠1 faire
Si A mod 2 ≠0 alors
ss+B
FinSi
AA div 2
BB*2
FinTantque
Retourner s+B
Fin

Exercice 4
1) Algorithme du programme principal : TDOG
Algorithme Hitparade
Objet Type/Nature
Début
TDNT T1 Tab1
Chanson(T1)
Saisir(N) Nouveau type T2 Tab2
Score (T2, N) Tab1=tableau de 5 chaînes N Entier
Trier (T1, T2) Tab2=tableau de5 entiers Saisir Procédure
Afficher (T1, T2) Chanson Procédure
Fin
Score Procédure
Trier Procédure
2) Les algorithmes des modules envisagés:
Procédure Chanson(@T1 :Tab1) Afficher Procédure
Début
Pour i de 0 à 4 faire
Répéter TDOL
Ecrire ("Saisir le titre de la chanson n°", i+1 ,":") Objet Type/Nature
Lire (T1 [i]) i entier
Jusqu’à (long(T[i]>0) et (alpha (T1[i])=vrai) alpha Fonction
Finpour
Fin
********************************************************************************************
Fonction alpha (ch : chaine) : booléen
Début
test vrai
i0 TDOL
Tantque (i<long (ch)) et (test=vrai) faire Objet Type/nature
testmajus(ch[i])∈ ["A".."Z"] test Booléen
ii+1 i Entier
Fin Tantque
Retourner test
Fin

Page 39 sur 52
Procédure Saisir (@ N:entier)
Début
Répéter
Ecrire ("Saisir le nombre de participants:")
Lire(N)
Jusqu’à N [5..100]
Fin
********************************************************************************************
Procédure Score(@T2 :Tab2, N:entier)
Début
Pour i de 0 à 4 faire TDOL
T2 [i]0 Objet Type/nature
Finpour i, num entier
Pour i de1 à N faire
Répéter
Ecrire ("Saisir le numéro de la chanson:")
Lire (num)
Jusqu’à (num[1..5])
T2[num-1]T2[num-1]+3
Finpour
Fin
********************************************************************************************
Procédure Trier(@T1 :Tab1,@T2 :Tab2) Procédure Afficher (T1:Tab1, T2 :Tab2)
Début
Début
Pour i de 0 à 3 faire
indicei Ecrire ("Le classement est :")
Pour j de i+1 a 4 faire rang1
Si T2[j]> T2[indice] alors Ecrire ("Rang", rang,":", T1[0])
indicej
Fin si Pour i de1 à 4 faire
Fin pour Si (T2[i]=T2[i-1])alors
Si indice ≠i alors Ecrire (",", T1[i])
Aux1T2[indice]
Sinon
T2[indice]T2[i]
T2[i]Aux1 rangrang+1
Aux2T1[indice] Ecrire ("Rang",rang,":",T1[i])
T1[indice]T1[i]
Fin si
T1[i]Aux2
Finsi Fin pour
Finpour Fin
Fin
TDOL
Objet Type/nature
i, rang entier
TDOL
Objet Type/Nature
i, j, indice, Aux1 Entier
Aux2 Chaine

Page 40 sur 52
Exercice 5 :
TDOG
Algorithme de programme principal : Objet T/N
Algorithme cryptage msg Chaine Le message à crypter
Début Crypter Fonction Retourner la chaine cryptée
Saisir (msg) Saisir procédure Saisir le message à crypter
Ecrire ("Le message crypté est : ", Crypter (msg))
Fin

Procédure Saisir (@ msg :chaine)

Début Saisir une chaine (msg) composée par des
Répéter mots séparés par un seul espace et ne
contenant aucun signe de ponctuation.
Ecrire ("Saisir le message à crypter : ")
Lire (msg)
Jusqu’à valide (msg)
Fin
*************************************************
Fonction valide (msg:chaine): booléen
Debut
i 0
test faux
Tantque (i<long(ch)) et (test =faux) faire
test msg[i]  [",",".",",",";","!","? ", ":"]
i i+1
FinTantque
Retourner (pos (" ", msg) = -1) et (test=faux)
Fin TDOL
*************************************************** Objet T/N
i, n1, n Entier
ch Chaine
T Tab
Fonction Crypter (msg: chaine) : chaine T1 Tab
Début Repartir Procedure
Separer (msg, T, n) Separer Procedure
AjouterEtoiles (T, n, n1) AjouterEtoiles Procedure
Repartir (T, n, T1, n1)
ch"" Concaténer les mots obtenus dans T1 en
Pour i de 0 a n1-1 faire les séparant par un espace pour obtenir le
ch ch +T1[i] + " " message crypté.
Fin pour
ch sous-chaine (ch,0 , long(ch) – 1) Effacer l’espace qui se trouve a la fin de la
retourner ch chaine cryptée.
Fin

TDNT

Type
Tab = tableau de 20 chaines

Page 41 sur 52
 Procédure Separer (msg : chaine, @T :tab, @ n :entier) Placer les mots de la chaine à cryptée dans
Début un tableau T de taille n.
n 0
Tantque msg ≠ "" faire
ppos (" ", ch)
Si p ≠ -1 alors
T[n] sous-chaine (msg, 0, p)
Effacer (ch, 0, p+1)
n n+1
Sinon TDOL
T[n] msg Objet T/N
msg"" p Entier
FinSi
FinTantque
Fin
*************************************************
Procédure AjouterEtoiles (@T :tab, n :entier, @n1 :entier)
- Pour chaque élément du tableau T,
Début
ajouter autant de fois le caractère "*"
n1 long(T[0])]
pour que sa longueur sera égale a celle
Pour i de 1 a n-1 faire
du mot le plus long dans le tableau T
Si (long(T[i]) > n1) alors
- n1 est la longueur de la chaine la plus
n1  long(T[i])
longue dans T
Fin si
TDOL
Fin pour
Objet T/N
Pour i de 0 a n-1 faire i Entier
Tantque long(T[i]) < n1 faire
T[i] T[i] + "*"
FinTantque
Fin pour
Fin
************************************************** Repartir les lettres des mots du tableau T
Procédure Repartir(T :tab, n :entier, @T1 :tab, n1 :entier) dans un nouveau tableau T1 de taille n1
Debut
Pour i de 0 a n1-1 faire
T1[i]  ""
Pour j de 0 a n-1 faire TDOL
T1[i] T1[i]+ T[j][i] Objet T/N
Fin pour i, j Entier
Fin pour
Fin

Page 42 sur 52
 Série de révision N°6- Correction
Exercice 1 :
Dans un contexte algorithmique et pour chacune des propositions ci-dessous, cochez, en mettant une crois (X) dans
la case qui correspond à la bonne réponse.
1- Quelle est la valeur de X après l'instruction suivante : x 71 MOD 12 DIV 2*5+ 18/3*2
13
28
X 37
2- Quelle est l'instruction erronée parmi les suivantes ?
Lire (n)
X Lire ("n")
Lire (n, m)
3- Quelle est la valeur finale de a et b après exécution de la séquence suivante :
a  25478
b0
Pour i de 0 à 3 faire
bb+a MOD 10
aa DIV 10
FinPour

a=25 et b= 24
x a=2 et b=24
a=2 et b=25
4- A quelle condition la boucle suivante s’arrête-t-elle ?
Tantque (N MOD 2 ≠ 0) OU NON (N≤50) Faire
……….
FinTantque

N est un nombre impair strictement supérieur à 50

N est un nombre pair strictement supérieur à 50
X N est un nombre pair inferieur ou égal à 50

Exercice 2 :
Procédure premiers (N :entier)
Début
Pour i de 2 à N faire
j 2
Tantque j ≤ i div 2 et i mod j ≠0 faire
jj+1
FinTantque
Si j > i div 2 alors
Ecrire(i)
FinSi
Fin Pour
Fin

Page 47 sur 52
Exercice 3 :

On désire chercher le nombre d’occurrences de minimum dans un tableau T de N entiers. Pour cela, on donne le
tableau de déclaration des objets suivant :

Objet Type/Nature
T Tableau de N entier
N, i, m, occ Entier

- Compléter la séquence algorithmique présentée ci-dessous afin de chercher le nombre d’occurrences de

minimum dans le tableau T
Début
mT[0]
Pour i de 1 à n-1 faire
Si T[i] < m alors
mT[i]
FinSi
FinPour
Ecrire ("Le minimum est", m)
occ 0
Pour i de 0 à n-1 faire
Si T[i]=m alors
occocc+1
FinSi
FinPour
Ecrire ("Le nombre d’occurrences de minimum est", occ)
Fin
Exercice 4 :

Algorithme de programme principal :

Algorithme Devinette
Début Tableau de déclaration de nouveaux types
Saisir (N) (TDNT)
RemplirLD (LD, N) Types
RemplirLP(LP, N) tab= Tableau de 10 entiers
Afficher (LD, LP, N)
Fin
TDOG :
Objet Type/Nature
N Entier
LD, LP tab
Saisir , RemplirLD ,RemplirLP, Afficher Procédures

Page 48 sur 52
Procedure Saisir(@N:entier)
Début
Répéter
Ecrire ("Donnez N: ") ;
Lire (N)
Jusqu’à (3 <=N<=10)
Fin
********************************************************************************************
Procedure RemplirLD(@LD:tab, N:entier)
Début
Pour i de 0 à N-1 faire TDOL
Répéter
Objet Type/Nature
LD[i]Alea(1, 100) i entier
Jusqu'à (Existe (LD [i], LD, i)=faux)
Existe fonction
Fin pour
Fin
********************************************************************************************
Fonction Existe (x : entier, LD :tab, i :entier) :booléen
Début
testfaux
j0
Tantque (test=faux) et (j<i) faire TDOL
Si LD[j]=x alors Objet Type/Nature
test vrai j Entier
Sinon test Booléen
jj+1
FinSi
FinTantque
Retourner test
Fin
********************************************************************************************
Procédure RemplirLP(@LP:tab, N:entier)
Début
Pour i de 0 à n-1 faire
Répéter TDOL
Ecrire ("Donner le nombre n° ", i+1 , " :") Objet Type/Nature
Lire(LP[i]) i entier
Jusqu'à (LP[i][1..100] et (Existe(LP [i], LP, i)=faux) Existe fonction
Fin pour
Fin

********************************************************************************************

Page 49 sur 52
Procédure Afficher (LD , LP: tab, N : entier)
Début
TDOL
score 0
Pour i de 0 à N-1 faire Objet Type/Nature
indice  Chercher (LP[i], LD, N) i entier
Si indice=i alors score entier
scorescore+5 indice entier
Sinon si indice <N alors Chercher fonction
scorescore+2
FinSi
FinPour
Pour i de 0 à N-1 faire
Ecrire (LD[i]), LP[i])
FinPour
Ecrire ("Votre score est:", score)
Fin

Fonction Chercher (x :entier, TD : tab, N :entier): entier

Début
i0
TDOL
Tantque (i<N) et (TD[i] ≠ x) faire Objet Type/Nature
ii+1 i entier
Fintanque
Retourner i
Fin

Page 50 sur 52
Exercice 5 :
Algorithme de programme principal :
Algorithme TirArc
Début Tableau de déclaration de nouveaux types
Saisir (N) (TDNT)
Joueurs (A, N) Types
Scores(S, N) Tab1= Tableau de 20 chaines
Trier (A, S, N) Tab2= Tableau de 20 entiers
Afficher (A, S, N)
Fin
TDOG :
Objet Type/Nature
N Entier
A Tab1
S Tab2
Saisir , Joueurs ,Scores, Trier, Afficher Procédures

Procedure Saisir(@N:entier)
Début
Répéter
Ecrire ("Donnez le nombre de joueurs: ") ;
Lire (N)
Jusqu’à (2 <=N<=20)
Fin
********************************************************************************************
Procedure Joueurs(@A:tab, N:entier)
Debut
Pour i de 0 à N-1 faire
Répéter TDOL
Ecrire ("Donnez le nom de joueur n°", i+1, ": ")
Objet Type/Nature
Lire (A[i])
i entier
Jusqu'à (0 < long (A[i])) et (alpha(A[i]))
alpha fonction
FinPour
Fin
********************************************************************************************
Fonction alpha( ch : chaine) : booléen
Début
i0
test Vrai
Tantque (i<long(ch)) et (test=Vrai) faire TDOL
test Majus(ch[i]) ["A".."Z"] Objet Type/Nature
i i+1 i entier
Fin tantque test booléen
Retourner test
Fin

Page 51 sur 52
Procédure Scores (@S:Tab2, N:entier)
Début
Pour i de 0 à N-1 faire TDOL
score0 Objet Type/Nature
Pour j de 1 à 3 faire i, j, essai, score entier
Répéter
Ecrire ("Donner l’essai n° ", i , " :")
Lire(essai)
Jusqu'à (essai[0..10] )
score score+essai
FinPour
S [i]score
Fin pour
Fin
*******************************************************************************************
Procédure Trier(@A :Tab1,@S :Tab2, N : entier)
Début
Pour i de 0 à N-2 faire
indicei
Pour j de i+1 a N-1 faire
Si S[j]> S[indice] alors
indicej
Fin si
Fin pour TDOL
Si indice ≠i alors Objet Type/Nature
Aux1S[indice] i, j, indice, Aux1 Entier
S[indice]S[i]
Aux2 Chaine
S[i]Aux1
Aux2A[indice]
A[indice]A[i]
A[i]Aux2
Finsi
Finpour
Fin

********************************************************************************************
Procédure Afficher (A :Tab1 , S:Tab2, N : entier)
Début TDOL
Pour i de 0 à N-1 faire Objet Type/Nature
Ecrire (A[i]), S[i]) i entier
FinPour
Fin

Page 52 sur 52