Corrig Sjjets Fichiers PDF

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
T.D.O. Globaux
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é
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.
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
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
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)
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
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
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
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
nb Å nb + T[i]
Fin Pour
Ecrire ("Le nombre total de lettres dans le fichier est : ", nb)
Fin Affiche
T.D.O. Locaux
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
nb Å nb + T[i]
Fin Pour
3) Ecrire ("Le nombre total de lettres dans le fichier est : ", nb)

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
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;
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);
Affiche (T);
END.
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

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
- 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

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
3) Fin Remplir
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.
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 ;
{ ________ 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 ) ;
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 ;
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 ? ');
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 ');
Writeln ;
End
Else
Begin
Repeat
Write ('Vouler vous fermer Le fichier ', nf, ' (O / N) ? ' );
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
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);
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
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

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
WriteLn; WriteLn ;
Until rep = 'N' ;
END ;
{ ________ 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

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
WriteLn; WriteLn ;
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';
If ouvert Then close(nl);

END;
{ ============= Programme Principal =========================== }
BEGIN
ouvert := false ; { init : aucun fichier n'est ouvert }
Menu (choix);
END.
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 :
F 8 F 19 V 22
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

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

nc Entier Compteur
1 - c / ALGORITHME PROCEDURE AFFICHE

0) Procédure Affiche (MOT : Chaîne)
1) Ecrire (MOT)
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

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
Tableau de codification des objets globaux

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
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)
- 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

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
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

i Entier Compteur
voix Caractère F, D ou N

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

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
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
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
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 ;
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;
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.
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

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

Résultat = Saisie et test de N
Traitement
Répeter
Lire (N)
Jusqu'à (N ≥ 10) ET (N ≤ Maxi)
Fin Saisie
Algorithme
1) Répéter
Ecrire ("Entrer un entier N compris entre 10 et " , Maxi )
Lire (N)
Jusqu'à (N ≥ 10) ET (N ≤ Maxi)

2) Fin Saisie
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

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
- 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

c Entier Compteur
p Entier Le pas
Tmp Entier Variable temporaire de sauvegarde
pos Entier Position actuelle d'une valeur à déplacer

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
Ecrire T[i]
Fin Pour
Fin Affiche
Algorithme
0) Procédure Affiche (T : Vect ; N : Entier)
Ecrire (T[i])
Fin Pour
2) Fin Affiche

i Entier Compteur
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 ;
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.
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.
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;
UNTIL N=0;
END;
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

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 ] )
Fin Pour
3) Fin Concaténation

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

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.

Type
Vecteur = Tableau de Rmax entiers
Mot = Chaîne [Rmax]
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 ;
(76)8 < (77)8 < (100)8

(29E)16 < (29F)16 < (2A0)16
(110010)2 < (110011)2 < (110100)2
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

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
Si A[ i ] > V Alors R ← R + 1
Fin Si
Fin Pour
3) RANG ← R
4) Fin Rang

i, R Entiers Compteurs
3/ a) ALGORITHME PROCEDURE RANGS
0) Procédure Rangs (n : Entier; A: TAB; VAR R : RA)

R [ i ] ← Fn RANG (n, A, A[ i ] )
Fin pour
2) Fin Rangs

i Entier Compteur
Rang Fonction Cherche le rang pour une moyenne V
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)

Ecrire ( i, A[ i ], R[ i ] )
Fin Pour
2) Fin Affiche

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

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

Type
Tab = Tableau de N Réels
RA = Tableau de N Entiers
CORRIGE DU SUJET DE BAC (JUIN 2001)
PARTIE 1 (6 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)
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 :
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

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.
- 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

échange Booléen Drapeau
i Entier Compteur
aux Entier Variable auxiliaire
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
3) Fin Affiche

i Entier Compteur
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

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

Type
Tab = Tableau de 10 Entiers
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
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

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
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 )

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

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 )
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

T Tab Tableau des éléments de la séquence
i, j Entier Compteurs
posi Entier Position trouvée
U0 Entier Entier saisit

Type
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 Examen pratique 1. Examen 1
pratique
2. Examen
théoriqu
e
 Examen pratique 
Examen pratique Examen
4 <Centrer> Examen théorique 3
théorique
</Center>
Examen pratique
Examen pratique Examen
5 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
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

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)
1) m ← 0
Si Fn Existe (A1[i], n, A2) Alors
m ← m+1
B [m] ← A1 [i]
Fin Si
Fin Pour
3) Fin intersection

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

i Entier Compteur
Test Booléen Drapeau de test
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)
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])
Répéter
Lire (A[i])
Jusqu'à NON (FN Existe (A[i], i - 1, A))
FinPour
3) Fin remp

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
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

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

Résultat = saisie et test de l'entier N
Traitement
Répéter
N = Donnée ("Entrer l'ordre de la matrice ")

Jusqu'à N Dans [3 .. 10]
Fin Saisie
Algorithme
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

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
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)
ch[i] Å Majuscule (ch[i])
Fin Pour
3) Fin Lecture
T.D. Objets locaux

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
inv Chaîne Pour construire la chaîne inverse de ch
i Entier Compteur pour parcourir la chaîne ch
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
Fin Si
Trouve Å OK
3) Fin Trouve
T.D.Objets locaux

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
k Entier Compteur des colonnes
ml Mot le mot de la ligne
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.
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
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
md Å + M[k, k]
Fin Pour
Si le sens est 2, on parcourt les lignes et les colonne de l'autre diagonale :

Sinon
md Å md + M[k, N-k+1]
Fin Pour
Fin Si
La variable md doit être initialisée à vide

md Å ""
Fin Mot_Diagonale
Algorithme
0) Fonction Mot_Diagonale (N : Entier ; M : Matrice, Sens : Entier) : Mot
1) md Å ''"
2) Si Sens = 1 Alors
md Å md + M[k, k]
Fin Pour
Sinon
md Å md + M[k, N-k+1]
Fin Pour
Fin Si
3) Mot_Diagonale Å md
4) Fin Mot_Diagonale
T.D.Objets locaux
md Mot Le mot de la diagonale
k Entier Compteur
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
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
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 )) ;
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.
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
i Entier Compteur
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.
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
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

résultat Réel Pour le calcul du résultat
NB : - les paramètres formels degré1 et degré2 sont facultatifs.
- 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;
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
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
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
Fin Pour
3) PGJ ← j
4) Fin PGJ
T. D. Objets locaux
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
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
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
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
max Constante = 200 Max du Tableau {n'est pas une limite}
n Entier Nombre d'éléments
k, L, j, i Entier Compteurs
T.D. Nouveaux types

Type
Tab = Tableau de Max Entiers
CORRIGE DU SUJET DE BAC (JUIN 2003)
PARTIE I
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 …………………. ……………
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.
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
deuxième opération
troisième opération
quatrième opération
cinquième opération
Etat de T après la sixième 1 4 2 3 5 6

opération
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 =’’)
PROC Remplir (T, N)

Fin décalage

N Entier Nombre d'entiers du tableau
M Entier Entier donné
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.

Type
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 :
T[i] Å i
Fin Pour
Fin Remplir

i Entier Compteur
2-5) Analyse de la procédure traitement
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

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 :
Ecrire (T[i])
Fin Pour
Ecrire (‘’le nombre de répétition est ‘’, nb)
Fin Affiche

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)
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)
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 )

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

Langue

Corrig Sjjets Fichiers PDF

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Corrig Sjjets Fichiers PDF

Titre original :

Transféré par

Droits d'auteur :

Formats disponibles

http://www.najah.

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

Analyse de la procédure Création

Algorithme de la procédure Création

Algorithme du programme principal

Programme Pascal (pour tester la solution)

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

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

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

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

T.D. Nouveaux types

Analyse de la procédure Ouvre

Analyse de la procédure Saisie

Ecrire (" Taper une ligne de texte : ")

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

Analyse de la procédure Cumul

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

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

Analyse de la procédure Affiche

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

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

Assign (FT, nom) ;

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

While ligne <> '*' Do

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

{Remise à zéro du pointeur du fichier }

For i:= 1 To Length (ligne) Do

PROCEDURE Affiche (T : Tab);

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

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

Algorithme du programme principal

Tableau de déclaration des nouveau types

Tableau de déclaration des objets Globaux

Analyse de la fonction Rechercher

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

Algorithme de la fonction Rechercher

Analyse de la procédure Saisie

Algorithme de la procédure Saisie

Analyse de la procédure Remplir

Algorithme de la procédure remplir

Fichier = File Of Films ;

nom_physique = String [40];

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

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

PROCEDURE Creation (VAR nf : nom_physique);

Writeln ('CRETATION DE FICHIER' : 50);

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

Assign (nl, nf) ;

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

PROCEDURE Ouverture (VAR nf : nom_physique);

Assign (nl, nf);

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

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

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

Assign (nl, nf);

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

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

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

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

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

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

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

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

{ _ Procédure d'ouverture d'un fichier _____ }

{ _ Procédure de suppression d'un fichier _____ }

{ Procédure de fermeture d'un fichier ___ }

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

{ _ Procédure d'ajout d'un film ________ }

{ _ Procédure qui modifie les données d'un film _______ }

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

{ Procedure qui supprime un film _______ }

{ _ Procédure du menu de choix ___________________ }