Vous êtes sur la page 1sur 96

http://www.najah.

com 

Solution du sujet T1 -1

Exercice 1
Analyse de la procédure Chercher
Résultat = Afficher l'existence ou non du mot dans chaque ligne du fichier
Traitement :
- Lire la première ligne et chercher l'existence du mot dans cette ligne puis afficher le message
correspondant.
- Répéter ce traitement pour toutes les lignes, jusqu'à la fin du fichier.
Tant que Non ( Fin_fichier (FT)) Faire
Lire (FT , ligne)
Si Position (mot , ligne) ≠ 0 Alors Ecrire("Le mot : ", mot, " existe pas dans la ligne ",
i)
Sinon Ecrire ("Le mot : ", mot, " n'existe pas dans la ligne ", i)
Fin Si
i Åi+1
Fin tant que

- Ouvrir le fichier et initialiser le compteur des lignes à 1


Ouvre (FT)
iÅ1
- Fin chercher

Algorithme
0) Procédure chercher (VAR FT : Texte ; ligne, mot : chaîne de caractères)
1) Ouvre (nom_logique)
2) i Å 1
4) Tant que Non ( Fin_fichier (FT)) Faire
Lire (FT, ligne)
Si Position (mot, ligne) ≠ 0 Alors Ecrire ("Le mot : ", mot, " existe pas dans la ligne ",
i)
Sinon Ecrire ("Le mot : ", mot, " n'existe pas dans la ligne ", i)
Fin Si
i Åi+1
Fin tant que
3) Fin chercher

T.D.O. Locaux
Objet Type / Nature Rôle
i Entier Compteur

Exercice 2
DOC4MTINFCS0001  Page 1 
http://www.najah.com 

Analyse de la procédure Création


Résultat : Saisir et enregistrer dans le fichier FT, des lignes de texte
Traitement :
- Ouvrir le fichier en ajout
- Dans le cas d'une erreur d'entrée/sortie, Recréer le fichier.
- Répéter la saisie et l'enregistrement des lignes de texte jusqu'à la saisie d'une ligne vide.
Fin Analyse

Algorithme de la procédure Création


0) Procédure Création (VAR FT : Texte ; ligne : Chaîne)
1) Ajouter (FT)
2) Si Erreur d'E/S Alors Recréer (FT)
Fin Si
3) Répéter
Ecrire ("Taper une ligne de texte : ");
Lire (ligne)
Si Ligne ≠ "" Alors Ecrire_nl (FT, ligne)
Jusqu'à (ligne = "")
4) Fin Création

Exercice 3 :
Analyse du programme principal
Résultat : Affichage des messages.
Traitement : - La recherche du mot et 'affichage des lignes sont réalisés par la procédure
Chercher.
- Pour afficher les lignes de texte, il faut commencer par remettre à zéro le pointeur du fichier,
puis faire une lecture de ce dernier.
- La saisie des lignes et leur enregistrement dans le fichier sont la tâche de la procédure
Création.
- Associer du nom logique "FT" au nom physique "Lignes.fch" avant de commencer la
sauvegarde des lignes dans le fichier.
Fin Analyse

Algorithme du programme principal


0) Début Programme_Mots
1) Associer (FT, "Lignes.fch")
2) Création (FT, Ligne)
3) Ecrire ("Entrer le mot recherché : "); Lire (Mot);
4) Chercher (FT, Ligne)
5) Fermer (FT)
6) Fin Programme_Mots

DOC4MTINFCS0001  Page 2 
http://www.najah.com 

T.D.O. Globaux
Objet Type / Nature Rôle
FT Fichier texte Nom logique du fichier de texte
Ligne Chaîne de caractères Ligne de texte du fichier
Mot Chaîne de caractères Le mot recherché

DOC4MTINFCS0001  Page 3 
http://www.najah.com 

Programme Pascal (pour tester la solution)

PROGRAM Program_Mots;
USES WinCrt ;

VAR
Ligne, mot : String ;
FT : Text;

PROCEDURE Chercher (VAR FT : Text ; ligne, mot : String) ;


VAR i : Integer ;
BEGIN
Reset (FT) ;
i := 1 ;
While NOT(EOF (FT)) DO
Begin
ReadLn (FT, ligne) ;
IF Pos (mot, ligne) <> 0 Then WriteLn ('Le mot : ', mot, ' existe dans la ligne ', i)
Else WriteLn ('Le mot : ', mot, ' n''existe pas dans la ligne ', i);
i := i + 1 ;
End ;
END ;

PROCEDURE Creation (VAR FT : Text ; ligne : STRING) ;


BEGIN
{$I-}
Append (FT);
IF IoResult <> 0 Then ReWrite (FT) ;
{$I+}
Repeat
Write ('Taper une ligne de texte : ');
ReadLn (ligne);
If Ligne <> '' Then WriteLn (FT, ligne) ;
Until (ligne = '') ;
END ;

{= = == = = = = = = =P P = = = = = = = = = == = =}
BEGIN
Assign (FT, 'Lignes.fch');
Creation (FT, Ligne) ;
Write('Donner un mot : '); ReadLn (mot) ;
Chercher (FT, Ligne, mot) ;
Close (FT);
END.

DOC4MTINFCS0001  Page 4 
http://www.najah.com 

Solution du sujet T1 - 2
Analyse du programme principal (Nbr_lettres)
Résultat = Afficher l'occurrence de chaque lettre et son pourcentage de présence dans le
fichier
Traitement :
Procédure qui calcule le pourcentage de présence et affiche l'occurrence et le pourcentage
pour chaque lettre. les occurrences sont dans un tableau T.
Affiche (T)

Procédure qui teste les caractères de chaque ligne pour distinguer uniquement les lettres, les
transforme en majuscule puis cumule leur nombre dans le tableau T
Cumul (FT, T, Ligne)

Procédure qui saisit et enregistre les ligne de texte du fichier.


Saisie (FT, ligne)

Procédure qui ouvre ou crée le fichier de texte


Ouvre (FT, nom);
Fin Analyse

T.D.O. Globaux
Objet Type / Nature Rôle
T Tab Tableau contenant les occurrences de chaque lettre
FT Texte nom logique du fichier de texte
Ligne Chaîne de caractères ligne de texte du fichier
Nom Chemin chemin + nom + extension du fichier
Extension Constante = FTX L'extension du nom physique du fichier

T.D. Nouveaux types


Type
Tab = Tableau de 26 Entier
Chemin = Chaîne de 50 Caractères

Algorithme
0) Début Nbr_lettres
1) Ouvre (FT, nom)
2) Saisie (FT, ligne)
3) Cumul (FT, T, ligne)
4) Affiche (T)
5) Ferme (FT)
6) Fin Nbr_lettres

DOC4MTINFCS0002  Page 1 
http://www.najah.com 

Analyse de la procédure Ouvre


Résultat = Ouvre ou créer le fichier de texte
Traitement :
Associer et ouvrir le fichier
Associer (FT, nom)
Ouvrir (FT)
Si le fichier n'existe pas il sera créer (directive de compilation {$i..}
Si erreur d'E/S alors Recréer (FT)
Fin Si
Saisir le chemin complet du fichier
Lire (nom)
nom Å nom + extension
Fin Ouvre

Algorithme
0) PROCEDURE Ouvre (VAR FT : Texte ; nom : chemin)
1) Ecrire ("Entrer le nom du fichier ") ; Lire (nom)
2) nom Å nom + extension
3) Associer (FT, nom) ; Ouvrir (FT)
4) Si erreur d'E/S Alors Recréer (FT)
Fin Si
5) Fin Ouvre

Analyse de la procédure Saisie


Résultat = Saisir les lignes de texte
Traitement :
Saisir une ligne de texte, tant que cette ligne est différente du caractère "*" qui, dans notre
cas, indique la fin de la saisie, on enregistre cette ligne dans le fichier et on répète le même
traitement.

Ecrire (" Taper une ligne de texte : ")


Lire (ligne)
Tant Que ligne ≠ "*" Faire
Ecrire_nl (FT, ligne)
Ecrire (" Taper une nouvelle ligne de texte : ")
Lire (ligne)
Fin Tant Que
Fin Saisie

Algorithme
0) PROCEDURE Saisie (VAR FT : Texte ; ligne : Chaîne de caractères)
1) Ecrire (" Taper une ligne de texte : ") ; Lire (ligne)
2) Tant Que ligne ≠ "*" Faire
Ecrire_nl (FT, ligne)

DOC4MTINFCS0002  Page 2 
http://www.najah.com 

Ecrire (" Taper une nouvelle ligne de texte : ")


Lire (ligne)
Fin Tant Que
3) Fin Saisie

Analyse de la procédure Cumul


Résultat = Cumuler le nombre de chaque lettre présente dans le fichier
Traitement :
Remettre le pointeur du fichier sur la première ligne
Ouvrir (FT)
Lire une à une les lignes du fichier puis cumuler uniquement les lettres trouvées.
Tant Que NON (Fin_Fichier (FT)) Faire
Lire_Ln (FT, ligne)
{Parcourir un à un tous les caractères de la ligne
Convertir le caractère en majuscule pour minimiser le nombre de test
Voir si le caractère appartient à l'ensemble des lettres A .. Z}
Si oui incrémenter le contenu de la case du tableau correspondante à cette
lettre }
Pour i de 1 à Longueur (ligne) Faire
ligne [i] Å Majuscule (ligne[i])
ca Å ASCII (ligne [i] ) {ou ca Å Ordre (ligne [i] ) }
Si ca DANS [ASC II ('A') .. ASCII ('Z')] Alors T[ca] Å T[ca] + 1
Fin Si
Fin Pour
Fin Tant Que
- Afin que le cumul soit exact, le tableau T doit être initialisé à zéro
Pour i de ASCII ('A') à ASCII ('Z') Faire
T[i] Å 0
Fin pour
Fin Cumul
NB : La fonction ASCII peut être remplacée par la fonction prédéfinie ORD

T.D.O. Locaux
Objet Type / Nature Rôle
i Entier Compteur
ca Entier Code ASCII d'un caractère

Algorithme

0) PROCEDURE Cumul (VAR FT : Texte ; VAR T : Tab ; ligne : Chaîne de caractères)


1) Pour i de ASCII ('A') à ASCII ('Z') Faire
T[i] Å 0
Fin pour
2) Ouvrir (FT)
3) Tant Que NON (Fin_Fichier (FT)) Faire
Lire_Ln (FT, ligne)
Pour i de 1 à Longueur (ligne) Faire

DOC4MTINFCS0002  Page 3 
http://www.najah.com 

ligne [i] Å Majuscule (ligne[i])


ca Å ASCII (ligne[i] ) {ou ca Å Ordre (ligne[i] ) }
Si ca DANS [ASC II ('A') .. ASCII ('Z')] Alors T[ca] Å T[ca] + 1
Fin Si
Fin Pour
Fin Tant Que
4) Fin Cumul

Analyse de la procédure Affiche


Résultat = Afficher le nombre d'occurrence de chaque lettre ainsi que son pourcentage (pc)
de présence par rapport aux autres lettres dont le nombre total est (nb).
Traitement :
- Parcourir l'ensemble des lettres et procéder à l'affichage
Pour i de ASCII ('A') à ASCII ('Z') Faire
Si nb > 0 Alors pc Å (T[i] *100) / nb
Sinon pc Å 0
{Pour éviter l'erreur de division par zéro}
Fin Si

Ecrire ("La lettre : ", CHR (i)," est présente : ", T[i]," fois, donc : ", pc:3:2, "
%")
Fin Pour
- Calcul du nombre total de lettres
nb Å 0
Pour i de ASCII ('A') à ASCII ('Z') Faire
nb Å nb + T[i]
Fin Pour
Ecrire ("Le nombre total de lettres dans le fichier est : ", nb)
Fin Affiche

T.D.O. Locaux
Objet Type / Nature Rôle
i Entier Compteur
nb Entier Nombre total de lettres dans le fichier
pc Réel Pourcentage de présence d'une lettre

Algorithme
0) PROCEDURE Affiche (T : Tab)
1) nb Å 0
2) Pour i de ASCII ('A') à ASCII ('Z') Faire
nb Å nb + T[i]
Fin Pour

DOC4MTINFCS0002  Page 4 
http://www.najah.com 

3) Ecrire ("Le nombre total de lettres dans le fichier est : ", nb)

4) Pour i de ASCII ('A') à ASCII ('Z') Faire


Si nb > 0 Alors pc Å (T[i] *100) / nb
Sinon pc Å 0
Fin Si
Ecrire ("La lettre : ", CHR (i)," est présente : ", T[i]," fois, donc : ", pc:3:2, " %")
Fin Pour
5) Fin Affiche

DOC4MTINFCS0002  Page 5 
http://www.najah.com 

Traduction en Pascal
PROGRAM nbr_lettres ;
USES WinCrt ; { ou CRT sous Dos }

CONST
extension = 'FTX' ;

TYPE
Tab = ARRAY [ORD ('A') .. ORD ('Z')] Of Integer ;
chemin = String [50] ;

VAR
FT : Text ;
nom : chemin ;
T : Tab ;
ligne : String ;

PROCEDURE Ouvre (VAR FT : Text ; nom : chemin) ;


BEGIN
Write ('Entrer le nom du fichier : '); ReadLn (nom) ;
nom := nom + extension ;
{$I-}

Assign (FT, nom) ;


Reset (FT);
IF IOResult <> 0 Then Rewrite (FT);

{$I+}
END;

PROCEDURE Saisie (VAR FT : Text ; ligne : String) ;


BEGIN
WriteLn (' Pour terminer la saisie des lignes du texte, taper uniquement le caractère * ') ;
WriteLn ;
Write (' Taper une ligne de texte : '); ReadLn (ligne) ;

While ligne <> '*' Do


Begin
WriteLn (FT, ligne);
Write (' Taper une nouvelle ligne de texte : '); ReadLn (ligne) ;
End;
END;

DOC4MTINFCS0002  Page 6 
http://www.najah.com 

DOC4MTINFCS0002  Page 7 
http://www.najah.com 

PROCEDURE Cumul (VAR FT : Text ; VAR T : Tab; Ligne : String);


VAR
i, ca : Integer ;

BEGIN
{Init du tableau à zéro }
For i := ORD ('A') To ORD ('Z') DO T[i] := 0 ;

{Remise à zéro du pointeur du fichier }


Reset (FT);
{Lecture du fichier ligne par ligne et cumul du nombre des lettres}
WHILE NOT (EOF (FT)) DO
Begin
ReadLn (FT, ligne);

For i:= 1 To Length (ligne) Do


Begin
ligne [i] := UpCase (ligne [i]);
{Cumul du nombre de lettre dans le tableau T }
ca := ORD (ligne [i] ) ;
IF ca IN [ORD ('A') .. ORD ('Z')] THEN T[ca] := T[ca] + 1 ;
End ;
End ;
END;

PROCEDURE Affiche (T : Tab);


VAR
nb, i : Integer ;
pc : Real ;
BEGIN
{Calcul du nombre total de lettres}
nb := 0 ;
For i:= ORD('A') To ORD('Z') do nb := nb + T[i] ;

Writeln('Le nombre total de lettres dans le fichier est : ', nb );

{Affichage de l'occurrence et du pourcentage de présence de chaque lettre}


For i := ORD ('A') To ORD ('Z') Do
Begin
IF nb > 0 THEN pc := (T[i] * 100) / nb ELSE pc := 0;
Writeln ('La lettre : ', CHR(i),' est présente : ', T[i] ,' fois, donc : ', pc:3:2, ' %') ;
End;
END;

{ ==================== P. P ======================}
BEGIN
Ouvre (FT, nom);
Saisie (FT, ligne);
Cumul (FT, T, ligne);

DOC4MTINFCS0002  Page 8 
http://www.najah.com 

Affiche (T);
END.

DOC4MTINFCS0002  Page 9 
http://www.najah.com 

Solution du sujet T1 - 3
Analyse du programme principal TOUT_RECURSIF
Résultat = Si Fn Rechercher (V, T, N ) = VRAI alors Ecrire (V , " existe dans T ") Sinon
Ecrire (V," n'existe pas dans T ")
Traitement :
- Rechercher est une fonction qui retourne un booléen indiquant la présence ou non de V dans
T.
- Une procédure Remplir permet le remplissage du tableau par des réels
- Une procédure Saisie permet la saisie et le test de l'entier N
- V est une valeur donnée
Fin TOUT_RECURSIF

Algorithme du programme principal


0) Début TOUT_RECURSIF
1) Proc saisie (N)
2) Proc remplir (T, N)
3) Ecrire ("Donner une valeur numérique ") ; Lire (V)
4) Si Fn Rechercher (V, T, N) = VRAI alors Ecrire (V , " existe dans T ") sinon Ecrire (V ,"
n'existe pas dans T ")
5) Fin TOUT_RECURSIF

Tableau de déclaration des nouveau types


Type
Tab = tableau de 100 réels

Tableau de déclaration des objets Globaux


Objet Type / Nature Rôle
T Tab Tableau d'entiers
N Entier Nombre de réels à saisir dans T
V Réel Le réel à chercher
Remplir Procédure Ranger des réels dans le tableau
Saisie Procédure Saisir la valeur de N
Rechercher Fonction Chercher l'existante ou non de V dans T

Analyse de la fonction Rechercher


Résultat = Rechercher.
Traitement : Le résultat booléen de la fonction recherche est obtenu comme suit :
- Si V = T [N] alors Rechercher Å vrai
Sinon Si n >1 Alors On appelle encore une fois la fonction Rechercher avec N-1 (appel
récursif)

Rechercher Å FN Rechercher (V, T, N-1)


Fin Si
Cet appel récursif se termine quand N-1 devient égal à 0

DOC4MTINFCS0003  Page 1 
http://www.najah.com 

- La fonction doit être initialisée à FAUX pour pouvoir quitter si la valeur V ne se trouve pas
dans le tableau T.
Rechercher Å FAUX
Fin Rechercher

Algorithme de la fonction Rechercher


0) Fonction Rechercher (V : Réel; T : Tab ; N : Entier) : Booléen
1) Rechercher Å FAUX
2) Si V = T [ N ] alors Rechercher Å VRAI
Sinon Si N n > 1 alors Rechercher Å FN Rechercher (V, T, N-1)
Fin si
3) Fin Rechercher

Analyse de la procédure Saisie


Résultat = Saisir un entier valide
Traitement :
Lire un entier N, Si (N <2) OU (N >100) Alors on recommence l'appel de la procedure Saisie
(appel recursif)
Si (N <2) OU (N >100) Alors Proc Saisie (N)
Fin Si
Fin Saisie

Algorithme de la procédure Saisie


0) Procédure Saisie (VAR N : Entier)
1) Ecrire (" Entrer le nombre de réels à saisir ") ; Lire (N)
2) Si (N < 2) OU (N > 100) Alors Proc Saisie (N )
Fin Si
3) Fin Proc Saisie

Analyse de la procédure Remplir


Résultat = Remplir un tableau T par N réels
Traitement :
- Lire (T[N])
- Si N >1 Alors on recommence l'appel de la procédure pour remplir la case d'indice N-1
(appel récursif de la procédure Remplir)
Si N > 1 Alors Proc Remplir (T, N-1)
Fin Si
Fin Remplir

Algorithme de la procédure remplir


0) Procédure Remplir (VAR T : Tab ; N : Entier)
1) Ecrire (" Entrer l’élément ", N , " : ") ; Lire (T[N])
2) Si N >1 Alors Proc Remplir (T, N-1)
Fin Si

DOC4MTINFCS0003  Page 2 
http://www.najah.com 

3) Fin Remplir

DOC4MTINFCS0003  Page 3 
http://www.najah.com 

Traduction en Pascal
PROGRAM TOUT_RECURSIF ;
USES WinCrt ;
TYPE Tab = ARRAY [1..100] OF Real ;

VAR N : Integer ;
V : Real ;
T : Tab ;

{------------------------------------------------------------------------}
PROCEDURE Saisie (VAR N : Integer) ;
BEGIN
Write ('donner un entier : '); ReadLn (N) ;
If (N<2) OR (N > 100) Then Saisie (N) ;
END ;

{------------------------------------------------------------------------}
PROCEDURE Remplir (VAR T : Tab ; N : Integer);
BEGIN
Write ('Entrer l''élèment ', N,' : ' ) ; ReadLn (T[N]) ;
If (N >1) Then Remplir (T, N-1) ;
END ;

{------------------------------------------------------------------------}
FUNCTION Rechercher (V : Real; T : TAB; N : Integer) : Boolean ;
BEGIN
Rechercher := False ;
If (V = T[N]) Then Rechercher := TRUE
Else If (N >1) Then Rechercher := Rechercher (V, T, N-1) ;
END ;

{ ======================== P P ==========================}
BEGIN
Saisie (N);
Remplir (T, N);
Write ('Donner une valeur numérique ') ; ReadLn (V) ;
If Rechercher (V, T, N) Then WriteLn (V, ' existe dans T')
Else WriteLn (V:8:3, ' n''existe pas dans T ');
END.

DOC4MTINFCS0003  Page 4 
http://www.najah.com 

Solution du sujet T1 - 4
Vu la longueur de la solution, on propose seulement le programme en Pascal
avec plusieurs commentaires et explications.

PROGRAM Videotheque ;

USES WinCrt ;

CONST
ext ='.FCH' ; { l'extension du nom physique du fichier}

TYPE
Films = RECORD
Reference : Word ;
Titre : String [40] ;
End ;

Fichier = File Of Films ;

nom_physique = String [40];

VAR
choix : Byte ;
nl : Fichier; {nom logique du fichier}
nf : nom_physique ; {le chemin du fichier }

enr : Films ;

ouvert : Boolean ;

trouve : Boolean ;
Posi : LongInt ;
Ref2 : Word ;

{ ______ Procédure d'attente sur l'appuie sur ECHAP __________ }

PROCEDURE Echap ;
VAR Rep : Char ;
BEGIN
WriteLn ;
WriteLn ('Appuyer sur la touche [ECHAP] pour continuer ...' : 20) ;

Repeat
Rep := Readkey ;
Until Rep = CHR (27) ; {27 = code ascii de la touche Echap }

END ;

DOC4MTINFCS0004  Page 1 
http://www.najah.com 

{ ________ Procédure de création d'un nouveau fichier _________ }

PROCEDURE Creation (VAR nf : nom_physique);


VAR L : Byte ;
BEGIN
ClrScr ; {Efface l'écran texte }

Writeln ('CRETATION DE FICHIER' : 50);


WriteLn ; WriteLn ;

Writeln ('Le fichier sera créer sur la racine du disque dur C '); WriteLn ;
WriteLn ('Pour des raison de compatibilité avec le SE DOS ');
WriteLn (' et avec les versions de Turbo Pascal sous Dos ') ;
WriteLn ('le nom du fichier est composé au maximum de 8 caractères ');
Writeln (' Si le nom saisit est plus long, il sera tronqué.') ;
WriteLn ;
WriteLn ('Réspecter SVP les caractères composant un nom de fichier sous DOS.') ;
WriteLN; WriteLn ;

Repeat
Write('Entrer le nom du fichier : '); ReadLn (nf);
L := Length (nf) ;
Until (L > 0) AND (L <=8 ) ;

nf := 'C:\'+nf+ext ; {le chemin du fichier }

Assign (nl, nf) ;


ReWrite(nl) ;

Writeln ;
WriteLn ('Le fichier ', nf, ' a été est crée avec succès ');
Writeln ;
ouvert := true ; { drapeau qui indique que le fichier est ouvert }
Echap ;
END;

{ _______ Procédure d'ouverture d'un fichier ___________ }

PROCEDURE Ouverture (VAR nf : nom_physique);


VAR L,er : Byte ;
Rep : Char ;
BEGIN
ClrScr ;
Writeln ('OUVERTURE D''UN FICHIER' : 50);
WriteLn; WriteLn ;

{$I-}
Repeat

Repeat
Write ('Entrer le nom du fichier : '); ReadLn (nf);
L := Length (nf) ;
Until (L > 0) AND (L <=8 ) ;

DOC4MTINFCS0004  Page 2 
http://www.najah.com 

nf := 'C:\'+nf+ext ;

Assign (nl, nf);


ReSet (nl);
er := IOResult ;
{$I+}

IF er <> 0 THEN
Begin
Writeln ;
WriteLn ('Le fichier ', nf, ' n''existe pas ') ; Writeln ;
Repeat
Write ('Vouler vous réessayer O/N ? ') ;
Rep := Readkey ; Rep := UpCase (rep);
WriteLn;
Until Rep IN ['O' , 'N'] ;
WriteLn ;
End;

Until (er = 0) or (Rep = 'N');


Writeln ;

IF er = 0 Then
Begin
ouvert := true ;
WriteLn ('Le fichier ', nf, ' est maintenant ouvert ');
End;

Writeln ;
Echap ;
END;

{ _______ Procédure de suppression d'un fichier ___________ }

PROCEDURE Suppression (VAR nl : fichier ; VAR nf : nom_physique);


VAR L,er : Byte ;
Rep : Char ;
BEGIN
ClrScr ;
Writeln('SUPPRESSION D''UN FICHIER': 50);
WriteLn; WriteLn ;

{$I-}
Repeat

Repeat
Write ('Entrer le nom du fichier à supprimer : '); ReadLn (nf);
L := Length (nf) ;
Until (L > 0) AND (L <=8 ) ;

nf := 'C:\'+nf+ext ;

DOC4MTINFCS0004  Page 3 
http://www.najah.com 

Assign (nl, nf);


ReSet(nl);
er := IOResult ;
{$I+}
IF er <> 0 THEN
Begin
Writeln ; WriteLn ('Le fichier ', nf, ' n''existe pas '); Writeln ;
Repeat
Write ('Vouler vous réessayer O/N ? ');
Rep := Readkey ; Rep := UpCase (rep);
WriteLn;
Until Rep IN ['O','N'] ;
WriteLn ;
End;

Until (er = 0) or (Rep = 'N');


Writeln ;

IF er = 0 Then
Begin
Erase (nl) ;
ouvert := false ; { Aucun fichier n'est ouvert }
WriteLn ('Le fichier ', nf, ' a été supprimer avec succès ');
Writeln ;
End ;
Echap ;
END;

{ ________ Procédure de fermeture d'un fichier ___________ }

PROCEDURE Fermeture (VAR nl : fichier ; VAR nf :nom_physique );


VAR
Rep : Char ;
er : byte ;

BEGIN
ClrScr ;
Writeln ('FERMETURE D''UN FICHIER' : 50);
WriteLn; WriteLn ;

{$I-}
Assign (nl, nf);
ReSet(nl);
er := IOResult ;
{$I+}
IF (er <> 0) or (ouvert=false) THEN
Begin
Writeln ;
if ouvert = false then WriteLn (' Le fichier n''est pas ouvert ')
Else WriteLn ('Le fichier ', nf, ' n''existe ');

DOC4MTINFCS0004  Page 4 
http://www.najah.com 

Writeln ;

End
Else
Begin
Repeat
Write ('Vouler vous fermer Le fichier ', nf, ' (O / N) ? ' );
Rep := Readkey ; Rep := UpCase (rep);
WriteLn;
Until Rep IN ['O','N'] ;

IF Rep = 'O' Then Close (nl) ;

Writeln ; WriteLn ('Le fichier ', nf, ' a été fermer avec succès ');
End;
Writeln ;

ouvert := false;
Echap ;
END;

{ _________ Procédure de recherche de l'existence et de la position d'un film ________ }

PROCEDURE Cherche (ref2 : Word ; enr : Films; VAR nl : Fichier ; VAR posi : LongInt ;
VAR trouve : Boolean);
BEGIN
Trouve := False ;
Reset (nl);
While (NOT(EOF (nl))) AND (trouve = False) DO
Begin
Read(nl, enr);
IF ref2 = enr.reference then
Begin
trouve := True ;
posi := FilePos(nl) -1 ;
End;
End;
END ;

{ ___________ Procédure d'ajout d'un film __________________ }

PROCEDURE Ajouter (VAR nl : Fichier ; enr : Films);


VAR rep : CHAR ;

BEGIN
ClrScr ;
WriteLn ('A J O U T E R F I L M S':20); WriteLn ;
Repeat
Repeat
Repeat

DOC4MTINFCS0004  Page 5 
http://www.najah.com 

Write ('Référence : '); ReadLn (enr.reference);


Cherche (enr.reference, enr, nl, posi, trouve);
IF trouve = True Then
Begin
WriteLn; WriteLn ('Cette référence existe déja dans le fichier ');
WriteLn('Veuillez entrer une autre référence ');
WriteLn;
End;
Until trouve = False ;

Write ('Titre : '); ReadLn(enr.titre);


Until (enr.reference > 0) AND (enr.titre <> '') ;

Write(nl, enr);

Write('Continuer Oui/Non (O/N)? ');


Repeat
Rep := Readkey ; Rep := UpCase (Rep);
Until Rep IN ['O', 'N'] ;
WriteLn; WriteLn ;
Until rep = 'N' ;
END ;

{ _________ Procédure qui modifie les données d'un film _______________ }

PROCEDURE Modifier (VAR nl : Fichier ; enr : Films);


VAR rep : CHAR ;

BEGIN
ClrScr ;
WriteLn ('M O D I F I E R F I L M S' : 20); WriteLn ;

Repeat
Write ('Référence : '); ReadLn (ref2);

WriteLn ('Recherche de la référence : ', Ref2); WriteLn ;

Cherche (ref2, enr, nl, posi, trouve);

IF trouve = False THEN


Begin
Writeln ('La référence du film n''existe pas dans le fichier '); WriteLn;
End
Else
Begin
Seek (nl, posi);
Read (nl, enr);

Repeat
Write ('Ancienne référence : ', enr.reference,' Nouvelle référence : ') ;
ReadLn (enr.reference);

DOC4MTINFCS0004  Page 6 
http://www.najah.com 

Write ('Ancien titre : ', enr.titre , ' Nouveau titre : ');


ReadLn (enr.titre);
Until (enr.reference > 0 ) AND (enr.titre <> '');

Seek (nl, posi); Write(nl, enr);


End;
Write ('Continuer Oui ou Non (O/N)? ');

Repeat
Rep := Readkey ; Rep := UpCase (Rep);
Until Rep IN ['O', 'N'] ;
WriteLn; WriteLn ;
Until rep = 'N' ;
END ;

{ _________ Procédure de recherche et d'affichage d'un film _________________ }

PROCEDURE Chercher_afficher (VAR nl : Fichier ; enr : Films);


VAR rep : CHAR ;
BEGIN
ClrScr ;
WriteLn ('C H E R C H E R F I L M S' : 20); WriteLn ;
Repeat
Write ('Référence : '); ReadLn (ref2);

WriteLn ('Recherche de la référence : ', Ref2); WriteLn ;

Cherche (ref2, enr, nl, posi, trouve);

IF trouve = False THEN


Begin
Writeln('La référence du film n''existe pas dans le fichier '); WriteLn;
End
Else
Begin
Seek(nl, posi);
Read(nl, enr);

WriteLn('Référence : ', enr.reference) ;


WriteLn('Titre : ', enr.titre );
End;

Writeln; Write ('Continuer Oui ou Non (O/N)? ');


Repeat
Rep := Readkey ; Rep := UpCase (Rep);
Until Rep IN ['O', 'N'] ;
WriteLn; WriteLn ;
Until rep = 'N' ;
END ;

DOC4MTINFCS0004  Page 7 
http://www.najah.com 

{ ________ Procedure qui supprime un film _______________ }

PROCEDURE Supprime (VAR nl : Fichier ; enr : Films);


VAR
rep : CHAR ;
taille, i : Word ;

BEGIN
ClrScr ;
WriteLn('S U P P R I M E R F I L M S':20); WriteLn ;

REPEAT
Write ('Référence : '); ReadLn (ref2);

WriteLn ('Recherche de la référence : ', Ref2); WriteLn ;

Cherche (ref2, enr, nl, posi, trouve);

IF trouve = False THEN


Begin
Writeln('La référence du film n''existe pas dans le fichier '); WriteLn;
End
Else
Begin
Seek(nl, posi) ; Read (nl, enr);
WriteLn ('Suppression du film : ', enr.reference, ' = ', enr.titre);
taille := FileSize (nl);
For i:= posi+1 to taille-1 do
Begin
Seek (nl, i); Read (nl, enr);

Seek (nl, i-1); Write(nl, enr);


End;

Seek (nl, taille-1); Truncate (nl);

Reset(nl);
Taille := FileSize(nl);
For i:=0 to taille-1 do
Begin
Seek(nl, i) ; Read (nl, enr);

WriteLn ('Référence : ', enr.reference) ;


WriteLn ('Titre : ', enr.titre );
End;
End;

Writeln;
Write('Continuer Oui ou Non (O/N)? ');
Repeat
Rep := Readkey ; Rep := UpCase (Rep);
Until Rep IN ['O', 'N'] ;
WriteLn; WriteLn ;

DOC4MTINFCS0004  Page 8 
http://www.najah.com 

UNTIL rep = 'N' ;


END ;

{ _____ Procédure qui affiche un message d'erreur si le fichier n'est pas ouvert _______ }
PROCEDURE Erreur ;
BEGIN
ClrScr ;
Writeln (' E R R E U R ');
Writeln ('Aucun fichier n''est ouvert ');
Writeln ;
Echap ;
END;

{ _________ Procédure du menu de choix ___________________________ }

PROCEDURE Menu (VAR choix : Byte ) ;


VAR Rep : char ;

BEGIN
REPEAT
ClrScr ;
WriteLn; Writeln ('___ M E N U ___ ' : 50);
WriteLn ; WriteLn ;
WriteLn (' F I C H I E R S EDITION Q U I T T E R '); Writeln;
WriteLn (' 1 - Créer un nouveau fichier 5 - Ajouter un film 9 - Sortir');
WriteLn (' 2 - Ouvrir un fichier existant 6 - Modifier un film ');
WriteLn (' 3 - Supprimer un fichier 7 - Chercher un film ');
WriteLn (' 4 - Fermer un fichier 8 - Supprimer un film '); Writeln ; WriteLn;
Write (' Votre choix ? ');
Repeat
Rep := ReadKey;
Until Rep IN ['1' .. '9'];

Case Rep Of
'1' : Creation (nf) ;
'2' : Ouverture (nf) ;
'3' : Suppression (nl, nf) ;
'4' : Fermeture (nl, nf) ;
'5' : If ouvert = true then Ajouter (nl, enr) Else Erreur;
'6' : If ouvert = true then Modifier(nl, enr) Else Erreur;
'7' : If ouvert = true then Chercher_afficher (nl, enr) Else Erreur;
'8' : If ouvert = true then Supprime (nl, enr) Else Erreur;
'9' : Begin
ClrScr;
Write(' A U R E V O I R ');
If ouvert Then close(nl);
Halt ; { Halt : procédure pré définie qui stoppe le programme et ramène au
système }
End;
End ;
UNTIL Rep = '9';

DOC4MTINFCS0004  Page 9 
http://www.najah.com 

If ouvert Then close(nl);


END;

{ ============= Programme Principal =========================== }

BEGIN
ouvert := false ; { init : aucun fichier n'est ouvert }
Menu (choix);
END.

DOC4MTINFCS0004  Page 10 
http://www.najah.com 

Solution du sujet T1 - 5
EXAMEN DU BACCALAUREAT (session : JUIN 1994)
SUJET : INFORMATIQUE

EXERCICE 1 (6 points )
1) La RAM est placée physiquement :

F dans le disque dur V sur la carte mère F dans le


microprocesseur

2) pour un micro-ordinateur, ces éléments sont-ils des périphériques ?

F l'unité V le clavier V l'imprimante


arithmétique
et logique

3) La commande RmDir (RD) sert à :

F créer un répertoire V enlever un répertoire F effacer un fichier

4) Dans le système DOS, l'instruction : PATH C:\ Travail \ Tableur


Permet la recherche dans :

F tous les lecteurs F le lecteur actuel V le sous répertoire


disponibles Tableur de C

5) Le nombre décimal 1994, est-il égal à :

V 7CA 16 F 3713 8 F 11111001011 2

6) Voici une séquence d'instructions écrites en Pascal :


cha := 'Je suis ';
chb := 'baccalauréat';
cha := cha + ' au bac';
chc := COPY( chb, 6 , 7);
INSERT ( chc, cha, 9 );
FOR i:= 1 TO LENGTH(cha) DO
cha[ i ] := UpCase ( cha[ i ] );
Après exécution de cette séquence, la longueur en caractères de la chaîne cha serait :

DOC4MTINFCS0006  Page 1 
http://www.najah.com 

F 8 F 19 V 22

DOC4MTINFCS0006  Page 2 
http://www.najah.com 

EXERCICE N° 2

1-a/ ALGORITHME PROCEDURE SAISIE

0) Procédure Saisie (VAR MOT1, MOT2 : Chaîne )


1) REPETER
test ← Faux
Lire (MOT1)
nc ← 0
REPETER
nc ← nc + 1
SI NON( MOT1[ nc ] DANS [ "a" .. "z" , "A" .. "Z" ] )
ALORS
test ← Vrai
Fin Si
JUSQU'A (test = Vrai) OU (nc = Longueur (MOT1) )
JUSQU'A (test = Faux)
2) MOT2 ← MOT1
3) POUR nc DE 1 A Longueur (MOT1) FAIRE
MOT2 [ nc ] ← "-"
Fin Pour
4) Fin Saisie

Tableau de codification des objets locaux


Objet Type / Nature Rôle
nc Entier Compteur
test Booléen Teste si un caractère est présent ou non dans le mot.

1 - b / ALGORITHME FONCTION CONV_MAJUS


0) Fonction CONV_MAJUS (MOT : Chaîne ) : Chaîne
1) POUR nc DE 1 A LONGUEUR( MOT ) FAIRE
MOT[ nc ] ← MAJUS( MOT[ nc ] )
CONV_MAJUS ← MOT
Fin Pour
2) Fin CONV_MAJUS

Tableau de codification des objets locaux


Objet Type / Nature Rôle
nc Entier Compteur

1 - c / ALGORITHME PROCEDURE AFFICHE


0) Procédure Affiche (MOT : Chaîne)
1) Ecrire (MOT)

DOC4MTINFCS0006  Page 3 
http://www.najah.com 

2) Fin Affiche

1 - d / ALGORITHME PROCEDURE LIRE_CAR


0) Procédure Lire_Car (VAR c : caractère)
1) REPETER
Lire( c )
c ← MAJUS( c )
Jusqu'à c DANS ["A" .. "Z"]
2) Fin Lire_Car

1 - e / ALGORITHME PROCEDURE CHERCHE_REMPLACE

0) Procédure Cherche_Remplace (MOT1 : Chaîne; c : caractère; VAR MOT2 : Chaîne )


1) POUR i DE 1 A Longueur (MOT1) FAIRE
Si MOT1[ i ] = c ALORS MOT2[ i ] ← c
Fin Si
Fin Pour
2) Fin Cherche_Remplace

Tableau de codification des objets locaux


Objet Type / Nature Rôle
i Entier Compteur

2 / ALGORITHME DU PROGRAMME PRINCIPAL

0) Début Devinette
1) Saisie ( MOT1 , MOT2 )
2) MOT1 ← Conv_Majus ( MOT1 )
3) co ← 0
4) n ← Longueur ( MOT1)
5) Affiche ( MOT2 )
6) Répéter
co ← co + 1
Lire_Car( c )
Cherche_Remplace ( MOT1 , c , MOT2)
Affiche ( MOT2 )
Jusqu'a ( co = 2 * n ) OU ( MOT2 = MOT1 )
7) Si MOT1 = MOT 2 Alors Ecrire (MOT1, "Trouvé en ", co , " essais")
Sinon Ecrire ("Désolé, le mot est : ", MOT1);
Fin Si
8) Fin Devinette

DOC4MTINFCS0006  Page 4 
http://www.najah.com 

Tableau de codification des objets globaux


Objet Type / Nature Rôle
MOT1 Chaîne Mot saisit
MOT2 Chaîne Mot deviné
n Entier Longueur du mot
co Entier Nombre d'essais
c Caractère Caractère saisit

DOC4MTINFCS0006  Page 5 
http://www.najah.com 

Solution du sujet T1 - 6

PARTIE I ( 6 points )
Exercice 1 ( 3 points )
1)
Soit la fonction Traitement suivante écrite en Pascal :

FUNCTION Traitement (d,f:integer;T:tab): INTEGER ; (Integer 0.5,


Real 0.25)
VAR
indmin : INTEGER ; (0.25 point)

i : INTEGER ; (0.25 point)

BEGIN
indmin:=d ;
FOR i := d+1 TO f DO
IF T[i] < T[indmin] THEN
Begin
indmin := i ;
End;
Traitement := indmin ;
END ;

2/ La valeur renvoyée par la fonction Traitement si d=2, f=5 et le tableau T contient les
éléments suivants est :

T -10 5 0 -6 10 13
i 1 2 3 4 5 6

Avant la boucle, indmin vaut 2


pour i = 3 on a T[3] =0 < 5 = T[2] donc indmin = 3
pour i = 4, on a T[4] = -6 < 0 = T[3] donc indmin = 4
pour i = 5, on a T[5] =10 ≥ -6 = T[4] , indmin reste inchangé
Donc la valeur renvoyée par cette fonction est 4 (1 point)
3) Le rôle de cette fonction est de déterminer le premier emplacement du minimum dans la
partie de T commençant à l'indice d et se terminant à l'indice f.
"le premier emplacement" 0.25 point
"le minimum" 0.5 point
"la plage (la partie de T)" 0.25 point

Exercice 2 (3 points)
Dans un contexte informatique, la définition de :
1) Signet : lieu indiqué dans un document pour référencer un lien hypertexte.
Mots clés : - Emplacement ou tout mot équivalent (0.5 point)

DOC4MTINFCS0006  Page 1 
http://www.najah.com 

- Lien hypertexte (0.5 point)


2) Adresse IP : Identifiant unique d'une machine connectée à un réseau et utilisant le
protocole de communication TCP/IP. Une telle adresse et actuellement composée de quatre
entiers compris chacun entre 0 et 255.
Mots clés : - Identifiant ou adresse unique ou toute expression équivalente (0.5 point)
Forme de l'adresse (4 octets) ou adresse d'Internet ou Adresse d'un réseau
IP
ou TCP/IP (0.5 point)

NB : si le candidat donne seulement un exemple => 0.25 point


3) Protocole : Ensemble de règles régissant la communication entre machines
interconnectées.

1 point

NB : si le candidat donne seulement un exemple => 0.25 point

PARTIE II (14 points)


1) Le résultat de ce problème est une décision qui dépendra essentiellement du nombre de
voix favorables nbf, du nombre de voix défavorables nbd et du nombre de voix neutres nbn.
Ces nombres seront le résultat d'une procédure de vote fait par les m membres du conseil.
Remarquons que :
nbf + nbd + nbn = m. Il suffit de calculer nbf et nbd et on a donc nbn = m - (nbf + nbd)

Analyse du problème
Résultat = Ecrire (FN Décision(nbf, nbd, nbn, m) )
(nbf, nbd, nbn) = PROC Vote(nbf, nbd, nbn, m)
m = PROC Saisie(m)
Fin Analyse

Tableau de codification des objets globaux


Objet Type / Nature Rôle
nbf Entier Nombre de voix favorables
nbd Entier Nombre de voix défavorables
nbn Entier Nombre de voix neutres
m Entier Nombre de membres
Décision Fonction Décision finale
Vote Procédure Compte les différents votes

DOC4MTINFCS0006  Page 2 
http://www.najah.com 

Saisie Procédure Saisie de m

2) Analyse des modules


Analyse de la fonction Décision

Résultat = Décision
Traitement :
Décision = [ ] Si (neutre > n DIV 2) alors
Fn Décision ← "Reportée"
Sinon si (favorable > défavorable) alors
Fn Décision ← " Acceptée"
Sinon
Fn Décision ← "Refusée"
Fin Si
Fin Analyse

Analyse de la procédure Vote


Résultat = (favorable, défavorable, neutre)
Traitement :
neutre = n - ( favorable + défavorable)
(favorable, défavorable) = [ favorable ← 0, défavorable ← 0]
Pour i de 1 à n répéter
Répéter
Ecrire ("Vote n° ", i)
Lire (voix)
voix ← MAJUS (voix)
Jusqu'à voix dans {"F","D","N"}
si (voix ="F") alors
favorable ← favorable + 1
sinon si (voix = "D") alors
défavorable ← défavorable + 1
Fin Si
Fin Pour
Fin Analyse

Tableau de codification des objets locaux


Objet Type / Nature Rôle
i Entier Compteur
voix Caractère F, D ou N

DOC4MTINFCS0006  Page 3 
http://www.najah.com 

Analyse de la procédure Saisie


Résultat = n
Traitement :
n=[ ] Répéter
Ecrire ("Donner un entier impair compris entre 10 et 20 ")
Lire (n)
valide ← (n MOD 2 = 1) et (n >= 10) et (n <= 20)
Jusqu'à (valide)
Fin Analyse

Tableau de codification des objets locaux


Objet Type / Nature Rôle
valide Booléen validité de la saisie de n

3) Algorithmes
0) Début Marché_info
1) PROC Saisie (m)
2) PROC Vote (nbf, nbd, nbn, m)
3) Ecrire (FN Décision (nbf, nbd, nbn, m) )
4) Fin marché_info

0) Procédure Saisie (VAR n : entier)


1) Répéter
Ecrire ("Donner un entier impair compris entre 10 et 20 ")
Lire (n)
valide ← (n MOD 2 = 1) et (n >= 10) et (n <= 20)
Jusqu'à (valide)
3) Fin Saisie

0) Procédure Vote (VAR favorable, défavorable, neutre : entier ; n : entier)


1) favorable ← 0, défavorable ← 0
Pour i de 1 à n répéter
Répéter
Ecrire ("Vote n° ", i)
Lire (voix)
voix ← MAJUS (voix)
Jusqu'à voix dans {"F","D","N"}

Si voix ="F" alors


favorable ← favorable + 1
Sinon si voix = "D" alors
défavorable ← défavorable + 1

DOC4MTINFCS0006  Page 4 
http://www.najah.com 

Fin Si
Fin Pour
2) neutre Å n - (favorable + défavorable)
3) Fin vote

0) Fonction Décision (favorable, défavorable, neutre, n : entier) : Chaîne


1) si (neutre > n DIV 2) Alors
décision ← "Reportée"
Sinon Si (favorable > défavorable ) alors
décision ← " Acceptée"
Sinon
décision ← "Refusée"
Fin Si
2) Fin décision

DOC4MTINFCS0006  Page 5 
http://www.najah.com 

Barème
Questions Note
1/ Analyser le problème en le décomposant en modules (3 points)
- Analyse et décomposition en modules 1 point
- Programme principal 1 point
- Tableaux de déclaration. 0.5 point
- Cohérence des appels et mode de passage 0.5 point
NB : -0.25 point par erreur

2/ Analyser le programme principal ainsi que chacun des modules


envisagés.
* Module Saisie de m & contrôles (1.5 points): 0.5 point
- Saisie de m 0.25 point
- Boucle Répéter 3x0.25 point
- Contrôle (parité, borne inf, borne sup)

* Module vote (4 points)


- Saisie des voix + test 1 point
- Contrôle de la saisie (Répéter … jusqu'à) 0.5 point
- Calcul de nbf, nbd, nbn 3x0.5 points
- Structure répétitive Pour 0.5 point
- Structure conditionnelle Si 0.5 point

* Module décision + affichage (2.5 points)


décision 3x0.5
Affichage 1 point

3/ En déduire les algorithmes correspondants (3 points)


moins 0.25 point par erreur. 3 points

DOC4MTINFCS0006  Page 6 
http://www.najah.com 

Solution du sujet T2 - 7
Exercice 1 :
{Fonction nommée Power qui retourne x^y (x à la puissance y) }.

FUNCTION Power (x , y : integer) : LongInt ;


VAR i: Integer ;
p: LongInt ;
BEGIN
p := 1;
For i := 1 to y Do
p := p * x ;
Power := p ;
END;

Exercice 2 :
Utilisation de la fonction pour effectuer la conversion de binaire à décimal.

PROGRAM Power_x_y ;
USES WinCrt ;
VAR
nombre : Integer ;
i: Integer ;
r : Integer ;
valeur : LongInt ;

{Fonction nommée Power qui retourne x^y (x à la puissance y) }.


FUNCTION Power (x , y : integer) : LongInt ;
VAR i: Integer ;
p: LongInt ;
BEGIN
p := 1;
For i := 1 to y Do
p := p * x ;

Power := p ;
END;

{ ================= P . P ====================}
BEGIN
ClrScr ;
i := 0 ;
valeur := 0 ;

DOC4MTINFCS0007  Page 1 
http://www.najah.com 

Write('Entrez le nombre codé en binaire : ') ;


ReadLn (nombre) ;

Wile (nombre < > 0) Do


Begin
r := nombre MOD 10 ;
If (r = 1) Then valeur := valeur + Power (2, i) ;
i := i + 1;
nombre := nombre DIV 10 ;
End ;
WriteLn ('Le nombre vaut ', valeur, ' en décimal') ;
END.

Exercice 3 :
Réutilisation de la fonction Power et écriture d'une fonction Int2Bin qui convertit l'entier en
paramètre en binaire

PROGRAM Entier_vers_binaire ;
USES WinCrt;
TYPE Str8 = String [8];

FUNCTION Byte2Bin (valeur : Byte): Str8;


VAR
s : Str8;
i: Integer;
BEGIN
s[0] := #8 ;
For i := 0 To 7 do
Begin
s[8 - i] := Char(((value shr i) and 1) + Ord('0'));
End;
byte2bin := s;
END ;

FUNCTION power2(i: Integer): Integer ;


VAR
j: Integer;
pro: Integer;
BEGIN
pro := 1;
Fo j := 1 To i Do
Begin
pro := pro * 2;
End;
power2 := pro;
END;
FUNCTION int2bin (value: Integer): String;
DOC4MTINFCS0007  Page 2 
http://www.najah.com 

VAR
i: Integer;
j: Integer;
BEGIN
i := 0; (* nombre de bits de codage *)
While (value DIV Power2(i)) <> 0 Do
i := i + 1;
int2bin[0] := Chr(i);
For j := 0 To i - 1 Do
Begin
int2bin[i - j] := Char(((value shr j) and 1) + Ord('0'));
End;
END ;

{ = = = = = = = = = == = = P P = = = = = = = = = = = = = = = =}
VAR
i: Integer;
value: Integer;
BEGIN
ClrScr ;
WriteLn (int2bin (256) );
END.

DOC4MTINFCS0007  Page 3 
http://www.najah.com 

Solution du sujet T2 - 8

Analyse du Programme Principal Classement


Résultat = Afficher les éléments triés du tableau T
Traitement :
- Une procédure Affiche, permet l'affichage du tableau trié
- Une procédure Trier, permet de trier le tableau par la méthode tri shell
- Une procédure Remplit_T, permet de remplir au hasard le tableau
- Une procédure Saisie, permet de saisir l'entier N
Fin Classement

Algorithme
0) Début Classement
1) Proc Saisie (N)
2) Proc Remplit_T (T , N)
3) Proc TRi_Shell (T , N)
4) Proc Affiche (T , N)
5) Fin Classement

Tableau de déclaration des objets globaux


Objet Type / Nature Rôle
N Entier Nombre d'éléments du tableau
Maxi Constante = 1000 Taille maximale du tableau
T Vect Tableau des entiers

Tableau de déclaration des nouveaux types


Type
Vect = Tableau de Maxi entiers

Analyse de la procédure Saisie


Résultat = Saisie et test de N
Traitement
Répeter
Lire (N)
Jusqu'à (N ≥ 10) ET (N ≤ Maxi)
Fin Saisie

Algorithme
0) Procédure Saisie (VAR N : Entier)
1) Répéter
Ecrire ("Entrer un entier N compris entre 10 et " , Maxi )
Lire (N)

DOC4MTINFCS0008  Page 1 
http://www.najah.com 

Jusqu'à (N ≥ 10) ET (N ≤ Maxi)


2) Fin Saisie

DOC4MTINFCS0008  Page 2 
http://www.najah.com 

Analyse de la procédure Remplit


Résultat = Remplit par N valeurs prise au hasard un tableau T
Traitement :
L'action de génération des valeurs aléatoire (hasard) se fait par la fonction prédéfinie Hasard
(x). En prendra par exemple x = 5000

Pour i de 1 à N Faire
T[i] Å Hasard (5000)
Fin Pour
Fin Remplit

Algorithme
0) Procédure Remplit (VAR T : Vect ; N : Entier)
1) Pour i de 1 à N Faire
T[i] Å Hasard (5000)
Fin Pour
2) Fin Remplit

Tableau de déclaration des objets locaux


Objet Type / Nature Rôle
i Entier Compteur

Analyse de la procédure Trier { Tri Shell }


Résultat = Trier par ordre croissant le tableau T
Traitement :
- Le tri Shell consiste à appliquer le tri par insertion sur p sous tableaux du tableau initial T.
- On répète cette opération de base pour des valeurs de p (pas) qui vont en diminuant jusqu'à
une valeur finale 1.
- Le pas p est calculé à partir de la formule : pn+1 = (3*pn+1) avec p0 = 1.

- Pour avoir la valeur maximale du pas, on utilise une boucle à condition d’arrêt :
PÅ 1
Tant Que p < N Faire
p Å (3 * p + 1)
- Détermination des valeurs successives que prendra le pas en utilisant la formule suivante :
pÅ p div 3 jusqu’à arriver à une valeur pour le pas égale à 1.
On utilise une boucle à condition d’arrêt
Tant Que p ≠ 0 Faire
p Å p DIV 3

- Pour par exemple une valeur maximale du pas p = 4, on a 4 sous tableaux dont les éléments
sont distants de 4 cases. Ces 4 sous tableaux seront triés par l'algorithme de tri par insertion.
Si T[i] n’est pas à sa place alors on réalise les actions suivantes :

Pour i de p +1 à N Faire

DOC4MTINFCS0008  Page 3 
http://www.najah.com 

- Ranger la valeur de T[i] dans la variable TMP


Pos c'est la valeur actuelle de i
- Décaler vers la droite de la valeur de p les contenus de T[pos - p] puis de T[pos - 2 * p],
etc. jusqu’à arriver à une valeur qui est inférieure à T[i]..
- Affecter au dernier élément décalé la valeur de TMP

- On prend la seconde valeur de p calculé, on répète le même traitement jusqu'à une valeur de
p = 1.
Dans ce cas on applique un tri par insertion normal sur tout le tableau.
Fin Tri_Shell

Algorithme
0) Procédure Trier (VAR T : Vect ; N : Entier)
1) PÅ 1
2) Tant Que (p < N) Faire
p Å (3 * p +1)
Fin Tant Que
3) Tant Que (p < >1) Faire
pÅ p DIV 3
Pour c de p+1 à N Faire
Si T[c] < T[c-p] Alors
Tmp Å T[c]
pos Å c
Tant Que (pos > p-1) ET (T[pos -p] > tmp) Faire
T[pos]Å T[pos - p]
pos Å pos - p
Fin Tant que
T[pos]Å Tmp
Fin Si
Fin Pour
Fin Tant Que
3) Fin Tri_Shell

Tableau de déclaration des objets locaux


Objet Type / Nature Rôle
c Entier Compteur
p Entier Le pas
Tmp Entier Variable temporaire de sauvegarde
pos Entier Position actuelle d'une valeur à déplacer

Analyse de la procédure Affiche


Résultat = Afficher le contenu du tableau
Traitement :
Une itération complète permet le parcourt et l'affichage des éléments du tableau T

DOC4MTINFCS0008  Page 4 
http://www.najah.com 

Pour i de 1 à N Faire
Ecrire T[i]
Fin Pour
Fin Affiche

DOC4MTINFCS0008  Page 5 
http://www.najah.com 

Algorithme
0) Procédure Affiche (T : Vect ; N : Entier)
1) Pour i de 1 à N Faire
Ecrire (T[i])
Fin Pour
2) Fin Affiche

Tableau de déclaration des objets locaux


Objet Type / Nature Rôle
i Entier Compteur

Traduction en Pascal
PROGRAM Tri_Shell ;
USES WinCrt ;

CONST Maxi = 1000 ;


TYPE Vect = ARRAY [1..Maxi] OF Integer ;
VAR T : Vect ;
N : Integer ;

{--------------------------------------------------------------------------------------}
PROCEDURE Saisie (VAR N : Integer );
BEGIN
Repeat
Write ('Entrer un entier N compris entre 10 et 1000 : ');
ReadLn (N);
Until (N >= 10 ) AND (N <= Maxi) ;
END ;

{--------------------------------------------------------------------------------------}
PROCEDURE Remplit (VAR T : Vect ; N : Integer ) ;
VAR i : Integer ;
BEGIN
Randomize ;
For i := 1 TO N DO
T[i] := Random (5000);
END ;

{--------------------------------------------------------------------------------------}
PROCEDURE Trier (VAR T : Vect ; N : Integer );
VAR p, c, pos, Tmp : Integer ;
BEGIN
p := 1 ;

DOC4MTINFCS0008  Page 6 
http://www.najah.com 

While (p < N) Do
Begin
p := (3 * p +1) ;
End ; {End while }

While (p <> 0 ) Do { 1er While }


Begin
p := p DIV 3 ;
For c:= p+1 TO N Do
Begin
If T[c] < T[c-p] Then
Begin
Tmp := T[c];
Pos := c ;
While (pos > p-1) AND (T[pos - p] > Tmp) Do {2 eme While }
Begin
T[pos] := T[pos - p] ;
Pos := pos - p ;
End ; {End 2 eme While }

T[pos] := Tmp ;

End ; { End If }

End ; { End For }

End ; { End 1er While }


END ;

{--------------------------------------------------------------------------------------}
PROCEDURE Affiche (T : Vect ; N : Integer ) ;
VAR i : Integer ;
BEGIN
For i := 1 To N Do
Writeln (i:3 ,' : ', T[i] );
END ;

{ ===================== P P ==========================}

BEGIN
Saisie (N);
Remplit (T, N) ;
Trier (T, N) ;
Affiche (T, N);

END.

DOC4MTINFCS0008  Page 7 
http://www.najah.com 

Solution du sujet T2 - 9
EXAMEN DU BACCALAUREAT (session : JUIN 1995)
SUJET : INFORMATIQUE

1 ère PARTIE ( 8 points)

EXERCICE N° 1 ( 3 points)

1/
a/ F V F

b/ V F F

2/
F F V

EXERCICE N°2 (2 points)

Base Binaire Octale Décimale Hexadécimale


Nombre
875 X X
101 X X X X
AB1 X
120 X X X

EXERCICE N° 3 (1 point)

( 135 )8 < ( 95 )10 < (1100011)2 < (A01)16

EXERCICE N°4 (2 points)

« Un ordinateur est une machine électronique programmable de traitement automatique


de l'information Il est constitué principalement d'une unité centrale qui exécute le programme
instruction par instruction, d'une mémoire centrale contenant les programmes et leurs
données, et d'éléments périphériques permettant la communication entre l'utilisateur et la
machine . »
Dictionnaire de micro-informatique.

DOC4MTINFCS0009  Page 1 
http://www.najah.com 

2 ème PARTIE (12 points)

1/ ALGORITHME PROCEDURE SAISIE_DEC

0) Procédure Saisie_Dec (VAR N : Entier)


1) REPETER
Ecrire ("Donner un entier N strictement positif : ")
Lire ( N )
JUSQU'A (N > 0)
2) Fin Saisie_Dec

2/ ALGORITHME PROCEDURE SAISIE_BASE

0) Procédure Saisie_Base (VAR B : Entier)


1) REPETER
Ecrire ("Donner une base: ")
Lire ( B )
JUSQU'A (B ≥ 2) ET ( B ≤ 16) { ou JUSQU'A B DANS [ 2 .. 16 ] }
2) Fin Saisie_Base

3/ a/ ALGORITHME PROCEDURE RANGER

0) Procédure Ranger (N, B : Entier ; VAR RESTES: Vecteur ; VAR R : Entier)


1) R ← 0
2) REPETER
R← R+1
RESTES [ R ] ← N MOD B
N ← N DIV B
JUSQU'A (N = 0)
3) Fin Ranger

3/ b/ Traduction en Pascal

PROCEDURE RANGER ( N, B : Integer; VAR RESTES : vecteur; VAR R : Integer);


BEGIN
R := 0;
REPEAT
R := R + 1 ;
RESTES[ R ] := N MOD B;
N := N DIV B;

DOC4MTINFCS0009  Page 2 
http://www.najah.com 

UNTIL N=0;
END;

DOC4MTINFCS0009  Page 3 
http://www.najah.com 

4/ ALGORITHME PROCEDURE

0) Procédure Renverser (VAR RESTES : vecteur ; R : entier)


1) POUR i DE 1 A ( R DIV 2) FAIRE
inter ← RESTES[ i ]
RESTES [ i ] ← RESTES[ R - i + 1 ]
RESTES [ R - i + 1 ] ← inter
Fin Pour
2) Fin Renverser

Tableau de codification des objets locaux


Objet Type / Nature Rôle
i Entier Compteur

5/ a / ALGORITHME FONCTION CONVERT

0) Fonction Convert (c : Entier) : Caractère


1) Si c < 10 ALORS
Fn Convert ← CHR (c + ORD("0") )
SINON
Fn Convert ← CHR (c - 10 + ORD("A") )
Fin Si
2) Fin Convert

Remarque : l'élève peut donner d'autres solutions en utilisant par exemple le code ASCII ou
la structure de choix multiples ( SELON c FAIRE ... )

5/ b/ Traduction en Pascal

FUNCTION CONVERT (c : Integer) : Char ;


BEGIN
IF c < 10
THEN CONVERT := CHR (c + ORD('0'))
ELSE CONVERT := CHR ( c - 10 + ORD('A')) ;
END;

6/ ALGORITHME PROCEDURE CONCATENATION

0) Procédure Concaténation (VAR résultat : mot ; RESTES : vecteur)


1) résultat ← ""
2) Pour i De 1 à R Faire
résultat ← résultat + Fn Convert (RESTES[ i ] )

DOC4MTINFCS0009  Page 4 
http://www.najah.com 

Fin Pour
3) Fin Concaténation

DOC4MTINFCS0009  Page 5 
http://www.najah.com 

Tableau de codification des objets locaux


Objet Type / Nature Rôle
i Entier Compteur
Convert Fonction Convertit les restes en chiffres / lettres de la base B

7/ ALGORITHME CONVERSION

0) Début Conversion
1) Proc Saisie_Dec (N)
2) Proc Saisie_Base (B)
3) Proc Ranger (N, B, RESTES, R)
4) Proc Renverser (RESTES, R )
5) Proc Concaténation (résultat, RESTES)
6) Ecrire ( N, " en décimal vaut ", résultat, " en base ", B )
7) Fin Conversion

Tableau de codification des objets globaux


Objet Type / Nature Rôle
Rmax Constante = 15 Valeur maximale des chiffres binaires
N Entier Le nombre décimal
B Entier La Base
Restes Vecteur Tableau des restes des divisions
Résultat Mot Résultat de la conversion
Saisie_Dec Procédure Saisie et teste le nombre décimal
Saisie_base Procédure Saisie et teste l'entier représentant la base
Ranger Procédure Range les restes dans le tableau Restes
Renverser Procédure Renverse le tableau des restes
Concaténation Procédure Rassemble les restes pour former le résultat.

Tableau de déclaration des nouveaux types


Type
Vecteur = Tableau de Rmax entiers
Mot = Chaîne [Rmax]

DOC4MTINFCS0009  Page 6 
http://www.najah.com 

Solution du sujet T2 - 10

BAC 97 - CORRIGE

PARTIE 1 (8 points)

EXERCICE 1 (3 points = 6 x 0,5)

V A := 3 ; V E := (C >= ‘C’) ;

F C := 3 ; V T[ 1 ] := -8 ;

V D := ‘ALI‘ ; F T[ 5 ] := T[ 1 ] / 2 ;

EXERCICE 2 (3 points = 6 x 0,5)

(76)8 < (77)8 < (100)8


(29E)16 < (29F)16 < (2A0)16
(110010)2 < (110011)2 < (110100)2

EXERCICE 3 (2 points = 4 x 0,5)

Valeur affichée Dans la procédure CHERCHE Dans le programme principal


Variable (après appel de la procédure)
x 3 0
y 0 0

PARTIE 2 (12 points)

1/ a) ALGORITHME PROCEDURE SAISIE

0) Procédure Saisie (VAR n : Entier ; VAR A : Tab)


1) REPETER
Lire( n )
JUSQU’A n DANS [ 10 .. 40 ]
2) POUR i DE 1 A n FAIRE
REPETER
Lire( A[ i ] )

JUSQU’A (A[ i ] ≥ 0) ET ( A[ i ] ≤ 20 )
Fin Pour
3) Fin Saisie

DOC4MTINFCS0010  Page 1 
http://www.najah.com 

Tableau de codification des objets locaux


Objet Type / Nature Rôle
i Entier Compteur

b) Traduction en Pascal

PROCEDURE SAISIE (VAR n : INTEGER ; VAR A : TAB) ;


VAR i : INTEGER ;

BEGIN
REPEAT
READLN( n );
UNTIL n IN [ 10 .. 40];

FOR i:=1 TO n DO
REPEAT
READLN( A[ i ] );
UNTIL (A[ i ] >= 0) AND (A[ i ] <= 20);
END;

2/ ALGORITHME FONCTION RANG

0) Fonction Rang (n : Entier ; A: TAB ; V : Réel) : Entier


1) R ← 1
2) POUR i DE 1 A n FAIRE
Si A[ i ] > V Alors R ← R + 1
Fin Si
Fin Pour
3) RANG ← R

4) Fin Rang

Tableau de codification des objets locaux


Objet Type / Nature Rôle
i, R Entiers Compteurs

3/ a) ALGORITHME PROCEDURE RANGS

0) Procédure Rangs (n : Entier; A: TAB; VAR R : RA)


1) POUR i DE 1 A n FAIRE
R [ i ] ← Fn RANG (n, A, A[ i ] )
Fin pour

DOC4MTINFCS0010  Page 2 
http://www.najah.com 

2) Fin Rangs

Tableau de codification des objets locaux


Objet Type / Nature Rôle
i Entier Compteur
Rang Fonction Cherche le rang pour une moyenne V

DOC4MTINFCS0010  Page 3 
http://www.najah.com 

b) Traduction En Pascal

PROCEDURE RANGS (n : INTEGER ; A: TAB; VAR R: RA );


VAR i : INTEGER;

BEGIN
FOR i:=1 TO N DO
R[ i ] := RANG ( n, A, A[ i ] )
END;

4/ ALGORITHME PROCEDURE AFFICHE

0) Procédure Affiche (n : Entier ; A : TAB ; R : RA)


1) POUR i DE 1 A n FAIRE
Ecrire ( i, A[ i ], R[ i ] )
Fin Pour
2) Fin Affiche

Tableau de codification des objets locaux

Objet Type / Nature Rôle


i Entier Compteur

5/ ALGORITHME RECHERCHE_RANG

0) Début Recherche_Rang
1) Proc Saisie (n , M)
2) Proc Rangs (n , M , R)
3) Proc Affiche (n , M , R )
4) Fin Recherche_Rang

Tableau de codification des objets globaux


Objet Type / Nature Rôle
N Entier Nombre d'élèves
M Tab Tableau des moyennes
R RA Tableau des rangs
Saisie Procédure Saisie et teste l'entier N
Rangs Procédure Range les rangs dans R
Affiche Procédure Renverse les tableaux R et M

DOC4MTINFCS0010  Page 4 
http://www.najah.com 

Tableau de déclaration des nouveaux types


Type
Tab = Tableau de N Réels
RA = Tableau de N Entiers

DOC4MTINFCS0010  Page 5 
http://www.najah.com 

Solution du sujet T2 - 11

CORRIGE DU SUJET DE BAC (JUIN 2001)

PARTIE 1 (6 points)
Exercice 1 (3 points)
Soit le message suivant :
"Cher ami, j'ai reçu ton message électronique et je te signale que tu peux télécharger le cours
de multimédia à partir de l'adresse suivante : fttp;//edunet.tn"

1) Définir les expressions soulignées.


* Un message électronique est un message envoyé par courrier électronique (e-mail).
* Télécharger : Rapatrier sur son ordinateur, des fichiers se trouvant sur un autre site Internet
(Download).
* fttp://edunet.tn : adresse FTP (pour téléchargement) du site Internet nommé edunet.tn

2) Citer les services d'Internet évoqués dans ce message.


* Courrier électronique (e-mail).
* FTP (File Transfert Protocol)

Exercice 2 (3 points)
Remplir le tableau suivant :
Description Exemple
Moteur de recherche www.yahoo.fr
Explorateur Internet Explorer
Adresse (URL) d'un site Internet http;//www.edunet.tn
Adresse du courrier électronique (e-mail) Mohamed.Salah@edunet.tn
Logiciel de création des pages Web MS Front Page
Protocole réseau TCP/IP

PARTIE 2 (14 points)

1) Décomposition en modules
* Proc Saisie_Nombre
* Proc Extraction
* Proc Trie
* Proc Affiche
* Programme principal Plus Grand

Dans ce qui suit on va respecter les normalisations utilisées actuellement, c'est-à-dire l'écriture
des analyses suivie des algorithmes et des tableaux de codification.

Analyse de la procédure Saisie_Nombre

Résultat = Saisie et teste de N


Traitement :
DOC4MTINFCS0011  Page 1 
http://www.najah.com 

Lire un entier N et refuser tout nombre négatif.


Fin Analyse

Algorithme de la procédure Saisie_Nombre

0) Procédure Saisie_Nombre (VAR n : Entier)


1) Répéter
Ecrire ("Enter un entier : ")
Lire ( n )
Jusqu'à (n > 0)
2) Fin Saisie_Nombre

Analyse de la procédure Extraction


Résultat = Tableau de chiffres
Traitement :
Extraire les chiffres de l'entier N et les mettre dans le tableau T de la façon suivante :
Convertir l'entier N en chaîne de caractères
Extraire un à un les caractères (chiffres) de la chaîne
Convertir chaque caractère en chiffre numérique et le mettre dans le tableau T.
Fin Analyse

Algorithme de la procédure Extraction

0) Procédure Extraction (n : Entier ; VAR T : Tab ; VAR L : Entier)


1) ConvCh (n, ch)
2) L Å Longueur (ch)
3) Pour i de 1 à L répéter
Valeur (ch[ i ], T[ i ], er )
Fin Pour
4) Fin Extraction

Tableau de codification des objets locaux


Objet Type / Nature Rôle
ch Chaîne de caractères L'équivalent en chaîne de l'entier N
i Entier Compteur
er Entier Variable contenant le numéro la position du caractère
qui a provoqué une erreur, sinon elle contient 0.

Analyse de la procédure Tri (Tri à bulles)

Résultat = Tri
Traitement :
- Trier par ordre croissant le tableau T.

DOC4MTINFCS0011  Page 2 
http://www.najah.com 

- Méthode choisie : Tri à bulles


On compare le 1er et le 2e élément du tableau, on conserve le plus grand et puis on les échange
s'ils sont désordonnés. On recommence cette opération jusqu'à la fin du tableau.
Si un échange a été effectué, on recommence le même traitement.
La condition d'arrêt de la répétition est que aucun échange ne se fait pendant un parcourt total
du tableau.
Fin Analyse
Algorithme de la procédure Tri

0) Procédure Tri (L : Entier ; VAR T : Tab)


1) Répéter
échange Å Faux
Pour i de 1 à L - 1 Faire
Si T[ i ] < T[ i + 1 ] Alors
aux Å T[ i ]
T[ i ] Å T[ i + 1 ]
T[ i + 1 ] Å aux
échange Å Vrai
Fin Si
Fin Pour
Jusqu'à (échange = Faux )
2) Fin Tri

Tableau de codification des objets locaux


Objet Type / Nature Rôle
échange Booléen Drapeau
i Entier Compteur
aux Entier Variable auxiliaire

Analyse de la procédure Affiche

Résultat = Afficher le plus grand entier formé.


Traitement :
Pour afficher le plus grand entier formé, il suffit d'afficher successivement le contenu du
tableau T et ce par une itération simple complète.
Fin Analyse

Algorithme de la procédure Affiche

0) Procédure Affiche (L : Entier ; T : Tab)


1) Ecrire ("Le plus grand entier formé est : ")
2) Pour i de 1 à L répéter
Ecrire ( T[ i ] )
Fin Pour

DOC4MTINFCS0011  Page 3 
http://www.najah.com 

3) Fin Affiche

Tableau de codification des objets locaux


Objet Type / Nature Rôle
i Entier Compteur

DOC4MTINFCS0011  Page 4 
http://www.najah.com 

Analyse du programme principal Plus grand


Résultat = Plus Grand
Traitement
Appeler dans l'ordre les différents modules :

Proc Saisie_Nombre (n )
Proc Extraction (n , T )
Proc Tri (L, T )
Proc Affiche ( L, T)
Fin Analyse

Algorithme du programme principal Plus grand

0) Début Plus grand


1) Proc Saisie_Nombre (n )
2) Proc Extraction (n , T, L )
3) Proc Tri (n, L, T )
4) Proc Affiche (L, T)
5) Fin Plus grand

Tableau de codification des objets globaux


Objet Type / Nature Rôle
N Entier L'entier saisit
T Tab Tableau des extractions
L Entier Longueur de la chaîne (le nombre en chaîne)
Saisie_Nombre Procédure Saisie l'entier N
Extraction Procédure Extrait les chiffres et les range dans T
Affiche Procédure Affiche le plus grand entier

Tableau de déclaration des nouveaux types


Type
Tab = Tableau de 10 Entiers

DOC4MTINFCS0011  Page 5 
http://www.najah.com 

Solution du sujet T2 - 12
EXAMEN DU BACCALAUREAT (session : JUIN 1993)
SUJET : INFORMATIQUE

EXERCICE 1 ( 6 points )
1) Le nombre hexadécimal CAF est égal dans la base 10 à :

F 3246 F 3428 F 3248

2) Le nombre Octal 456, multiplié par 8, est égal dans la même base à :

V 4560 F 4056 F 4567

3) La commande DIR est exécutable avec les paramètres suivants :

V /P /W V > PRN V > nom de fichier

4) ASCII est :

F un langage de F un système V un système de


programmation d'exploitation codage
d'information

5) Le nombre décimal 1993, s'écrit dans la base 2 :

F 1111 1100 1001 V 0111 1100 1001 F 0111 1100 1011

6) Après les instructions suivantes écrites en Pascal :


STR(17373 , mot ); R := LENGTH( mot );
La valeur de R est :

F '17373' F 0 V 5

DOC4MTINFCS0012  Page 1 
http://www.najah.com 

EXERCICE 2 ( 14 points)

1/ Calcule des 15 premiers éléments de (Un)


12 → 5, 25, 29, 85, 89, 145, 42, 20, 4, 16, 37, 58, 89, 145

295 → 110, 2, 4, 16, 37, 58, 89, 145, 42, 20, 4, 16, 37, 58

1115 → 28, 68, 100, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1


2/ ALGORITHME PROCEDURE INIT

0) Procédure Init (VAR T : Tab)


1) POUR i DE 0 A 99 FAIRE
T[ i ] ← 0
Fin Pour
2) Fin Init

Tableau de codification des objets locaux


Objet Type / Nature Rôle
i Entier Compteur

3/ ALGORITHME PROCEDURE SAISIE

0) Procédure Saisie (VAR U0 : Entier)


1) REPETER
Lire (U0)
JUSQU'A (U0 > 0)
2) Fin Saisie

4/ ALGORITHME FONCTION NBRCHIF

0) Fonction NBRCHIF ( m : Entier ) : Entier


1) ConvCh (m , mot )
2) NBRCHIF ← Longueur (mot)
3) Fin NBRCHIF

5/ ALGORITHME FONCTION CARRECHIF

0) Fonction CARRECHIF (p : Entier) : Entier


1) somme ← 0
2) ConvCh ( p , mot )
3) POUR i DE 1 A NBRCHIF( p ) FAIRE
Valeur (mot [ i ] , n , erreur )
somme ← somme + (n * n )
Fin Pour

DOC4MTINFCS0012  Page 2 
http://www.najah.com 

4) CARRECHIF ← somme
5) Fin CARRECHIF

NB : au lieu de Valeur (mot [ i ] , n , erreur )


On peut écrire Valeur (Sous_Chaîne (mot, i , 1) , n , erreur )

Tableau de codification des objets locaux


Objet Type / Nature Rôle
i Entier Compteur
somme Entier Somme des carrées des chiffres
n Entier Entier correspondant à MOT[i]
erreur Entier Variable contenant le numéro la position du caractère
qui a provoqué une erreur, sinon elle contient 0.

6/ ALGORITHME FONCTION CHERCHE

0) Fonction Cherche (v , k : Entier ) : Entier


1) x ← -1
2) i ← 0
3) REPETER
Si T[ i ] = v ALORS x ← i
i ← i+1
JUSQU'A ( i ≥ k) OU ( x ≠ -1)
4) Cherche ← x
5) Fin Cherche

Tableau de codification des objets locaux


Objet Type / Nature Rôle
i Entier Compteur
x Entier Première position trouvée

7/ ALGORITHME DU PROGRAMME INSIPID

0) Début INSPID
1) Proc INIT (T)
2) Proc SAISIE (U0)
3) T[ 0 ] ← U0
4) i ← 0
5) posi ← -1
6) TANT QUE ( posi = -1) ET (T[ i ] ≠ 1 ) FAIRE
i ← i+1
T[ i ] ← CARRECHIF( T[ i-1 ] )
posi ← CHERCHE( T[ i ], i -1 )
DOC4MTINFCS0012  Page 3 
http://www.najah.com 

Fin Tant Que


7) Si T[ i ] = 1 ALORS {séquence stationnaire }
Ecrire ( i )
POUR j DE 0 A i FAIRE
Ecrire ( T[ j ] )
Fin Pour
SINON {séquence cyclique}
Ecrire ( posi , i )
POUR j DE 0 A i FAIRE
Ecrire ( T[ j ] )
Fin Pour
Fin Si
8) Fin INSIPID

Tableau de codification des objets globaux


Objet Type / Nature Rôle
T Tab Tableau des éléments de la séquence
i, j Entier Compteurs
posi Entier Position trouvée
U0 Entier Entier saisit

Tableau de déclaration des nouveaux types


Type
Tab = Tableau de 99 Entiers

DOC4MTINFCS0012  Page 4 
http://www.najah.com 

Solution du sujet T3 - 13

Solution et barème de l’épreuve théorique d’informatique


Examen du baccalauréat
Session principale : juin 2006
Sections : Mathématiques, Sciences expérimentales et Technique

Partie I (6 points)
Exercice 1 : (3 points)

Soit la fonction booléenne VERIF suivante :

1) FUNCTION VERIF (Ch : String) : Boolean ;


Var
Vc : Integer;
Test : Boolean ;
Begin
Test := False ;
Vc := o;
Repeat
Vc := Vc + 1;
If Not(Upcase (Ch[Vc]) in ['A' .. 'Z'])
Then
Begin
Test := True;
End;
Until (Test) Or (Vc = Length(ch));
VERIF : Test ;
End ;

2) Cette fonction booléenne permet de renvoyer la valeur « VRAI » s'il y a un caractère


différent d'une lettre dans la chaîne ch sinon la valeur « FAUX ».

Exercice 2 : (3 points)

Mettre devant chaque aperçu le numéro du code HTML correspondant.

N° Code HTML Aperçu N° du code HTML


<OL>
<LI> Examen pratique </LI> Examen pratique
1 4
<LI> Examen théorique </LI> Examen théorique
</OL>
Examen pratique Examen pratique
2 5
Examen théorique Examen théorique
3 <B> Examen pratique </B> 1. Examen 1

DOC4MTINFCS0013  Page 1 
http://www.najah.com 

pratique
2. Examen
théoriqu
e
<U> Examen pratique </U> <BR>
Examen pratique Examen
4 <Centrer> Examen théorique 3
théorique
</Center>
Examen pratique
Examen pratique Examen
5 <BR> 2
théorique
Examen théorique

Partie II (14 points)

1) Analyse du problème

Résultat =
Une même procédure nommée Affiche, permet l'affichage des trois tableaux et ce par trois
appels différents.
Proc Affiche (n, T1)
Proc Affiche (n, T2)
Proc Affiche (m, INTER)
Traitement :
- Une procédure Intersection permet de faire l'intersection des deux tableaux T1 et T2 dans le
tableau INTER à m éléments.
Proc Intersection (n, T1, T2, m, INTER)

- Une même procédure Remp, permet de remplir les deux tableaux T1 et T2 par deux appels
successifs.
Proc Remp (n, T1)
Proc Remp (n, T2)
- Une procédure Saisie, permet la saisie et le test de du nombre d'éléments N.
Proc Saisie (n)
Fin Analyse

a) Tableau de déclaration des nouveaux types

Type
Vect = Tableau de n éléments de type entier

b) Tableau de déclaration des objets globaux

Objets utilisés Type/Nature Rôle


Affiche Procédure Affichage du contenu d'un tableau
n Entier Nombre d'éléments
T1 vect Tableau 1

DOC4MTINFCS0013  Page 2 
http://www.najah.com 

T2 Vect Tableau 2
m Entier Nombre d'éléments de l'intersection
INTER Vect Tableau de l'intersection
Intersection Procédure Réalise l'intersection de T1 et T2 dans Inter
Remp Procédure Remplit un tableau
Saisie Procédure Saisie le nombre d'élément N

2) Analyse des modules

2 – 1) Analyse de la procédure affiche


Résultat = Affiche le contenu d'un tableau
Traitement :
Pour i de 1 à n Faire
Ecrire (A[i])
Fin Pour
Fin analyse

Algorithme
0) Procédure Affiche (n : Entier ; A :Vect)
1) Pour i de 1 à n Faire
Ecrire (A[i])
Fin Pour
2) Fin Affiche

Tableau de déclaration des objets locaux

Objets utilisés Type/Nature Rôle


i Entier Compteur

2-2) Analyse de la procédure intersection


Résultat = Tableau contenant l'intersection de T1 et T2
Traitement :
On parcourt le parcourt le premier tableau et on vérifie chacun de ses éléments s'il existe dans
le deuxième tableau, c'est le rôle de la fonction Booléenne existe.
Si la fonction retourne vrai, l'élément sera placé dans le tableau d'intersection.
Le nombre d'éléments trouvés est égal à la taille m du tableau d'intersection.
m est un compteur qui doit être initialisé à zéro.0
Fin Analyse

Algorithme
0) Procédure Intersection (n : entier ; A1, A2 : Vect ; VAR m : entier ; VAR B : vect)

DOC4MTINFCS0013  Page 3 
http://www.najah.com 

1) m ← 0
2) Pour i de 1 à n Faire
Si Fn Existe (A1[i], n, A2) Alors
m ← m+1
B [m] ← A1 [i]
Fin Si
Fin Pour
3) Fin intersection

Tableau de déclaration des objets locaux

Objets utilisés Type/Nature Rôle


i Entier Compteur
Existe Fonction Cherche si élément existe dans T1 et T2

2-3) Analyse de la fonction existe


Résultat = existe
Traitement :
On suppose que l'élément de T1 existe dans T2 (test Å Vrai), si l'élément n'est pas trouvé
après un parcourt total du tableau alors le test reçoit Faux
La fonction reçoit test comme résultat.
Fin analyse.

Algorithme
0) Fonction Existe (v : Entier ; k : entier; A : vect) : Booléen
1) Test ← Vrai
2) i ← 1
3) Tant Que (A[i] ≠ v) et (i ≤ k) Faire
i← i+1
Fin Tant Que
4) Si (i = k+1) Alors
Test ← Faux
FinSi
5) Existe ← test
6) Fin existe

Tableau de déclaration des objets locaux

Objets utilisés Type/Nature Rôle


i Entier Compteur
Test Booléen Drapeau de test

DOC4MTINFCS0013  Page 4 
http://www.najah.com 

2-4) Analyse de la procédure remp


Résultat = Remplir un tableau par des éléments distincts deux à deux
Traitement :
Lire le premier élément (élément de référence puisque c'est un traitement récurent)
Pour i de 2 à n Faire
On lit l'élément d'indice i, puis par appel à la fonction existe déjà étudiée, on vérifie
qu'il n'existe pas dans les éléments précédents.
Non (Fn Existe (A[i], i-1, A))
Fin analyse

Algorithme
0) Procédure Remp (n : entier ; VAR A : vect)
1) Lire (A[1])
2) Pour i de 2 à n Faire
Répéter
Lire (A[i])
Jusqu'à NON (FN Existe (A[i], i - 1, A))
FinPour
3) Fin remp

Tableau de déclaration des objets locaux

Objets utilisés Type/Nature Rôle


i Entier Compteur

2-5) Analyse de la procédure saisie


Résultat = Lire et tester la validité d'un entier
Traitement
Répéter
Lire(k)
Jusqu'à k dans [3 .. 99]
Fin Analyse

Algorithme
0) Procédure Saisie (VAR k : entier)
1) Répéter
Lire (k)
Jusqu'à k dans [3 .. 99]
2) Fin Saisie

DOC4MTINFCS0013  Page 5 
http://www.najah.com 

Solution du sujet T3 - 14
Analyse du programme principal Jeu_de_mots

Résultat = Afficher Le mot (existe ou n'existe pas) dans la matrice


Traitement :
- Chercher l'existante du mot ou de son inverse dans la matrice que se soit dans le sens
horizontal, vertical ou diagonal.
C'est le rôle de la fonction Booléenne Trouve.

- Une fonction Inverse retourne l'inverse du mot ch.

- Une procédure Lecture permet la lecture, le test et la conversion en majuscule du mot ch à


chercher.

- Une procédure Remplir permet de ranger des lettres majuscules dans la matrice M.

- Une procédure Saisie permet la saisie et le test de validité de l'entier N représentant l'ordre
de la matrice.
Fin Jeu_de_mots

Algorithme
0) Début Jeu_de_mots
1) Proc Saisie (N)
2) Proc Remplir (M, N)
3) Proc Lecture (ch, N)
4) inv_ch Å FN Inverse(ch)
5) Result Å FN Trouve (N, M, ch, in_ch)
6) Si Result Alors Ecrire ("le mot ", mot, " se trouve dans la matrice ")
Sinon Ecrire ("le mot ", mot, " ne se trouve pas dans la matrice ")
Fin Si
7) Fin Jeu_de_mots

Tableau de déclaration des objets globaux


Objet Type / Nature Rôle
M Matrice de 10x10 caractères Matrice carrée
Ch Mot Le mot à chercher
Inv_ch Mot L'inverse de mot
N Entier Ordre de la matrice
Result Booléen Vrai si le mot existe, faux sinon

Analyse de la procédure Saisie


Résultat = saisie et test de l'entier N
Traitement
Répéter
DOC4MTINFCS0014  Page 1 
http://www.najah.com 

N = Donnée ("Entrer l'ordre de la matrice ")


Jusqu'à N Dans [3 .. 10]
Fin Saisie
Algorithme
0) Procédure Saisie (VAR N : Entier)
1) Répéter
Ecrire ("Entrer l'ordre de la matrice : ")
Lire (N)
Jusqu'à N Dans [3 .. 10]
2) Fin saisie

Analyse de la procédure Remplir


Résultat = Remplir par des caractères majuscules la matrice M
Traitement
Lire uniquement une lettre, la convertir en majuscule et la ranger dans la matrice M.
Répéter ce traitement pour remplir toute la matrice.
Fin Remplir

Algorithme
0) Procédure Remplir (N : Entier ; VAR M : Matrice)
1) Pour i de 1 à N Faire {ligne}
Pour j de 1 à N Faire {colonne}
Répéter
Ecrire ("Donner M[", i , " ," , j , " ] : ")
Lire (M[i, j] )
M[i, j] Å Majuscule M[i, j]
Jusqu'à M[i, j] Dans ["A" .. "Z"]
Fin Pour
Fin Pour
2) Fin Remplir

T.D. Objets locaux


Objet Type / Nature Rôle
i Entier Compteur des lignes
j Entier Compteur des colonnes

Analyse de la procédure Lecture


Résultat = Lecture d'un mot
Traitement
Lire un mot, tester sa longueur qui doit être égal à N puis le convertir en majuscule.
Fin Lecture

DOC4MTINFCS0014  Page 2 
http://www.najah.com 

Algorithme
0) Procédure Lecture (VAR ch : Mot ; N : Entier)
1) Répéter
ch = Donnée ("Entrer le mot à chercher ")
Jusqu'à (Longueur (ch) = N)

2) Pour i de 1 à N Faire
ch[i] Å Majuscule (ch[i])
Fin Pour
3) Fin Lecture

T.D. Objets locaux


Objet Type / Nature Rôle
i Entier Compteur pour parcourir la chaîne ch

Analyse de la fonction Inverse


Résultat = Inverse
Traitement
Parcourir la chaîne "ch" dans le sens inverse, et cumuler les lettres dans une nouvelle variable
"inv" de type mot.
Pour i de longueur (ch) à 1 Faire
inv Å ch[i]
Fin pour

La variable "inv" doit être initialisée à vide


inv Å ""
Fin Inverser

Algorithme
0) Fonction Inverse (ch : Mot) : Mot
1) inv Å ""
2) Pour i de longueur (ch) à 1 faire
inv Å inv + ch[i]
Fin Pour
3) Inverse Å inv
4) Fin Inverse

T.D.Objets locaux
Objet Type / Nature Rôle
inv Chaîne Pour construire la chaîne inverse de ch
i Entier Compteur pour parcourir la chaîne ch

DOC4MTINFCS0014  Page 3 
http://www.najah.com 

Analyse de la fonction Trouve


Résultat = Trouve
Traitement
On forme un nouveau mot avec les lettres se trouvant sur la diagonale principale. On compare
ce nouveau mot avec le mot recherché ou avec son inverse, s'ils sont égaux la variable
Booléenne OKD Å VRAI.
Traitement effectué par la fonction Mot_Diagonale
Sinon
On forme un nouveau mot avec les lettres se trouvant sur la ligne 1 et on fait les mêmes tests
que précédemment. Si les deux mots sont égaux, la variable Booléenne OKL (OK Ligne) Å
VRAI
Traitement effectué par la fonction Mot_Ligne.
Sinon
On forme un nouveau mot avec les lettres se trouvant sur la colonne 1 et on fait les mêmes
tests que précédemment. Si les deux mots sont égaux, la variable Booléenne OKC (OK
Colonne) Å VRAI
Traitement effectué par la fonction Mot_Colonne.
Si l'une des variables OKL ou OKC ou OKD est VRAI Alors La variable Booléenne OK Å
VRAI
Sinon On répète ces deux derniers traitements jusqu'à OK (le mot est trouvé) ou NON OK
(toute la matrice est vérifiée et le mot n'est pas trouvé).
Fin Trouve.

Algorithme
0) Fonction Trouve (N : Entier ; M : Matrice ; ch, inv_ch : Mot) : Booléen
1) OK Å Faux
2) OKD Å ((FN Mot_Diagonale (N, M,1) = ch) OU ((FN Mot_Diagonale (N, M, 1) = inv_ch
))
Si OKD Alors OK Å Vrai
Sinon
OKD Å ((FN Mot_Diagonale (N, M, 2) = ch) OU ((FN Mot_Diagonale (N, M, 2) =
inv_ch ))
Fin Si

Si OKD Alors OK Å Vrai


Sinon
iÅ1
Tant Que ((NON OK) ET (i < = N )) Faire
OKL Å ((FN Mot_Ligne (N, i, M) = ch) OU (FN Mot_Ligne (N, i, M) = inv_ch))
OKC Å ((FN Mot_Colonne (N, i, M) = ch) OU (FN Mot_Colonne (N, i, M) =
inv_ch))
Si (OKL) OU (OKC) Alors OK Å Vrai
Sinon i Å i + 1
Fin Si
Fin Tant Que

DOC4MTINFCS0014  Page 4 
http://www.najah.com 

Fin Si
Trouve Å OK
3) Fin Trouve

T.D.Objets locaux

Objet Type / Nature Rôle


OKD Booléen Vrai si le mot est trouvé dans une diagonale
OKL Booléen Vrai si le mot est trouvé dans une ligne
OKC Booléen Vrai si le mot est trouvé dans une colonne
OK Booléen Vrai si le mot est trouvé
i Entier Compteur des lignes et des colonnes
Mot_Ligne Fonction Forme le mot de la ligne en cours
Mot_Colonne Fonction Forme le mot de la colonne en cours
Mot_Diagonale Fonction Forme le mot de la diagonale en cours

Analyse de la fonction Mot_Ligne


Résultat = Mot_Ligne

Traitement :
On parcourt toute les colonnes pour concaténer les N lettres de la ligne L en cours. On
forme ainsi le mot de la ligne.
Pour k de 1 à N Faire
ml Å ml + M[L, k]
La variable ml doit être initialisée à vide
ml Å ""
Fin Mot_Ligne

Algorithme
0) Fonction Mot_Ligne (N, L : Entier ; M : Matrice ) : Mot
1) ml Å ""
2) Pour k de 1 à N Faire
ml Å ml + M[L, k]
Fin Pour
3) Mot_Ligne Å ml
4) Fin Mot_Ligne

T.D.Objets locaux
Objet Type / Nature Rôle
k Entier Compteur des colonnes
ml Mot le mot de la ligne

DOC4MTINFCS0014  Page 5 
http://www.najah.com 

Analyse de la fonction Mot_Colonne


Résultat = Mot_Colonne
Traitement :
On parcourt toute les lignes pour concaténer les N lettres de la colonne C en cours. On
forme ainsi le mot de la colonne.
Pour k de 1 à N Faire
mc Å mc + M[k, C]
La variable mc doit être initialisée à vide
mc Å ""
Fin Mot_Colonne

Algorithme
0) Fonction Mot_Colonne (N, C : Entier ; M : Matrice ) : Mot
1) mc Å ""
2) Pour k de 1 à N Faire
mc Å mc + M[k, C]
Fin Pour
3) Mot_Colonne Å mc
4) Fin Mot_Colonne

T.D.Objets locaux
Objet Type / Nature Rôle
k Entier Compteur des lignes
mc Mot le mot de la colonne
Analyse de la fonction Mot_Diagonale
Résultat = Mot_Colonne
Traitement :
Si le sens est 1, on parcourt les lignes et les colonne de la diagonale principale pour
concaténer les N lettres. On forme ainsi le mot de la diagonale principale (sens = 1):
Si Sens = 1 Alors
Pour k de 1 à N Faire
md Å + M[k, k]
Fin Pour

Si le sens est 2, on parcourt les lignes et les colonne de l'autre diagonale :


Sinon
Pour k de 1 à N Faire
md Å md + M[k, N-k+1]
Fin Pour
Fin Si

La variable md doit être initialisée à vide


md Å ""
Fin Mot_Diagonale

DOC4MTINFCS0014  Page 6 
http://www.najah.com 

Algorithme
0) Fonction Mot_Diagonale (N : Entier ; M : Matrice, Sens : Entier) : Mot
1) md Å ''"
2) Si Sens = 1 Alors
Pour k de 1 à N Faire
md Å md + M[k, k]
Fin Pour
Sinon
Pour k de 1 à N Faire
md Å md + M[k, N-k+1]
Fin Pour
Fin Si
3) Mot_Diagonale Å md
4) Fin Mot_Diagonale

T.D.Objets locaux
Objet Type / Nature Rôle
md Mot Le mot de la diagonale
k Entier Compteur

Traduction en Pascal
PROGRAM Jeu_de_mots ;
USES WinCrt;
TYPE
Matrice = Array[1..10,1.. 10] OF Char ;
Mot = String [10] ;
VAR
M : Matrice;
N : Integer;
Ch, Inv_ch : mot ;
Result : Boolean ;

{------------------------------------------------------------------------------------}
PROCEDURE Saisie (VAR N : Integer) ;
BEGIN
Repeat
Write ('Entrer l''ordre de la matrice : ');
ReadLn (N) ;
Until (N IN [3..10]);
END ;

{------------------------------------------------------------------------------------}
PROCEDURE Remplir (N : Integer ; VAR M : Matrice) ;
VAR

DOC4MTINFCS0014  Page 7 
http://www.najah.com 

i, j : Integer ;
BEGIN
For i:=1 TO N Do
Begin
For j:=1 TO N Do
Begin
Repeat
Write ('Donner M[', i , ' , ' , j , '] = ');
ReadLn (M[i , j]);
M[i , j] := UpCase (M[i , j]);
Until (M[i, j] IN ['A'..'Z']);
End ;
WriteLn (' ****************************************** ');
End;
END;

{------------------------------------------------------------------------------------}
PROCEDURE Lecture (VAR ch : Mot ; N : Integer) ;
VAR i : Integer ;
BEGIN
Repeat
Write ('Entrer le mot à chercher : ') ;
ReadLn (ch);
Until (Length (ch) = N) ;
For i: = 1 TO N Do
ch[i] := UpCase (ch[i]) ;
END;

{------------------------------------------------------------------------------------}
FUNCTION Inverse (ch : Mot ): Mot ;
VAR
inv : Mot ;
i : Integer ;
BEGIN
inv := '' ;
For i:= Length (ch) DOWNTO 1 do
inv:= inv + ch[i] ;

Inverse := inv ;
END ;

{------------------------------------------------------------------------------------}
FUNCTION Mot_Ligne (N, L : Integer ; M : Matrice) : Mot ;
VAR ml : Mot ;
k : Integer ;
BEGIN
ml := '' ;
For k := 1 To N Do

DOC4MTINFCS0014  Page 8 
http://www.najah.com 

ml := ml + M[L, k] ;
Mot_Ligne := ml ;
END ;

{------------------------------------------------------------------------------------}
FUNCTION Mot_Colonne (N, C : Integer ; M : Matrice) : Mot ;
VAR
mc : Mot ;
k : Integer ;
BEGIN
mc := '' ;
For k := 1 To N Do
mc := mc +M[k, C] ;
Mot_Colonne := mc ;
END;

{------------------------------------------------------------------------------------}
FUNCTION Mot_Diagonale (N : Integer ; M : Matrice ; Sens : Integer) : Mot ;
VAR
k : Integer ;
md : Mot;
BEGIN
md := '' ;

If Sens = 1 Then
Begin
For k := 1 To N Do
md := md + M[k, k] ;
End
Else
Begin
For k := 1 To N Do
md := md + M[k, N-k+1] ;
End ;

Mot_Diagonale := md ;
END;
{------------------------------------------------------------------------------------}
FUNCTION Trouve (N : Integer ; M : Matrice ; ch, inv_ch : Mot) : Boolean ;
VAR
i, j : Integer ;
OK, OKL, OKC, OKD : Boolean;
BEGIN
OK := FALSE ;
OKD := ((Mot_Diagonale (N, M, 1) = ch) OR (Mot_Diagonale (N, M, 1) = inv_ch )) ;
If OKD Then OK := TRUE
Else
OKD := ((Mot_Diagonale (N, M, 2) = ch) OR (Mot_Diagonale (N, M, 2) = inv_ch )) ;

DOC4MTINFCS0014  Page 9 
http://www.najah.com 

If OKD Then OK := TRUE


Else
Begin
i := 1;
While ((NOT OK) AND (i <= N )) Do
Begin
OKL := ((Mot_Ligne (N, i, M) = ch) OR (Mot_Ligne (N, i, M)= inv_ch)) ;
OKC := ((Mot_Colonne (N, i, M) = ch) OR (Mot_Colonne (N, i, M) =
inv_ch)) ;
If (OKL) OR (OKC) Then OK := TRUE
Else i := i+1 ;
End ;
End ;

Trouve:= OK ;
END ;

{================= P P ======================}

BEGIN
Saisie (N) ;
Remplir (N, M) ;
Lecture (ch, N) ;
inv_ch := Inverse (ch) ;
Result := Trouve (N, M, ch, inv_ch) ;
If Result Then WriteLn ('Le mot ', ch, ' existe dans la matrice M ')
Else WriteLn ('Le mot ', ch, ' n"existe pas dans la matrice M');
END.

DOC4MTINFCS0014  Page 10 
http://www.najah.com 

Solution du sujet T3 - 15
BACCALAUREAT Session : JUIN 1990

CORRIGE DU SUJET

I/ QUESTIONS (1 point par réponse correcte)

N° de la question N° du choix correct


1 2
2 3
3 2
4 3
5 3
6 1

II/ Problème

PROCEDURE SAISIE_POLY

0) PROCEDURE SAISIE_POLY( degré : entier ; table : tab)


1) SI degré = 0
ALORS
Lire (table [degré])
SINON
TANT QUE table [degré] = 0 FAIRE
Lire (table [degré])
Fin tant que
POUR i DE degré-1 A 0 FAIRE
Lire (table [i])
Fin Pour
Fin si

2) SI degré < DEG_MAX


ALORS
POUR i DE degré+1 A DEG_MAX FAIRE
table [i] ← 0
Fin Pour
Fin Si
3) FIN SAISE_POLY

T. D. Objets locaux
Objet Type / Nature Rôle
i Entier Compteur

DOC4MTINFCS0015  Page 1 
http://www.najah.com 

Remarque : DEG_MAX est déclarée dans la zone CONST et tab dans la zone TYPE comme
étant un tableau à DEG_MAX +1 éléments.
Ce sont des objets globaux.

DOC4MTINFCS0015  Page 2 
http://www.najah.com 

2 - a ) FONCTION VAL_POLY

0) FONCTION VAL_POLY (degré : entier ; table : tab ; x0 : réel) : réel


1) résultat ← 0
2) POUR i DE degré A 0 FAIRE
résultat ← résultat * x0 + table [i]
Fin Pour
VAL_POLY ← résultat
3) Fin VAL_POLY

T. D. Objets locaux
Objet Type / Nature Rôle
résultat Réel Pour le calcul du résultat

b) En Pascal

FUNCTION VAL_POLY(degre : Integer ; table: tab ; x0: real): real ;


VAR resultat : real;
BEGIN
resultat := 0 ;
FOR i := degre TO 0 DO
resultat := resultat * x0 + table [i ];

VAL_POLY := resultat;
END;

3) ALGORITHME PROCEDURE SOM_POLY

0) PROCEDURE SOM_POLY (degré1, degré2 : entier ; table1, table2, coef_som : tab )


1) POUR i DE 0 A DEG_MAX FAIRE
coef_som[ i ] ← table1[ i ] + table2 [ i ]
Fin Pour
2) Fin SOM_POLY

T. D. Objets locaux

Objet Type / Nature Rôle


résultat Réel Pour le calcul du résultat

NB : - les paramètres formels degré1 et degré2 sont facultatifs.

DOC4MTINFCS0015  Page 3 
http://www.najah.com 

- le parcours de 0 à DEG_MAX permet de compléter en cas de besoins coef_som par


des zéros (Initialisation nécessaire).

4 - a ) ALGORITHME PROCEDURE SORTIE_POLY

0) PROCEDURE SORTIE_POLY ( table : tab)


1) indicateur ← 0
2) POUR i DE 0 A DEG_MAX FAIRE
SI table [ i ] ≠ 0
ALORS
Ecrire (table [ i ] , " " , i)
indicateur ← 1
Fin si
Fin Pour
3) SI indicateur = 0
ALORS
Ecrire( " polynôme nul ")
Fin Si
4) Fin Sortie_Ploy

b) En Pascal
PROCEDURE SORTIE_POLY ( table : tab);
VAR
i , indicateur : Integer;

BEGIN
indicateur := 0;
FOR i:=0 TO DEG_MAX DO
IF table[ i ] < > 0 THEN
BEGIN
WriteLn( table[ i ], ' ' , i );
indicateur := 1;
END;
IF indicateur = 0 THEN WriteLn( ' polynôme nul ');
END;

DOC4MTINFCS0015  Page 4 
http://www.najah.com 

Solution du sujet T3 - 16
EXAMEN DU BACCALAUREAT (session : JUIN 1992)
SUJET : INFORMATIQUE

CORRIGE DU SUJET

EXERCICE 1 (6 points)

1) L'instruction " IF ... THEN ... ELSE ... " traduit :

V une alternative V une définition F une boucle


conditionnelle

2) L'instruction " FOR ... TO ... DO ... " traduit :

V une itération V une répétition V une boucle

3) Les éléments suivants sont des périphériques d'un ordinateur :

V un clavier F une U.A.L V un scanner


(unité arithmétique
et logique)

4) Un microprocesseur est :

F un programme F un programme en F un D.O.S.


en assembleur langage machine

5) FFFF écrit en hexadécimal, vaut en décimal :

V 65535 F 65536 F 64000

a, b et c sont des variables booléennes. a , b et c désignent respectivement non a, non b


et non c. " + " et " . " représentent respectivement les opérateurs logiques " ou " et " et ".
L'expression a + a . b vaut :

F 0 V a + a + c V 1

DOC4MTINFCS0016  Page 1 
http://www.najah.com 

EXERCICE 2
1/
a/ Transformation de la permutation ( 1, 2, 3, 4).

Etape 1 : i=4
Etape 2 : j=4
Etape 3 : On permute 3 et 4 on obtient ( 1, 2, 4, 3)
Etape 4 : on renverse la séquence 3 (En fait, ne rien faire ), on obtient (1, 2, 4, 3)

b/ Transformation de la permutation (1, 4, 3, 3, 2).

Etape 1 : i=2
Etape 2 : j=4
Etape 3 : On permute 1 et 4 on obtient (2, 4, 3, 1)
Etape 4 : On renverse l'ordre de (4, 3, 1) on obtient la permutation ( 2, 1, 3, 4)

Transformation de la permutation (4, 3, 2, 1)

Pas de i tel que T[i - 1] < T[ i ] donc il n'est pas possible d'appliquer cet
algorithme tel qu'il est indiqué.

2/ ALGORITHME FONCTION PGI


0) FONCTION PGI ( ) : Entier
1) i ← 0
2) POUR k DE 2 A n FAIRE
Si T[ k - 1 ] < T[ k ]
ALORS i ← k
Fin Si
Fin Pour
3) PGI ← i
4) Fin PGI

T. D. Objets locaux
Objet Type / Nature Rôle
i,k Entiers Compteurs

3 / ALGORITHME FONCTION PGJ


0) FONCTION PGJ ( r : Entier ) : Entier
1) j ← r
2) POUR k DE r A n FAIRE
SI T[ r-1 ] < T[ k ]
ALORS j ← k
Fin Si

DOC4MTINFCS0016  Page 2 
http://www.najah.com 

Fin Pour
3) PGJ ← j
4) Fin PGJ
T. D. Objets locaux
Objet Type / Nature Rôle
j,k Entiers Compteurs

4/ ALGORITHME PROCEDURE PERMUTE


0) PROCEDURE PERMUTE ( k, L : Entier )
1) aux ← T[ k ]
2) T[ k ] ← T[ L ]
3) T[ L ] ← aux
4) Fin PERMUTE

T. D. Objets locaux
Objet Type / Nature Rôle
aux Entiers Variable auxiliaire

5 / ALGORITHME PROCEDURE RENVERSE


0) PROCEDURE RENVERSE ( k : Entier )
1) L ← (n - k + 1) DIV 2
2) SI L ≠ 0
ALORS
POUR m DE 0 A L -1 FAIRE
PERMUTE ( k + m , n - m )
Fin Pour
Fin Si
3) Fin RNVERSE

T. D. Objets locaux
Objet Type / Nature Rôle
m Entiers Compteur

6/ ALGORITHME PRINCIPAL
0) Début Principal
1) REPETER
Lire( n )
JUSQU'A n > 0

2) POUR k DE 1 A n FAIRE
T[ k ] ← k
Fin Pour

DOC4MTINFCS0016  Page 3 
http://www.najah.com 

3) POUR k DE 1 A n-1 FAIRE


Ecrire ( T[ k ] , " , " )
Fin Pour

4) Ecrire ( T[ n ] )

5 ) REPETER
i ← PGI
SI i ≠ 0 ALORS
j ← PGJ( i )
PERMUTE ( i-1 , j )
RENVERSE ( i )
POUR L DE 1 A n-1 FAIRE
Ecrire ( T[ L ] , " , " )
Fin Pour
Ecrire ( T[ n ] )
Fin Si
JUSQU'A ( i = 0 )
6) Fin Principal

T. D. Objets locaux
Objet Type / Nature Rôle
max Constante = 200 Max du Tableau {n'est pas une limite}
T Tab Tableau d'entiers
n Entier Nombre d'éléments
k, L, j, i Entier Compteurs

T.D. Nouveaux types


Type
Tab = Tableau de Max Entiers

DOC4MTINFCS0016  Page 4 
http://www.najah.com 

Solution du sujet T3 - 17
CORRIGE DU SUJET DE BAC (JUIN 2003)

PARTIE I
Exercice 1 (3 points)
On donne la liste suivante d’extensions de fichiers :
GIF ; AVI ; JPG ; EXE ; MP3 ; DOC ; PAS ; BPM ; TXT ; WAV ; HTM ; XLS

A partir de cette liste, mettre dans chaque colonne du tableau ci-dessous les extensions
habituellement utilisées pour les trois types de fichiers : image, son et vidéo .

Types de fichiers
Image Son Vidéo
Gif.. MP3.. AVI
JPG WAV. ……………
BMP …………………. ……………

Exercice 2 (3 points)
Dans le domaine informatique, donner les définitions des termes suivants :

Adresse IP :
Identifiant numérique unique d’une machine connectée à un réseau utilisant le protocole
TCP/IP.

Internet :
Réseau mondial, réseau des réseaux.

Adresse électronique:
Adresse e-mail, adresse de courrier, courrier, adresse de messagerie.

DOC4MTINFCS0017  Page 1 
http://www.najah.com 

PARTIE II (14)

1) pour n=6 et m= 4, les opérations sur T sont :

Etat initial du tableau T : 1 2 3 4 5 6

Etat de T après la 2 1 3 4 5 6
première opération

Etat de T après la 1 3 2 4 5 6
deuxième opération

Etat de T après la 3 1 2 4 5 6
troisième opération

Etat de T après la 1 2 4 3 5 6
quatrième opération

Etat de T après la 2 1 4 3 5 6
cinquième opération

Etat de T après la sixième 1 4 2 3 5 6


opération

Etat de T après la 4 1 2 3 5 6
septième opération

2) Les analyses

2-1) Décomposition en modules :

PROC
PROC Saisie PROC remplir traitement PROC Affichage

P.P décalage

2-2) Analyse du programme principal

Résultat =PROC Affiche (T, N)


Traitement :
PROC Saisie (N)
PROC traitement(T, N, M, nb)
M= donnée (‘’M =’’)

DOC4MTINFCS0017  Page 2 
http://www.najah.com 

PROC Remplir (T, N)


Fin décalage

Tableau de codification des objets globaux


Objet Type / Nature Rôle
N Entier Nombre d'entiers du tableau
M Entier Entier donné
T Tab Tableau d'entiers
Saisie Procédure Saisie de N
Remplir Procédure Remplir le tableau T
Traitement Procédure Chercher le nombre d'opérations
Affiche Procédure Affiche le tableau et le nombre d'opérations.

Tableau de déclaration des nouveaux types


Type
Tab = Tableau de 49 Entiers

2 –3) Analyse de la procédure Saisie

Résultat = Saisie de N
Traitement :
Répéter
N = Donnée
Jusqu'à N dans [6 .. 49]
Fin Saisie

2-4) Analyse de la procédure Remplir


Résultat = Initialiser le tableau à la valeur de son indice
Traitement :
Pour i de 1 à N Faire
T[i] Å i
Fin Pour
Fin Remplir

Tableau de codification des objets locaux


Objet Type / Nature Rôle
i Entier Compteur

2-5) Analyse de la procédure traitement

DOC4MTINFCS0017  Page 3 
http://www.najah.com 

Résultat = Réaliser les reculs et chercher le nombre d'opérations nécessaires


Traitement ;
nbÅ0
Répéter
PÅ T[1]
Pour i de 1 à p Faire
T[i] Å T[ i+1 ]

Fin pour
T[p+1] Åp
NbÅnb+1
Jusqu à T[1] =m
Fin traitement

Tableau de codification des objets locaux


Objet Type / Nature Rôle
i Entier Compteur
p Entier Variable de sauvegarde

2-6) Analyse de la procédure Affiche

Résultat = Afficher le nouveau tableau et le nombre d'opérations.


Traitement :
Pour i de 1 à n Faire
Ecrire (T[i])
Fin Pour
Ecrire (‘’le nombre de répétition est ‘’, nb)
Fin Affiche

Tableau de codification des objets locaux


Objet Type / Nature Rôle
i Entier Compteur

3) Les algorithmes
a/ Algorithme du programme principal
0) Début Décalage
1) PROC Saisie (n)
2) PROC Remplir (T, N)
3) Ecrire (‘’M =’’) lire (M)
4) PROC Traitement (T, N, M, nb)
5) PROC Affiche (T, N)
DOC4MTINFCS0017  Page 4 
http://www.najah.com 

6) Fin décalage

b/ Algorithme de la procédure Saisie


0) Procédure Saisie (VAR N : Entier )
1) Répéter
Lire (N)
....Jusqu'à N dans [1 .. 50 ]
2) Fin Saisie

c/ Algorithme de la procédure Remplir


0) Procédure Remplir (VAR T : Tab; N : Entier)
1) Pour i de 1 à N Faire
T[i] Åi
...Fin Pour
2) Fin Remplir

d/ Algorithme de la procédure Traitement


0) Procédure Traitement (var T :tab ; N, M: Entier ; var nb :entier)
1) nbÅ0
2) Répéter
PÅ T[1]
Pour i de 1 à p Faire
T[i] Å T[ i+1 ]
Fin pour
T[p+1] Åp
NbÅnb+1
Jusqu'à T[1] =m
3) Fin traitement

e/ Algorithme de la procédure Affiche

0) Procédure Affiche (T : Tab ; n,m : Entier )


1) Pour i de 1 à n Faire
Ecrire (T[i])
Fin Pour
2) Ecrire ("le nombre de répétition est : ", nb)
3) Fin Affiche

DOC4MTINFCS0017  Page 5 

Vous aimerez peut-être aussi