ECCSA Programmation 6U

6ème U

Option Sciences – Informatique

Programmation

2023-2024 1 P. Renouprez
 ECCSA Programmation 6U
[Link] : Langage Pascal

1.1. Programme Pascal

1. PROGRAM cercle (input,output); (* entête *)
2. VAR
3. perimetre, diametre : REAL; (* déclarations *)
4. BEGIN
5. readln(diametre); (* instruction *)
6. perimetre := 3.141592 * diametre; (* instruction *)
7. writeln(diametre,perimetre) (* instruction *)
8. END.
Un programme pascal débute toujours par le mot réservé PROGRAM
suivi d'un nom libre dénommant le programme.

Il est suivi d'une partie pour la déclaration des variables signalée par
le mot réservé VAR. Toutes les variables (zones mémoires où sont
mémorisées des données pendant le déroulement du programme)
nécessaires doivent y être définie.

Arrive enfin le code en lui même signalé par le mot réservé BEGIN
et qui se terminera toujours par le mot réservé END suivi d'un point.

Chaque instruction doit se terminer par un « ; »

1.2. Instruction entrée/sortie et affectation

1.2.1. Entrée : Readln()
readln(diametre); (* instruction *)

1.2.2. Sortie : Writeln()

writeln(diametre,perimetre) (* instruction *)

1.2.3. Affectation
perimetre := 3.141592 * diametre; (* instruction *)

1.3. Saisir/Afficher données

1.3.1. Saisir donnée
write('Veuillez introduire votre age : ') ;
readln(age);

1.3.2. Afficher donnée

writeln('Vous avez ', age, ' ans') ;

2023-2024 2 P. Renouprez
 ECCSA Programmation 6U

1.4. Les types de données

1.4.1. Entiers

Déclaration :

VAR entier1, entier2, ..., entiern : INTEGER;

Opérations sur entiers :

• + (addition) • div (division)

• - (soustraction) • mod (reste de la division)
• * (multiplication)
Elles donnent toutes un résultat entier et nécessitent deux
arguments entiers.

Les entiers sont compris entre -(MAXINT + 1) et +MAXINT, qui est

une constante standard prédéfinie.

1.4.2. Réels

Déclaration :

VAR reel1, reel2, ..., reeln : REAL;

Opérations sur les réels :

• + (addition) • * (multiplication)
• - (soustraction) • / (division)

Quand une opération comprend un argument réel et un entier, le

résultat est réel.

« / » donne toujours un résultat réel, même si les deux arguments

sont entiers.

* et / sont de priorité supérieure à + et -, mais entre * et / tout

dépend du compilateur (en général de gauche à droite). En cas
d'ambiguïté, utilisez des parenthèses (il n'y a aucun inconvénient à mettre
plus de parenthèses que nécessaire).

Exemples d'expressions numériques (soit A = 3, B = 4, C = 2) :

• A+ B/C = A + (B / C) = 5
• A/B*C = (A/B) * C (1.5) dans certains cas,
A / (B * C) (0.375) dans d'autres
2023-2024 3 P. Renouprez
 ECCSA Programmation 6U
• A / BC = valeur de A sur valeur de la variable de nom BC
et non A sur B * C
• B * A - 5 * C = (B * A) - (5 * C) = 2

Exercices :

1. Sur base de 4 notes sur 20, calcule la moyenne de l'élève.

2. A partir d’une quantité de produit achetée à un prix hors taxe on

veut établir la facture d’un client dont on connaît le nom. La facture
fera apparaître le nom, le montant hors taxe, et toute taxe sachant
qu’on applique un taux de taxe de 10%.

3. Un employé travaille dans une firme depuis 10 ans et bénéficie

d'une prime d'ancienneté de 132,94€. Il travaille 173 heures par
mois et touche 9,92€ de l'heure.
Calcule son salaire brut.

1.5. L’alternative.
Dans la recette : toujours les mêmes ? dépendent-elle de quelque
chose d’externe ?

▪ Type de four : air pulsé, gaz, etc

▪ Type de taque gaz électrique vitrocéramique, induction.
▪ Robot …
 recette différente selon le matériel
un Nouveau type d’instruction : l’ALTERNATIVE

Exemples :
▪ Comparaison entre 2 nombres
1. BEGIN
2. ...
3. IF nbr1 > nbr2 (*SI condition *)
4. THEN (*ALORS UNE instruction *)
5. writeln(nbr1:3:2, ' est plus grand que ' nbr2:3:2)
6. ELSE (*SINON UNE instruction suivie d'un ; *)
7. writeln(nbr2:3:2, ' est plus grand que ' nbr1:3:2) ;
8. …
9. IF nbr1 > 0 (*SI condition *)
10. THEN (*ALORS UNE UNE instruction suivie d'un ; *)
11. writeln(nbr1:3:2, ' est un nombre positif) ;

2023-2024 4 P. Renouprez
 ECCSA Programmation 6U
Exercices
1. Écrire un programme calculant la plus grande de deux valeurs
saisies par l’utilisateur. Faire la même chose avec trois valeurs.

2. Écrire un programme demandant quatre notes à l’utilisateur et

calculant leur moyenne, en ne prenant en compte la quatrième que
si elle est supérieure à la moyenne des trois autres (imaginez qu’il
s’agit d’une note bonus, qui ne peut pas faire baisser la moyenne).

3. On veut déterminer la moyenne annuelle finale d’un étudiant qui

sera le maximum entre la note à l’examen final, et la moyenne
générale calculée à partir de la note du premier et second partiels,
et la note à l’examen final a un coefficient de 2

Travaillons sur deux exemples :

Soit les notes du premier partiel, du second partiel et de
l’examen.
a) 10 10 12 donne une moyenne générale calculée de 11 on
gardera donc le 12 de l’examen

b) 12 12 10 donne une moyenne générale calculée de 11 on

gardera donc ce 11

4. Idem 3 mais donne la moyenne en pourcent (66,33%).

1.6. Caractères
1.6.1. Déclaration :
VAR variable1, variable2, ..., variableN : CHAR

Ces variables contiennent un caractère.

Ceux-ci sont classés suivant un ordre précis: le code ASCII, qui suit
l'ordre suivant : - Les chiffres '0' à '9' par ordre croissant;
- Les majuscules 'A' à 'Z' par ordre alphabétique;
- Les minuscules 'a' à 'z'.
Dans le code ASCII, chaque caractère possible a un numéro de
code.
Par exemple A a pour code 65.
En déclarant C comme variable caractère, on peut mettre le signe
« A » dans C par C := 'A' ou C := Chr(65). Dans le premier cas, il faut
mettre les cotes pour différencier 'A' de la variable A.

2023-2024 5 P. Renouprez
 ECCSA Programmation 6U
1.7. Les chaines de caractères.
Il est souvent nécessaire de mémoriser plusieurs caractères
ensembles. Il existe un type de variable pour cela : les chaînes de
caractères : STRING.

Ce type de variable pourra contenir une suite de 255 caractères

maximum. La longueur des variables de type STRING dépendra donc du
nombre de caractères que l'on mettra dans la variable.

Une chaîne de caractères est un ensemble de CHAR délimité par des

simples quotes : '

VAR nom : STRING ;

nom := 'Monsieur le professeur' ;

1.7.1. Exercices :

1. Ecrit l'algorithme du programme qui après avoir saisit l'adresse et

les coordonnées d'une personne , les affiche selon le format d'une
étiquette à coller sur un pli postal.

2. Ecrit l'algorithme du programme qui permettra de calculer la note

d’hôtel d'un client. Il faut tenir compte des nuits (petit déjeuner
inclus), des boissons et des repas, sachant que le tarif est le
suivant :
nuit + petit déjeuner 67,26€
déjeuner 18,59€
souper 25,49€.
Il faut tenir compte que le tarif ne tient pas compte de la TVA de
21 %.

3. Construire une calculette simple avec les opérations (+,-,*,/) et 2

nombres.

2023-2024 6 P. Renouprez
 ECCSA Programmation 6U

1.8. Booléens
1.8.1. Déclaration :
VAR variable1, variable2, ..., variableN : BOOLEAN;
Ces variables peuvent prendre soit la valeur TRUE (vrai), soit la valeur
FALSE (faux).

1.8.2. Opérations booléennes :

Ces opérations Ces opérations comparent tous éléments de type

nécessitent des simple (les 2 arguments doivent être de même
type, sauf entiers et réels qui peuvent être
arguments booléens. comparés entre eux), et renvoient un booléen.
• AND • > (supérieur)
• OR • < (inférieur)
• NOT • >= (supérieur ou égal)
• XOR (ou exclusif) • <= (inférieur ou égal)
• = (égal)
• <> (différent)

Les caractères sont comparés suivant l'ordre du

code ASCII.

AND (et), OR (ou), NOT (non) et XOR (ou exclusif), sont de priorité
supérieure aux opérations de comparaison et ne peuvent opérer que sur
des booléens : A > B et C doit être écrit : (A > B) and (A > C). Les
parenthèses sont obligatoires pour ne pas faire en premier B and A.

2023-2024 7 P. Renouprez
 ECCSA Programmation 6U
1.8.3. Exercices récapitulatifs

1. Écrire un programme Pascal pour demander à l’utilisateur de saisir

son
nom et prénom ainsi que son sexe (M pour homme et F pour
femme) et puis afficher à
l’écran le message : « Bonjour Monsieur Nom Prénom » si c’est un
homme ou
« Bonjour Madame/Mademoiselle Nom Prénom » si c’est une
femme.

2. Écrire un programme Pascal qui demande à l'utilisateur 2 nombres

puis qui signalera quel est le nombre le plus grand.

3. Écrire un programme Pascal qui détermine la parité et le signe du

nombre introduit.

4. Écrire un programme Pascal qui, à partir du mois donné affiche le

nombre de jour que contient ce mois. Vérifie que le mois encodé est
correct.

5. Écrire un programme Pascal qui, à partir de la date de naissance

(sous la forme JOUR, MOIS, ANNEE) d’une personne, détermine si
elle bénéficie d’une réduction ; sachant que la réduction est
accordée aux personnes ayant moins de 18 ans, et aux personnes
ayant au moins 60 ans.

6. Écrire un programme Pascal qui détermine la moyenne annuelle

finale d’un étudiant qui sera le maximum entre la note à l’examen
final, et la moyenne générale calculée à partir de la note du premier
et second partiels, et la note à l’examen final multipliée par 2. .
Exemples :Soit les notes du premier partiel, du second partiel et de
l’examen.

a) 10 10 12 donne une moyenne générale calculée de 11 on

gardera donc le 12 de l’examen

2023-2024 8 P. Renouprez
 ECCSA Programmation 6U
b) 12 12 10 donne une moyenne générale calculée de 11 on
gardera donc ce 11

2023-2024 9 P. Renouprez
 ECCSA Programmation 6U
2. Les itérations

2.1. Boucle 0-n

TantQue condition

instructions

Fin TantQue

while (condition) do
begin
instructions ;
end ;

2.2. Boucle 1-n

Répéter

instructions

JusquAceQue condition

repeat
begin
instructions ;
end ;
until condition ;

2.3. Boucle n
Pour i = 1 JusquA 10 FAIRE

FinFaire

for i:=1 to max do

begin
instructions ;
end ;

2023-2024 10 P. Renouprez
 ECCSA Programmation 6U

2.4. Exercices sur les itérations

Pour chaque exercice avant de commencer la programmation,
montre sur papier :

– La liste des données

– l’algorithme et les variables qu’il nécessite

2.4.1. Exemples

On veut afficher la table des valeurs de 1 à 20, de leurs carrés et

cubes.

Phase 1 : Étape de réflexion (conception abstraite).

Le travail est constant : afficher la table des valeurs de 1 à 20

associées aux valeurs de leurs carrés et cubes.

TROUVER ce que REPETE ici calculer n² et n³

et afficher n n² n³

C'est ce qui sera DANS la boucle

De la forme (par exemple)

1 1 1
2 4 8
3 9 27
:
20 400 8000

TROUVER COMBIEN de FOIS on le répète ici 20 fois

Phase 2 : L'algorithme associé à son lexique (conception
concrète).

variable
i (entier) indice d’itération
Début
Pour i de 1 à 20 faire
Ecrire (i, (i*i), (i*i*i))
Fin pour i
Fin
Phase 3 : Programmation (codification).

2023-2024 11 P. Renouprez
 ECCSA Programmation 6U
On peut désormais choisir un langage de programmation cible, et
traduire le précédent algorithme pour en obtenir le programme
correspondant …

program premier;
uses crt;
var i : integer ;

begin
for i:=1 to 20 do
begin
writeln(i,' ',(i*i),' ',(i*i*i)) ;
end ;
readkey() ;
end.

2.4.2. Exemple 2
program premierbis;
uses crt;
var
n,r,i:integer;
begin
write('Donnez un entier naturel : ');
read(n);
r:=0;
for i:=1 to n do
begin
if (n mod i) = 0
then
r:=r+1;
end ;
if r=2
then
write('le nombre est premier')
else
write('le nombre n''est pas premier');
readkey() ;
end.
Que fait ce programme ?

2023-2024 12 P. Renouprez
 ECCSA Programmation 6U
2.4.3. PgmBCL01

Ecrire un programme qui demande un nombre compris entre 10 et

20, jusqu’à ce que la réponse convienne. En cas de réponse supérieure à
20, on fera apparaître un message : « Plus petit ! », et inversement,
« Plus grand ! » si le nombre est inférieur à 10.

2.4.4. PgmBCL02

Ecrire un programme qui demande un nombre de départ, et qui

ensuite affiche les dix nombres suivants. Par exemple, si l'utilisateur entre
le nombre 17, le programme affichera les nombres de 18 à 27.

2.4.5. PgmBCL03

Ecrire un algorithme qui demande un nombre de départ, et qui

calcule la somme des entiers jusqu’à ce nombre. Par exemple, si l’on entre
5, le programme doit calculer :

1 + 2 + 3 + 4 + 5 = 15

NB : on souhaite afficher uniquement le résultat, pas la

décomposition du calcul.

2.4.6. PgmBCL04

Ecrire un programme qui calculera, jusqu’à ce que l’utilisateur ne le

veuille plus, la puissance p d’un nombre nbr tous deux donnés par
l’utilisateur.

2.4.7. PgmBCL05

Ecrire un algorithme qui demande successivement 20 nombres à

l’utilisateur, et qui lui dise ensuite quel était le plus grand parmi ces 20
nombres :

Entrez le nombre numéro 1 : 12

Entrez le nombre numéro 2 : 14
etc.

2023-2024 13 P. Renouprez
 ECCSA Programmation 6U
Entrez le nombre numéro 20 : 6
Le plus grand de ces nombres est : 14

Modifiez ensuite l’algorithme pour que le programme affiche en

quelle position avait été saisie ce nombre :

C’était le nombre numéro 2

2.4.8. PgmBCL06

On veut convertir un nombre entier positif de décimal en binaire.

PgmBCL08
Écrire un programme qui permet de saisir un entier qui représente le
rang d'une journée de la semaine (dimanche est représenté par 1, lundi par
2, ...samedi par 7) et d'afficher un message du genre :

Ca bosse dur! (du lundi au jeudi)

Le weekend est arrive ! (le vendredi)
Youpi! C est le weekend! (le samedi et le dimanche)
A la prochaine (pour un 0)
Rang invalide! (pour un autre rang)
Le programme doit répéter cette opération jusqu'à ce que la valeur
entrée soit de 0

2.4.9. PgmBcl09

En utilisant les boucles for, écrire un programme qui demande un

nombre entre 1 et 40 et qui affiche un motif. Par exemple, voici les motifs
n=4

*
**
***
****
***
**
*
2.4.10. PgmBcl10

Écrire un programme qui permet de saisir l'âge (un entier) et le sexe

(M/F) d'une personne.

Ensuite, on affiche un message du genre :

2023-2024 14 P. Renouprez
 ECCSA Programmation 6U
C'est un enfant de sexe masculin.
On répète le même traitement tant que l'usager décide de continuer
(O/N). Une personne entre 0 et 11 ans est considérée comme enfant, entre
12 et 17 ans comme adolescent(e), plus grand ou égale à 18ans est
considérée comme adulte

2023-2024 15 P. Renouprez
 ECCSA Programmation 6U
[Link] chaînes de caractères.

3.1. Définition d’une chaine de caractères

« String » :
Pour mieux comprendre les chaînes de caractères, il faut mettre
dans nos têtes que les chaînes de caractères est une suite de caractères.
Le type de données pour les chaînes de caractères est un tableau de
256 caractères.

Type
String = array [ 0 .. 255 ] of char ;
Une chaîne de caractères est un ensemble de lettre délimité par des
simples quotes : '

nom := 'Monsieur le professeur' ;

3.2. Exemple sur les chaines de caractères :

Program exempleChaine;
Var
St: string;
Begin
St: = ‘ computer ‘;
Writeln (st [2]);
Writeln (st [5]);
End.
Pendant l’exécution de ce programme on va obtenir les résultats
suivants :

C
P
Remarque, dans cet exemple, le compilateur a pris en compte les
deux espaces blancs que se sont des caractères qui se trouvent avant et
après « computer ». Pour cela le langage pascal pris en compte les
espaces blancs que se sont des caractères.

3.3. Concaténer
Pour coller deux chaînes de caractères l’une à l’autre, utilisez
l’opérateur +

St := ‘bon’ + ‘jour’ ;

2023-2024 16 P. Renouprez
 ECCSA Programmation 6U

3.4. Exercices
3.4.1. Ex01
A partir d’une phrase donnée : (la fonction length(cha) donne la
longueur de cha)

1. Afficher tous les caractères un à un l'un en dessous de l'autre

2. Afficher la phrase à l'envers (la phrase → esarhp al)

3. Afficher la phrase sans les voyelles (la phrase → l phrs)

4. Afficher la phrase avec les mots dans l'ordre mais à l'envers (la
phrase → l srhp)

3.4.2. Ex02

A partir d’une phrase on souhaite connaître le nombre d’occurrence

d’un caractère donné.

3.4.3. Ex03

Chaque employé d’une entreprise possède un code personnel

alphanumérique composé de sept caractères. :

• Les deux premiers représentent l’année d’embauche.

• Les trois suivants le numéro d’embauche.
• Le sixième le titre de la personne

0 pour Madame 1 pour Mademoiselle 2 pour Monsieur

• Le septième le service de travail

0 pour la direction 1 pour le secrétariat 2 pour la comptabilité

3 pour l’informatique 4 pour l’entretien 5 pour la production

exemple
Code personnel de l’employé: 0002313
Nom de l’employé :COTINE
Prénom de l’employé :Annie
Mademoiselle Annie COTINE travaille au service informatique depuis
2000.

2023-2024 17 P. Renouprez
 ECCSA Programmation 6U
3.4.4. Ex04

Idem EX03 Mais avec les initiales des nom et prénom en position 8
et 9 et vérification de la concordance des initiales avec les nom et prénom
introduits.

exemple
Code personnel de l’employé: 0002313CA
Nom de l’employé :COTINE
Prénom de l’employé :Annie
Mademoiselle Annie COTINE travaille au service informatique depuis
2000.

3.4.5. Ex05

Imagine le jeu du pendu et réalise le en pascal.

6) Ex06
Écris un programme qui mémorise une chaîne de caractères. Puis
qui construit la chaîne inverse et détermine en fonction de cette dernière
si la chaîne de caractères est ou non un palindrome.

2023-2024 18 P. Renouprez
 ECCSA Programmation 6U
[Link] tableaux
Un outil particulièrement pratique et proposé dans la grande
majorité des langages est le tableau. Il permet le stockage d'une série
d'éléments de même type.

Imaginons un professeur voulant stocker les notes de 5 élèves, il

peut ainsi utiliser un tableau d'entiers de longueur 5. Illustrons ce
dernier :

12 16 07 13 09
En pascal, un tableau peut être déclaré de la manière suivante :

var
t : array[1..5] of integer;
Ainsi, ce code déclare un tableau d'entiers, dont les indices vont de
1 à 5. Cet indice permet d'accorder un numéro à chacune des cases et d'y
accéder.

Exemple :

var
t : array[1..5] of integer;
begin
t[1] := 12;
t[2] := 16;
t[3] := 7;
t[4] := 13;
t[5] := 9;
end.
Voilà comment il est possible d'affecter une valeur à chacune des
cases du tableau. L'accès en lecture se fait par la même notation.

Il est aussi possible d’initialiser un tableau lors de sa déclaration

(pour des tests par exemple.

var
t : array[1..5] of integer = (12,16,7,13,9);
Plus généralement, nous utiliserons une boucle pour initialiser un
tableau.

2023-2024 19 P. Renouprez
 ECCSA Programmation 6U
var
t : array[1..5] of integer;
i : integer ;
begin
for i:=1 to LONGTABLEAU do
begin
write(‘valeur élément ’, i, ’ : ‘) ;
readln(t[i]) ;
end ;

4.1. Exemple :
4.1.1.
Program exemple ;
Var tab : Array[1..10] Of Integer ;
i : Integer ;
BEGIN
For i:=1 To 10 Do
Begin
tab[i]:=i ;
WriteLn(sqrt(tab[i])*5+3) ;
End;
END.

4.1.2. Ecrire l’algorithme :

1. qui permet de saisir un nombre maximum de ville.
2. qui permet de saisir un certain nombre de ville.
3. qui affiche l’ensemble des villes (du tableau)
4. qui détermine la présence d’une ville donnée en affichant son
rang dans le tableau
5. qui affiche une ville à partir d’un rang du tableau donné

4.1.3. Phase 1: Étape de réflexion (conception

abstraite).

A partir de l'énoncé on doit définir les flux entrants (les données du

problème), les flux sortants (les résultats du problème), et le moyen de
passer des uns aux autres.

Représentation du tableau

indice TABL_VILLE
1 NANCY
2 METZ
NBVIL= 3 BESANCON
:

MAXVIL

2023-2024 20 P. Renouprez
 ECCSA Programmation 6U
4.1.4. Phase 2 : L'algorithme associé à son lexique
Programme
Données générales
Constante
MAXVIL = 100
Variable
TABL_VILLE : table [1..MAXVILLE] chaîneDeCaractere
NBVIL : entier //taille réellement utilisée du tableau
RangDonne :entier
//Données de travail
i :entier
VILLE_CHERCHEE :String
VilleTrouvée :Booléen
Début
--------- 1 -----------------------------
Saisir(NBVIL)
Tant Que NBVIL PAS dans [1..MAXVIL] //contrôle taille du
tableau
Debut
Afficher(NBVIL doit etre compris dans [1..MAXVIL])
Saisir(NBVIL)
Fin
--------- 2 -----------------------------
Pour i ← 1 à NBVIL faire
Debut
Saisir (TABL_VILLE [i])
Fin
--------- 3 -----------------------------
Pour i ← 1 à NBVIL faire
Afficher (TABL_VILLE [i])
Fin
--------- 4 -----------------------------
Saisir(VILLE_CHERCHEE)
i ← 1
VilleTrouvée ← Faux
Répéter
SI VILLE_CHERCHEE = TABL_VILLE[i]
ALORS Afficher (TABL_VILLE [i])
VilleTrouvée ← VRAI
SINON i ← i +1
FIN
Jusqu’à VilleTrouvée OU FinTableauAtteinte
SI not VilleTrouvée
Alors
Afficher(Ville pas dans le tableau)
Fin
--------- 5 -----------------------------
Saisir (RangDonne)
Tant Que RangDonne pas dans [1.. NBVIL] contrôle taille utile
du tableau
Afficher( RangDonne doit etre compris dans [1..NBVIL])
Saisir(RangDonne)
Fin
Afficher (TABL_VILLE [i])
Fin

2023-2024 21 P. Renouprez
 ECCSA Programmation 6U

4.2. Les recherches

La recherche est un des atouts de l'informatique, les algorithmes de
recherche sont ceux qui permettent le plus de gain de temps. Ces
algorithmes sont nombreux et multiples, ils dépendent de la façon sont
organisées les données (triée ou pas, clés secondaires, etc...), s'il faut
rechercher des doublons, etc...

Nous nous contenterons d'étudier deux des algorithmes les plus

simples sur des données pas nécessairement triées.

Le premier s’arrêtera dès qu'un élément correspondant à la

recherche est trouvé (ex : recherche d'un étudiant sur base de son
matricule. En effet le matricule ne correspond qu'à un seul étudiant)

Le deuxième passera toutes les données afin de trouver d'autres

occurrences si elles existent (ex recherche dans une liste de contact sur
base du prénom, il est probable que plusieurs de nos contacts aient le
même.)

4.2.1. Recherche d'un élément unique

Deux remarques :

1. Comme la recherche s'arrête dès que l'on a trouvé se que l'on

cherchait, nous utilisons une boucle 1-n (nous ne savons pas
combien de fois la comparaison va devoir être effectuée)

2. Comme il n'a que deux résultats possibles (trouvé ou non), un seul

traitement de la recherche APRES la boucle est nécessaire.
Deux versions sont possibles pour la recherche. Chacune avec ses
avantages et inconvénients.

2023-2024 22 P. Renouprez
 ECCSA Programmation 6U
Prenez celle qui vous semble la plus logique...

// VERSION 1
Saisir(Matricule_CHERCHE)
i ← 1
MatriculeTrouvé ← Faux
Répéter
SI Matricule_CHERCHE = TABL_Matricule[i]
ALORS MatriculeTrouvé← VRAI
SINON i ← i +1
FINSI
Jusqu’à MatriculeTrouvé OU FinTableauAtteinte

//traitement du résultat de la recherche

SI not MatriculeTrouvé
Alors
Afficher(Matricule pas dans le tableau)
Sinon
Afficher (TABL_Matricule [i])
FinSI
La 2ième version n’a pas de sinon dans le test et l’incrémentation
de l’indice n’est pas au même endroit...

// VERSION 2
Saisir(Matricule_CHERCHE)
i ← 0
MatriculeTrouvé ← Faux
Répéter
i ← i +1
SI Matricule_CHERCHE = TABL_Matricule[i]
ALORS MatriculeTrouvé← VRAI
FINSI
Jusqu’à MatriculeTrouvé OU FinTableauAtteinte

//traitement du résultat de la recherche

SI not MatriculeTrouvé
Alors
Afficher(Matricule pas dans le tableau)
Sinon
Afficher (TABL_Matricule [i])
FinSI

2023-2024 23 P. Renouprez
 ECCSA Programmation 6U
4.2.2. Recherche d'un élément pouvant être présent de
nombreuses fois

Deux remarques :

1. Comme l'élément peut être présent plusieurs fois, nous devrons

passer TOUTES les données en revue. une boucle N est utilisée

2. Comme il est possible de trouver plusieurs fois un même prénom, il

est nécessaire d'ajouter dans la BOUCLE un traitement pour tous les
éléments trouvés. Et ce EN PLUS du traitement final après la boucle
qui est le seul à pouvoir dire si une correspondance a été trouvée.

Saisir(Prenom_CHERCHE)
PrenomTrouvé ← Faux
POUR i ← 1 JUSQU'A TailleTableau
SI Prenom_CHERCHE = TABL_Prenom[i]
ALORS TRAITEMENT (TABL_Prenom [i])
PrenomTrouvé← VRAI
FINSI
FinPOUR
SI not PrenomTrouvé
ALORS
Afficher(Prenom pas dans le tableau)
SINON
Traitement DU ou DES prenoms trouvé
FinSI

4.3. Exercices
4.3.1. Ex01

Écrivez un algorithme constituant un tableau, à partir de deux

tableaux de même longueur préalablement saisis. Le nouveau
tableau sera la somme des éléments des deux tableaux de départ.

Tableau 1 :
4 8 7 9 1 5 4 6

Tableau 2 :
7 6 5 2 1 3 7 4
Tableau à constituer :
11 14 12 11 2 8 11 10

2023-2024 24 P. Renouprez
 ECCSA Programmation 6U
4.3.2. Ex02

Écrivez un algorithme permettant, à l’utilisateur de saisir les notes

d'une classe. Le programme, une fois la saisie terminée, renvoie le
nombre de ces notes supérieures à la moyenne de la classe.

4.3.3. Ex03
On veut représenter un menu composé d’au maximum 20 noms de plat associé à
son prix respectif.
0. définir la structure de données en tableaux associés permettant de
représenter le menu.
Ecrire l’algorithme :
1. qui permet de saisir un certain nombre de plats et prix associés.
2. qui permet d’afficher le menu de tous les plats et prix à la carte.
3. qui permet d’afficher le prix d’un plat dont on fournira le nom (on suppose
que chaque nom de plat est unique dans le menu).
4. qui permet d’afficher tous les noms de plat correspondant à un prix donné.
5. qui permet d’afficher tous les noms de plat correspondant à une fourchette
de prix donnée (compris entre un prix minimum, et un prix maximum).
6. qui permet d’afficher le nom et prix d’un plat dont on donnera le rang dans le
menu (indice dans le tableau).
7. qui permet d’augmenter l’ensemble des prix du menu de 10%

2023-2024 25 P. Renouprez
 ECCSA Programmation 6U

4.4. Les tableaux à DEUX dimensions

En programmation, il est parfois nécessaire de disposer d’un tableau
de plusieurs dimensions. Nous nous contenterons d’utiliser des tableaux à
2 dimensions qui seront déclaré de la manière suivante :

var
tab1 : Array[0..10, 0..10] Of Byte ;
tab2 : Array[0..10, 0..100] Of Integer ;
tab3 : Array[-10..10, -10..10] Of Real ;
tab4 : Array[5..7, 20..22] Of String ;
tab5 : Array[1..10, 1..10, 1..10, 0..2] Of Char ;//4 dimensions

Ainsi, ce code déclare un tableau d'entiers, dont les indices vont de

1 à 5. Cet indice permet d'accorder un numéro à chacune des cases et d'y
accéder.

var
t : array[1..2][1..3] of integer;
begin
t[1][1] := 12;
t[1][2] := 16;
t[1][3] := 7;
t[2][1] := 13;
t[2][2] := 9;
t[2][3] := 9;
end.
Voilà comment il est possible d'affecter une valeur à chacune des
cases du tableau. L'accès en lecture se fait par la même notation.

Il est aussi possible d’initialiser un tableau lors de sa déclaration

(pour des tests par exemple.

var
t : array[1..2][1..3] of integer = ((12,16,7),(13,9,9));
Plus généralement, nous utiliserons deux boucles imbriquées pour
initialiser un tableau à deux dimensions.

var
t : array[1..2][1..3] of integer;
i,j : integer ;
begin
for i:=1 to 2 do
for j:=1 to 3 do
begin
write(‘valeur élément ’, J, ’de la ligne ‘, ‘i’ ’ : ‘) ;
readln(t[i][j]) ;
end ;
end.

2023-2024 26 P. Renouprez
 ECCSA Programmation 6U

4.5. Exercices
4.5.1. Occupation de salle
Une salle de réunion peut être utilisée par différents employés d’une
entreprise. La réservation se fait par plage d’une heure, de 8H00 du matin à 19H00.
Chaque plage d’une heure commence à l’heure pile (par exemple, il y a une plage
9H00-10H00 mais il n’y a pas de plage 9H15-10H15.

Un tableau de booléens à deux dimensions est utilisé pour représenter si la

salle est occupée (valeur true) ou disponible (valeur false) pendant une semaine.

Une dimension est utilisée pour coder les jours ouvrables de 1 (lundi) à 5
(vendredi).

L’autre dimension est utilisée pour les plages horaires de 0 (8H00-9H00) à 10

(18H00-19H00). Chaque case correspond à la réservation de la salle pour une plage
d’un jour donné.

OccupationSalle : array [1..5,1..10] of boolean =

((false,true,true,true,false,true,true,false,true,false),
(false,true,true,true,false,true,true,false,true,false),
(false,false,true,true,false,false,true,false,true,false),
(true,true,false,true,false,true,true,false,true,true),
(false,true,false,true,false,true,true,false,false,false))};

Question 1 affichage
écrire un programme qui déclare la variable tableau OccupationSalle
comme ci-dessus et qui affiche l’occupation de la salle de façon intelligible (par
exemple : salle occupée le mardi de 9H00 à 10H00).

Question 2 taux d’occupation

écrire un programme qui calcule le taux d’occupation de la salle, c’est à dire le
nombre de plages réservées divisé par le nombre total de plages

Question 3 réservation
écrire un programme qui permet à l’utilisateur de réserver une plage. Il faut
vérifier que la salle est libre au moment demandé.

2023-2024 27 P. Renouprez
 ECCSA Programmation 6U
4.5.2. Tableau de vente
On va considérer un tableau à deux dimensions qui regroupe les informations
relatives aux ventes de voitures dans une concession.

Une première dimension sert à représenter les différents modèles de voitures

(une colonne pour chaque modèle).

Une deuxième dimension sert à représenter les ventes d’un vendeur de

l’entreprise (une ligne par vendeur).

Une case contient le nombre de voitures d’un modèle donné vendu par un
vendeur X.

Question 1
On suppose qu’il y a 4 modèles et 4 vendeurs. Écrivez un programme qui crée
le tableau des ventes et lit au clavier les données permettant de le remplir.

Question 2
Ecrivez un programme qui donne le nombre d’exemplaires vendus pour
chacun des modèles.

Question 3
On donne le prix de chaque modèle dans un second tableau à une seule
dimension. Ecrire un programme qui calcule le chiffre d’affaire généré par chacun
des vendeurs, c’est à dire le total de ses ventes exprimé en euros.

2023-2024 28 P. Renouprez
 ECCSA Programmation 6U
[Link] procédures et fonctions

5.1. Introduction1
On peut regrouper un ensemble d'instructions sous un même nom. On forme
alors un sous-programme ou procédure. On utilise les procédures :

* chaque fois qu'une même suite d'instructions doit être répétée

plusieurs fois dans un programme,
* quand une suite d'instruction forme une action globale. Le
programme est alors plus clair et les erreurs plus facilement détectables.

5.2. Les procédures

Pour pouvoir utiliser une procédure, il faut d'abord la déclarer. La
déclaration des procédures et fonctions se fait après toutes les autres
déclarations.

PROGRAM NomProgramme
USES
VAR variables;
définition des procédures; {sous-programmes}
BEGIN
instructions
END
Une procédure est donc un petit programme et fonctionne comme lui avec son
mot clé : PROCEDURE sa déclaration variables VAR son BEGIN et son END.

PROCEDURE NomProcedure ;
VAR

BEGIN
instructions
END ;
On peut appeler une procédure déclarée dans une routine n'importe où dans
cette routine en indiquant simplement son nom comme si c'était une instruction. A
l'appel d'une procédure, le programme interrompt son déroulement normal, exécute
les instructions de la procédure, puis retourne au programme appelant et exécute
l'instruction suivante.

Tout ce passe donc comme si le nom de la procédure était remplacé dans le

programme par les instructions de la procédure .

1
[Link]
2023-2024 29 P. Renouprez
 ECCSA Programmation 6U
PROGRAM ProgrammeMenu
USES
VAR variables;
définition des procédures; {sous-programmes}
PROCEDURE AffichageMenu;
VAR

BEGIN //procedure
writeLN(' Faites votre choix :')
writeLN(' --------------------')
...
END ;

BEGIN //programme
REPEAT
AffichageMenu ;
until choix = '9'
END

5.3. PORTEE Des DECLARATIONS

Celle-ci est symbolisée dans l'exemple ci-dessus par deux cadres :
la variable I et la procédure LIGNE (avec un argument entier) sont
déclarées dans REMPLIR, et donc connues dans tout le programme
(rectangle extérieur). Par contre N et J sont déclarés dans LIGNE et ne
sont connus (et utilisables) que dans le rectangle intérieur.

En d'autres termes :

* Une variable est LOCALE pour une procédure X si elle est déclarée
dans X. Elle n'existe que dans X (et dans les procédures déclarées à
l'intérieur de X). La routine qui comporte la procédure X ne peut donc pas
accéder à cette variable locale.

* Une variable est GLOBALE pour une procédure X si elle est

déclarée dans une routine ENGLOBANT la procédure X. Elle peut être
utilisée dans la procédure. La modifier la modifie également dans le
routine appelante (englobante).

Si l'on avait déclaré une variable I dans la procédure LIGNE (au lieu
de N ou J), celle-ci aurait été locale à la procédure, c'est à dire que, dans
le programme principal, I désigne une autre case mémoire que dans la

2023-2024 30 P. Renouprez
 ECCSA Programmation 6U
procédure. Modifier la variable locale I ne modifie pas la variable globale I
(momentanément inaccessible).

Rq : Ceci s'applique à toutes les déclarations. En particulier, une

procédure déclarée localement à l'intérieur d'une procédure est indéfinie à
l'extérieur.

2023-2024 31 P. Renouprez
 ECCSA Programmation 6U

5.4. ARGUMENTS (OU PARAMETRES)

Les échanges d'informations entre une routine appelant une sous-
routine peuvent se faire par l'intermédiaire des variables globales. Mais il
est beaucoup plus intéressant d'utiliser les PARAMETRES :

PROGRAM machin (input,output);

VAR a,b,c,d:real;
PROCEDURE aff_somme(x,y:real);
g z:real;
begin
z:=x+y;
writeln(x ,' + ', y ,' = ', z)
end;

{ programme principal }
BEGIN
writeln('entrez 4 valeurs : ');
readln(a,b,c,d);
aff_somme(a,b);
aff_somme(3,5);
aff_somme(c+a,d)
END.
En appelant AFF_SOMME(A,B), la procédure prend pour X la valeur
de A, et pour Y la valeur de B. On dit que les arguments sont "passés par
valeur". Mais si la procédure modifiait X ou Y, A et B ne seraient pas
modifiés dans le programme appelant. Pour répercuter les modifications
des arguments, il faut les déclarer comme "variables" (ils sont alors dits
"passés par adresse").

5.5. Exercice
Crée un programme qui au travers d’un menu propose à l’utilisateur
de calculer les périmètres et surfaces des différentes formes géométrique
que tu connais (carré, rectangle, triangle, cercle, …).

Chacun des calcul devra se faire dans une procédure qui lui est
propre.

2023-2024 32 P. Renouprez
 ECCSA Programmation 6U

5.6. LES FONCTIONS

Tout ce qui a été dit pour les procédures s'applique également aux
fonctions. La différence avec une procédure est qu'une fonction renvoie un
résultat. L'entête est du type :

FUNCTION nom_fonction (liste_parametres):type_de_la_fonction

la liste des paramètres (en général passés par valeur) est de la
même forme que pour une procédure, le type de la fonction étant le type
du résultat retourné. On retourne le résultat par : NOM_FONCTION := ...

Cette affectation ne peut se faire qu'une seule fois par appel

à la fonction.

program classer(input,output);
var a,b,c:real;
function MAX(x,y:real):real;
begin
if x>=y then MAX:=x else MAX:=y ;
end;
{ programme principal }
begin
writeln('entrez deux valeurs : ');
readln(a,b);
writeln('le plus grand est ',max(a,b))
end.
La fonction MAX a 2 paramètres réels (X et Y) et renvoie un réel.

5.6.1. Ex01

Écrire une fonction SupprimeEspace qui supprime les espaces d'une

chaîne de caractères.

5.6.2. Ex02

Ecris un programme qui permettra de calculer, à l'aide de fonctions

et selon le choix de l'utilisateur, les :
• volume d'un cylindre
• périmètre du cercle
• surface du cercle
• aire d'un rectangle
• périmètre d'un rectangle
• aire et périmètre d'un carré en te servant des fonctions du carré
• la puissance d'un nombre
• bonus, la factorielle d'un nombre

2023-2024 33 P. Renouprez
 ECCSA Programmation 6U
5.6.3. Ex03
Soit la structure Personne schématisée par
• le nom (chaîne de 30 caractères max),
• le numéro de téléphone (10 caractères max),
• le numéro de carte bancaire (entier non signé).
Écrire un programme qui enregistre jusqu'à 100 personnes dans un tableau.

Écrire une série de fonctions qui testent si les données entrées sont
correctes :
• Une fonction isString pour vérifier que le nom ne contient pas
de chiffres
• Une autre fonction isNumber pour vérifier que le numéro de
téléphone ne contient pas de lettres de l'alphabet
Indication :

• Ecrire des fonctions élémentaires isAlpha et isDigit qui

renseignent respectivement si leur argument est une lettre ou un
chiffre.

if (((ord(c) >= 97) and (ord(c) <= 122))

or ((ord(c) >= 65) and (ord(c) <= 90)))
then isalpha := true ;
if ((ord(c) >= 48) and (ord(c) <= 57))
then isDigit := true ;
Utiliser les fonctions précédentes pour s'assurer que les données du
programme de l'énoncé précédent sont valides avant l'enregistrement.

5.6.4. PgmFct

Construire et tester un programme éditant à l’écran les valeurs de la

fonction G telle que G(x) = exp(-x*x/2)/sqrt(2 * PI) pour x variant de –
2.5 à 2.5 par pas de 0.2.
Indice : On créera la fonction Pascal

function G(X:real) : real ;

begin
G := {à compléter} ;
end ;
{PI est une constante de valeur 3.1416}

5.6.5. Lancement d'un dé

Écrire une fonction simulant le lancé d’un dé à six faces.

Bonus (passe en argument le nombre de face du dé : 4,8,12,20,...)

2023-2024 34 P. Renouprez
 ECCSA Programmation 6U
[Link] choix multiple.
Dans certains cas le nombre des alternatives pour une MÊME
variable est tellement grand qu’il est nécessaire d’enchaîner plusieurs If.

Cela donne le code suivant avec choix variable de type entier :

If choix = 1
then Traitement01
else If choix = 2
then Traitement02
else If choix = 3
then Traitement03
else If choix = 4
then Traitement04
else If choix = 5
then Traitement06
else TraitementAutres ;
Ce cas de figure est tellement fréquent que les concepteurs de
langage ont prévu une instruction pour ces cas de figures. En Pascal, il
s’agit de l’instruction Case variable of valeur : end;

Cela donnera pour le cas ci-dessous le code suivant :

Case choix of
1 : Traitement01 ;
2 : Traitement02 ;
3 : Traitement03 ;
4 : Traitement04 ;
5 : Traitement05 ;
6 : Begin
code
…
end ;
else TraitementAutres ;
end ;
Ce qui es, tu le conviendras plus lisible et facile à écrire.

2023-2024 35 P. Renouprez
 ECCSA Programmation 6U
[Link] ensembles
Un ensemble est une "collection" d'éléments de même type (cf cours
maths). L’utilisation la plus courante est l’ensemble de caractère attendu :

On "remplit" un ensemble en donnant ses éléments entre crochets :

CONST
MINUSCULES = [‘a’..’z’];
MAJUSCULES = [‘A’..’Z’];
CHIFFRES = [‘0’..’9’];
Le type ensemble est défini par SET OF :

TYPE
tEnsDeCaracteres = SET OF char ;
VAR
caractereAutorises : SET OF char;
L'ensemble vide est : [].

Pour passer un ensemble en paramètre, in faut avoir défini un type

TYPE
tEnsDeCaracteres = SET OF char ;
Procedure isCaractereValide(c:char ;
ensemble :tEnsDeCaracteres):boolean ;
On teste l'appartenance d'un élément par IN :

VAR
reponse : char ;
BEGIN

if reponse IN [‘o’,’O’,’N’,’n’]
then…
if NOT (reponse IN [‘o’,’O’,’N’,’n’])
On peut faire les opérations suivantes :

• Union : Lettres:= MINUSCULES + MAJUSCULES

CaracteresAlpha:= Lettres + CHIFFRES

• Intersection : CHIFFRES * Lettres =[]

• Complément : CaracteresAlpha - Lettres = CHIFFRES

Les tests booléens possibles sont :

▪ = (egal) ▪ <= (inclus)

▪ <> (différent) ▪ >= (contenant)

2023-2024 36 P. Renouprez
 ECCSA Programmation 6U
[Link] fichiers

8.1. Introduction
Jusqu'à présent, de l'exécution à l'autre d'un programme il fallait
réintroduire toutes les données. Pour pouvoir récupérer des données d'un
programme à un autre, il faut les mémoriser dans un fichier. La
manipulation de ces fichiers doit respecter certaines règles.

8.2. Les fichiers Texte

Ce sont les fichiers les plus simples, ce sont les fichiers « .txt » créé
par le bloc-note par exemple. Les enregistrements sont les lignes du
fichier. Une ligne se terminant par un (retour chariot/Enter/Line
Feed/LF/code ascii:10). Ces enregistrements n’ont donc pas tous la même
longueur, c’est la caractéristique des fichiers texte.

FiLogique : TEXTFILE ;
Ces fichiers ne se lisent que séquentiellement, ligne après ligne.

Ces fichiers texte sont encore très utilisés pour les transferts de
données entre logiciel (.csv que nous verrons plus tard).

8.2.1. Liaison Programme/Système d’exploitation

Un fichier a un nom externe (ou le nom physique): C'est le nom

tel qu'il apparaît dans l'explorateur de fichiers, le nom du fichier selon le
système d'exploitation (avec éventuellement tout ou partie du chemin ).

Le programme ne travaille pas avec le nom externe mais avec un

nom logique. Il faut donc lier le fichier logique avec le fichier logique.

Cette liaison se fait avec l'instruction Assign

assign(nomLogique,nomPhysique)

2023-2024 37 P. Renouprez
 ECCSA Programmation 6U
8.2.2. Manipulation des fichiers

Un fichier doit être ouvert avant de pouvoir être utilisé. L'opération

d'ouverture sera différente, selon que l'on veuille seulement lire les
enregistrements ou que l'on veuille écrire des nouveaux enregistrements
dans le fichier.

Cette opération d’ouverture réserve le fichier exclusivement pour le

programme, personne d’autre ne pourra le modifier tant qu’il sera réservé
(ouvert) par ton programme.

reset(nomLogique) ; //ouverture pour lire

rewrite(nomlogique) ; //ouverture pour écrire
Et un fichier doit OBLIGATOIREMENT être fermé après utilisation

close(nomLogique) ; //fermer le fichier

8.2.3. Le repère de position d’un fichier

Il permet de savoir où l’on se trouve dans un fichier lorsque l’on accède à celui-ci dans
l’ordre de ses enregistrements (accès séquentiel).

C’est aussi lui qui détermine le résultat des opérations telles que : Eof (nomLogique)
qui nous signale si la fin du fichier est atteinte, s’il y a encore une ligne à lire/traiter.

8.2.4. Écriture d'un enregistrement

writeln(nomLogique, Chaine) ;

8.2.5. Lecture d'un renregistrement

Il est OBLIGATOIRE de s'assurer qu'il y a encore quelque chose à

lire avant d'effectuer la lecture

Les fichiers texte se lisent de manière séquentielle, chaque ligne les

unes après les autres après avoir vérifier que nous ne sommes pas à la fin
du fichier.

While not EOF(FiLogique) do

begin
Readln(FiLogique,chaine) ;
//traitement de la ligne lue
..
end ;

2023-2024 38 P. Renouprez
 ECCSA Programmation 6U
8.2.6. Résumé fichiers texte (longueur variable)
Var Var
FiLogique : TEXTFILE ; FiLogique : TEXTFILE ;
chaine: string ; chaine: string ;

// dans le programme // ECRITURE dans un fichier texte

// LECTURE d’un fichier texte //lier les fichiers log et phys
//--------------------------- assign(FiLogique,nomPhysique) ;
//lier les fichiers log et phys //Ouvrir le fichier en ECRITURE
assign(FiLogique,nomPhysique) ; rewrite(FiLogique) ;
//Ouvrir le fichier en LECTURE repeat
reset(FiLogique) ; begin
//Tant qu’il reste une lig à LIRE //saisie du texte à écrire
While not EOF(FiLogique) do readln(chaine)
begin //ECRIRE une ligne de texte
//LECTURE d’une ligne de txt // dans le fichier
//dans le fichier writeln(FiLogique,chaine) ;
Readln(FiLogique,chaine) ; //traitement de la ligne lue
//traitement de la ligne lue
until ;//plus de ligne à ECRIRE
end ; close(FiLogique) ;..
close(FiLogique) ;..

8.2.7. Exercices 01

1. Crée un programme qui créera un fichier texte appelé [Link] et

y stocker des valeurs (de type string) récupérées depuis le clavier
jusqu'à la lecture de la chaîne 'FIN'. La chaîne de caractère, 'FIN' en
l'occurrence ne sera pas stockée dans le fichier.

2. Améliore ton programme pour qu’il s’arrête quelque soit la casse du

mot fin:('fin','fIn',FIN, etc..)

3. Écrire un deuxième programme qui

◦ récupère le 10 premiers mots du fichier,

◦ les stocke dans un tableau de 10 chaînes,

◦ puis affiche celui-ci.

4. Améliore ce deuxième programme pour qu’il puisse récupérer

jusqu’à 500 mots.

5. Avec une pose de l’affichage tous les écrans (20 lignes + ou -)

2023-2024 39 P. Renouprez
 ECCSA Programmation 6U
8.2.8. Exercices 02

1. Crée un programme qui lit un fichier texte appelé [Link] et

affiches toutes ses lignes d’enregistrement.

2. Qui découpe les lignes lues en mot (séparateurs de mot :

ponctuation, espace apostrophe) et écrit les mots de plus de 3
lettres dans un fichier [Link]

3. Qui remplace les lettres accentuées par leur équivalent sans accent

4. Qui remplace les majuscules par des minuscules.

5. Modifie le fichier pendu pour qu’il aille chercher les mots

aléatoirement dans ce fichier [Link].
Pour ce faire tu pourras utiliser la procédure ci dessous pour encore
améliorer ton programme.

8.2.9. Fichier inexistant

Quand il est ouvert en lecture, un fichier doit obligatoirement

exister, sinon le programme bogue. Il faut en fait tester la variable
IOResult, variable système qui contient un code erreur différent de zéro
s’il y a eu problème. La valeur de IOResult détermine le type d’erreur.

Le mieux est de tester l’existence d’un fichier à l’aide de la fonction

ci-dessous

function FileExists(FileName: string): Boolean;

var
F: file;
begin
{$I-}
Assign(F, FileName);
FileMode := 0;
Reset(F);
Close(F);
{$I+}
FileExists := (IOResult = 0) and (FileName <> '');
end;

Cette fonction est en fait déclarée dans la librairie sysutils de

Lazarus.

2023-2024 40 P. Renouprez
 ECCSA Programmation 6U
2
Exemples d’erreurs possibles

OS error I/O errors Fatal errors

2 File not found. 100 Error when reading 150 Disk is write protected.
from disk.
3 Path not found. 101 Error when writing to 151 Unknown device.
disk.
4 Too many open files. 102 File not assigned. 152 Drive not ready.
5 Access denied. 103 File not open. 153 Unknown command.
6 Invalid file handle. 104 File not opened for 154 CRC check failed.
input.
1 Invalid file-access mode. 105 File not opened for 155 Invalid drive specified..
2 output.
1 Invalid disk number. 106 Invalid number. 156 Seek error on disk.
5
1 Cannot remove current 157 Invalid media type.
6 directory.
1 Cannot rename across 158 Sector not found.
7 volumes.
159 Printer out of paper.
160 Error when writing to
device.
161 Error when reading
from device.
162 Hardware failure.

2
Source : [Link]

2023-2024 41 P. Renouprez
 ECCSA Programmation 6U
8.2.10. Exercices

Nombre phrase/mot ?
Écrire un programme qui détermine, dans un fichier texte dont le
nom est entré au clavier, le nombre de phrases terminées par un point, un
point d'interrogation ou un point d'exclamation.

Utiliser une fonction d'aide FIN_PHRASE qui décide si un caractère

transmis comme paramètre est un des séparateurs mentionnés ci-dessus.
FIN_PHRASE retourne la valeur (logique) true si le caractère est égal à
'.', '!' ou '?' et false dans le cas contraire.

Analyse texte
Écrire un programme qui détermine, dans un fichier texte dont le
nom est entré au clavier:
• le nombre de chacune des lettres de l'alphabet (sans distinguer les
majuscules et les minuscules),
• le nombre de mots,
• le nombre de paragraphes (c.-à-d.: des retours à la ligne),
Les retours à la ligne ne devront pas être comptabilisés dans les
caractères. On admettra que deux mots sont toujours séparés par un ou
plusieurs des caractères suivants:
• espace
• ponctuation: . : , ; ? !
• parenthèses: ( )
• guillemets: "
• apostrophe: '
Nom du fichier texte : [Link]
Votre fichier contient:
12 paragraphes
571 mots
4186 caractères
dont
279 fois la lettre a
56 fois la lettre b
. . .
3 fois la lettre z
et 470 autres caractères

2023-2024 42 P. Renouprez
 ECCSA Programmation 6U

Programme MinusCol

Type ligne
t_ligne = String ;

Fonction minusCar
function minusCar(c : char) : char ;

Cette fonction renvoie c en minuscule si c est une lettre, sinon c

reste inchangé.

If c in [‘A’..’Z’]
then
minusCar:= chr(ord(c)+32)//lowerCase(c)
else
minusCar:=c;

Procédure minusLig
procédure minusLig(var s : t_ligne);

Cette procédure met tous les caractères de s en minuscules.

Procédure casseNom
procédure casseNom(nom1, Nom2 : t_ligne);

Cette procédure ouvre en lecture F1 (fichier de nom physique nom1

et de type text), en écriture F2 (fichier de nom physique nom2 et de type
text), puis appelle la procédure casseFi(F1, F2) pour finalement fermer
les fichiers.

Procédure casseFi
procédure casseFi(var f1, f2 : text);

Cette procédure lit f1 enregistrement par enregistrement, découpe

ces enregistrements en mot et recopie ces mots en minuscules, l'un en
dessous de l'autre dans f2.

Programme principal
program minusCol;

Ce programme lit au clavier 2 noms de fichiers, puis recopie dans le

second fichier tous les mots du premier fichier en minuscule les uns en
dessous des autres.

2023-2024 43 P. Renouprez
 ECCSA Programmation 6U

8.3. Les types d’enregistrements des fichiers

Un fichier est composé d'enregistrements. Ces enregistrements
seront du même type pour un même fichier.

FiLogique1 : file of byte;

FiLogique2 : file of t_personne;
FiLogique3 : file of real;
Les instructions de base sont les mêmes que pour les fichiers texte
SAUF pour les lecture/écriture où nous laissons tomber le ‘ln’ des
instructions.

8.3.1. Ecriture d'un enregistrement

write(FiLogique , enregistrement) ;

8.3.2. Lecture d'un renregistrement

If not eof(FiLogique ) then read(FiLogique , enregistrement) ;

8.3.3. Positionnement dans un fichier d’enregistrement

Les enregistrements étant de longueur fixe, il est possible de se

positionner sur un enregistrement précis et même de connaître le nombre
d’enregistrement total du fichier à l’aide des fonctions suivantes.

Seek(FiLogique, numeroDEnregistrement) ;
nombreDEnregistrement:=FileSize(FiLogique) ;

8.4. Exemples
8.4.1. Exemple
TYPE
FichierDonnee = FILE OF Real ;
VAR
FiDonnee: FichierSequentiel;
nbrReel: real ;
BEGIN {main}
Assign ( FiDonnee, '[Link]' );
Rewrite ( FiDonnee ); {*ouverture du fichier en mode lecture *)
repeat begin
writeln('Entrez un reel a ecrire dans le fichier');
readln(nbrReel);
write(FiDonnee, nbrReel);
end ;
until nbrReel = 0 ;
Close ( FiDonnee )
END . (* -- main *)

2023-2024 44 P. Renouprez
 ECCSA Programmation 6U
8.4.2. Exemple
TYPE
FichierSequentiel = FILE OF Real ;
VAR
F: FichierSequentiel;
. . .
FUNCTION SommeFichierReel ( VAR Fichier: FichierSequentiel ): Real;
VAR
X, S: Real ;
BEGIN
S:=0;
WHILE NOT Eof ( Fichier ) DO BEGIN
Read ( Fichier, X );
S := S + X
END ; (* -- WHILE, Eof( Fichier ) *)
SommeFichierReel := S
END ; (* -- SommeFichierReel *)
. . .
BEGIN {main}
Assign ( F, '[Link]' );
Reset ( F ); {* ouverture du fichier en mode lecture *)
Writeln( SommeFichierReel( F ) );
Close ( F )
END . (* -- main *)

8.4.3. exemple
Debut dupliquerFichier
Associer (f1,'[Link]')
Associer (f2,'[Link]')
Ouvrir(f1)
Recréer(f2)
TANT QUE NonFinFichier(f1) FAIRE
Lire(f1,ch)
Ecrire(f2,ch)
FINTANTQUE
Fermer(f1)
Fermer(f2)
Fin Inconnu

2023-2024 45 P. Renouprez
ECCSA Programmation 6U
8.4.4. Table de routage

1. Crée une fonction pour convertir une adresse ip (string

composé 4 nombres (compris entre 0 et 255 et séparés par 3 ".") en
type structuré de 4 nombres

2. Crée une fonction pour transformer ce type structuré de 4

nombres en string de 32 bits.

3. Crée une fonction qui permet de transformer un string de 32

bits en adresse ip de 4 nombres séparés par des points

4. Crée un programme PGMSaisieTableRoutINITIALES qui permet

l'encodage de la table de routage de ton ordinateur dans un fichier.
Sous la forme suivante :

Destination Masque Passerelle Interface

string[32] integer string[32] string[32]

5. Crée un programme qui permet de lire ce fichier et enregistre

les éléments du fichier dans un tableau

6. Trie ce tableau sur base du masque puis de la destination

7. Reproduit le fonctionnement du routage à l'aide de cette table:

• Demande une adresse IP à l'utilisateur

• Parcours la table de routage afin de trouver l'interface de

sortie pour cette adresse

• Commence par le bas de la table

• Applique le masque à l'adresse introduite (ne

considère que les masque premiers bits)

• Compare l'adresse ainsi obtenue à l'adresse de

destination

• Si les adresses sont identiques

Alors Affiche l'interface correspondant
Sinon recommence avec le masque suivant

2023-2024 46 P. Renouprez
 ECCSA Programmation 6U
8.4.5. Encodage relevés journaliers de température :

Ecrire un programme qui lit les 8 fichiers de relevé d'un jour donné
(de [Link] à de [Link] ).

Pour chacun des fichiers relevés, calcule la moyenne des

températures du jour et d'un lieu et mémorise l'information dans un
tableau de données structurées comme suit :

t_lieux : record tTempProv :array[1..20] of

Lieu : string[20] ; t_lieux;
T00 : integer ;
T06 : integer ;
T12 : integer ;
T18 : integer ;
Tmoy:integer ;
End ;

Le programme demande à l'utilisateur d'introduire la date des

fichiers et vérifiera dans une certaine mesure (Mois compris entre 1 et
12 ; Jour compris entre 1 et 31) la validité de celle-ci.

Le programme affiche le fichier qu'il traite, puis une fois tous les
fichiers traités, affiche les données du tableau comme suit :

=== Ville 1 ===

Températures à 00h : 12 ; 06h : 14 ; 12h : 18 ; 18h : 15
Température moyenne:15
=== Ville 2 ===
Températures à 00h : 12 ; 06h : 14 ; 12h : 18 ; 18h : 15
Température moyenne:15
=== Ville 3 ===
Températures à 00h : 12 ; 06h : 14 ; 12h : 18 ; 18h : 15
Température moyenne:15
…

2023-2024 47 P. Renouprez
 ECCSA Programmation 6U

[Link] les données du tableau dans un fichier (texte)

au format csv

Le fichier [Link] ressemblera à ce qui suit :

Province ; Lieu;00h;06h;12h;18h;moy
Liege ; lieu 1;2;10;12;6;8
Liege ; lieu 2;2;10;12;6;8
Liege ; lieu 3;2;10;12;6;8
Liege ; lieu 4;2;10;12;6;8
Liege ; lieu 5;2;10;12;6;8
Liege ; lieu 6;2;10;12;6;8
Liege ; lieu 7;2;10;12;6;8
Liege ; lieu 8;2;10;12;6;8
Le programme signalera la création du fichier avant de s'arrêter.

[Link] des fonctions, des procédures et aura la

structure suivante :
Begin
jourTraite:= LireJour() ;
...
lireFichier(var : Tableau_Lieu : array [1..8] of t_lieu ;
jour : string; numLieu:integer)
...
afficherTemp(var: Tableau_Lieu : array [1..8] of t_lieu );
...
creerFichierCsv(nomProvince : string ;
var : Tableau_Lieu : array [1..8] of t_lieu);
...
End.

8.4.6. Bibliothèque

Crée un programme qui permet d'encoder 5 livres (Titre, Auteur,

ISBN, Prix)

Sauve ces 5 enregistrements dans un fichier

Vide la table

Recharge le fichier et effectue une recherche de livre du fichier

2023-2024 48 P. Renouprez
 ECCSA Programmation 6U
8.4.7. Programme CreationProfilUtilisateur.

Tu dois créer à partir de la liste des élèves de la classe un fichier qui

permettra de créer tous les profils élèves de la Cyberclasse.

En entrée, tu as fichier de type '.DAT'

Televe = record
nom : string[20];
prenom : string[25];
age : integer;
presence: boolean;
dateNais: string[8];
end;
A l’aide de ce fichier, crée un fichier .csv (fichier de type texte où les
champs de l'enregistrement sont séparés par des virgules) dont les
champs sont les suivants :

pseudonyme,nomPrenom,MotDePasse,Type,Classe,Annee,QuotaImpr
ession(pages),QuotaDisque(Mo),Internet(true/false)

• pseudonyme:Crée une procédure qui crée le login(pseudonyme) de

chaque élève en prenant la première lettre du prénom et les sept
premières lettres de son nom. Le tout en minuscule.

Ex : LAGAFFE Gaston glagaffe

DEMESMAKER Aime ademesma
SMITH Jules jsmith

• Les noms et prénoms sont à concaténer. Les espaces, tiret, accents

ont été enlevés des noms ou des prénoms.

Ex : de Champignac Pacôme-Ladislas sera enregistré de la sorte :

deChampignac PacomeLadislas
de Mesmaker Aimé a été enregistré : DEMESMAKER Aime

• Crée aléatoirement un mot de passe

• Type, Classe, Année, QuotaImpressionMois,QuotaDisque,Internet

sont demandé une fois pour toute après avoir demandé le nom du
fichier.

2023-2024 49 P. Renouprez
 ECCSA Programmation 6U
8.4.8. Exercice

Soit la structure Personne schématisée par le nom (chaîne de 30

caractères maximum), le numéro de téléphone (10 caractères maximum),
le numéro de carte bancaire (entier non signé).

Ecrire un programme qui permet l'enregistrement de 100 personnes

sous forme tabulaire.

Ecrire une série de fonctions qui testent si les données entrées sont
correctes :

• Une fonction pour vérifier que le nom ne contient pas de

chiffres

• Une autre fonction pour vérifier que le numéro de téléphone

ne contient pas de lettres de l'alphabet

Les fonctions évoquées ci-dessus porteront respectivement les noms

isString et isNumber. Indication :

• Ecrire des fonctions élémentaires isAlpha et isDigit qui

renseignent respectivement si leur argument est une lettre ou un
chiffre.

if (((ord(c) >= 97)

and (ord(c) <= 122)) or ((ord(c) >= 65)
and (ord(c) <= 90)))
then isalpha = true ;
if ((ord(c) >= 48)
and (ord(c) <= 57))
then isDigit := true ;
Utiliser les fonctions précédentes pour s'assurer que les données du
programme de l'énoncé précédent sont valides avant l'enregistrement.

Utilisez une procédure Up(s: string) est utilisée pour mettre tous les
caractères de la chaîne en majuscules en se servant de la fonction
UpCase, ceci pour mettre fin à la lecture dès lecture de 'FIN' !

2023-2024 50 P. Renouprez
ECCSA Programmation 6U
8.4.9. Dictionnaire de mot
Crée un programme qui
1. Lit le fichier [Link] contenant les paragraphes d'un article
du journal (affiche l'article à l'écran)

2. Crée un fichier de mot

3. pour chaque paragraphe lu :

1. va découper le paragraphe en mot (fin d'un mot quand

le caractère n'est pas dans [a,b,..,z,A,B,..,Z]

2. Si le mot a plus de 5 caractère, l'écrit dans un fichier

[Link]

4. Après avoir traiter ton article, affiche tous les mots que tu as
sélectionné (que tu as écris dans ton fichier mot)

5. bonus:gère la possibilité que le fichier n'existe pas et à l'aide

d'un menu

1. Donne la possibilité à l'utilisateur de donner le nom du

fichier article

2. Donne la possibilité à l'utilisateur de donner le nom du

fichier mot

3. De créer le fichier mot

4. de quitter le programme

6. Bonus2 Certains mots sont bizarres, trouve un moyen pour

améliorer le programme

Bon travail

2023-2024 51 P. Renouprez
 ECCSA Programmation 6U
[Link] types enregistrement
La structure de tableau permet de traiter des données composées
de plusieurs éléments tous de même type. Or d'autres données sont
formées d'éléments de types différents comme par exemple:

• les dates chronologiques (année, mois, jour)

• les fiches bibliographiques (titre du livre, auteur, date de parution,

ISBN...)

• es fiches personnelles (nom, prénom, âge, sexe, taille ...)

• ...

La nature différente de ces éléments conduit le programmeur à

utiliser une structure permettant la définition explicite de chacun de ces
éléments: les enregistrements.

9.1. Généralités
Un enregistrement (record) est formé d'un ou de plusieurs éléments
(ou champs) pouvant être de types différents.

Exemples:

record
notes : t_notes;
moyenne : real;
suffisant : boolean;
end

record (* nombre complexe *)

partie_reelle : real;
partie_imaginaire : real;
end

RECORD
reference : integer;
jour : date; {enregistrement d'enregistrement}
client : string [100];
total_HT : real
END;
RECORD
jour : 1..31;
mois : 1..12;
an : 1980..2020 ;
END;

2023-2024 52 P. Renouprez
 ECCSA Programmation 6U

9.2. Syntaxe
Les types enregistrement se déclarent ainsi:

type
t_branche = record (* notes d'une branche *)
notes : t_notes;
moyenne : real;
suffisant : boolean;
end ;
t_nombre_complexe = record (* nombre complexe *)
partie_reelle : real;
partie_imaginaire : real;
end;
Des variables de ces types se déclarent comme toujours:

var
maths : t_branche;
nombre_1, nombre_2 : t_nombre_complexe;
fi_nbr_cplx : array [1..20] of t_nombre_complexe;

9.3. Exercices
9.3.1. Ex01

On veut représenter sous forme d’un tableau un répertoire téléphonique

composé pour chaque enregistrement d’un prénom, nom et numéro de
téléphone.

Définir la structure de données en un tableau structuré

permettant de représenter le répertoire.

Ecrire l’algorithme :
1. qui permet d’ajouter un certain nombre de personnes dans le
répertoire
2. qui permet d’afficher toutes les personnes du répertoire
3. affichage de tous les n° de téléphone (et noms) correspondant à
un prénom donné
4. affichage du n° de téléphone correspondant à un prénom et un
nom (unique) donnés (Il n'a donc pas de synonyme)
5. affichage des informations (nom, prénom, tel) correspondant à un
rang dans le tableau TABL_AGENDA donnée
6. affichage des informations (nom, prénom, tel) correspondant
aux personnes de Bruxelles (préfixe téléphonique 02)
7. modification du n° de téléphone correspondant à un prénom et un
nom (unique) donnés (Il n'a donc pas de synonyme)

2023-2024 53 P. Renouprez
 ECCSA Programmation 6U
9.3.2. jeu du 421

Écrire un programme du jeu de 421 auquel joue deux joueurs en

utilisant un maximum de procédures ou fonctions.

Utilise un tableau de jeu comprenant 3 dés associés chacun à un

booléen indiquant s'il faut jouer le dé ou non.

9.3.3. Jeu de carte bataille

Écrire un programme du jeu de bataille auquel joue deux joueurs en

utilisant un maximum de procédures ou fonctions.

const
NBRCARTE = 52;
type
TcarteJeu = record
couleur: string;
carte : string;
poids : integer;
end;
Tjeu = array [0..(NBRCARTE-1)] of TcarteJeu ;
...

function InitTableau():Tjeu;
var i,j : integer;
couleur : array [0..3] of string = ('Coeur','Carreau','Trefle','Pique');
nbCarteCoul : integer;
begin
nbCarteCoul := NBRCARTE DIV 4;
for i:=0 to 3 do
begin
for j:= 0 to ((nbCarteCoul)-1) do
begin
InitTableau[(i*nbCarteCoul)+j].couleur :=couleur[i];
if j<1
then begin
InitTableau[(i*nbCarteCoul)+j].carte:= 'AS';
InitTableau[(i*nbCarteCoul)+j].poids:=11;
end
else begin
InitTableau[(i*nbCarteCoul)+j].poids:=j+1;
if j<10
then begin
InitTableau[(i*nbCarteCoul)+j].carte:= IntToStr(j+1);
end
else if j = 10
then InitTableau[(i*nbCarteCoul)+j].carte:='Valet'
else if j = 11
then InitTableau[(i*nbCarteCoul)+j].carte:='Dame'
else InitTableau[(i*nbCarteCoul)+j].carte:='Roi';
end;
end;
end;
end;

Bonus modifie le nombre de joueur

2023-2024 54 P. Renouprez
 ECCSA Programmation 6U
9.3.4. Le taquin
Ouvrir : Exo-Tableaux/Taquin/[Link]

Le formulaire
Principe du jeu
Lorsqu'on clique sur un chiffre se trouvant à coté du trou (le carré noir), le
chiffre est échangé avec le trou.

Le but du jeu est d'arrivé à ranger les chiffres dans l'ordre (c.a.d comme ci-
dessus) en effectuant plusieurs fois cette opération. Voilà par exemple deux coups
joué depuis le début du jeu:

Situation initiale Après avoir cliqué sur le 5 Après avoir cliqué sur le 2

Le bouton Shuffle permet de mettre les chiffres dans le désordre. Cette

opération est assez complexe à mettre en oeuvre. Elle sera donc laissé en projet.

1 ) Déclaration du tableau
Le jeu est représenté en mémoire par le tableau TabJeu. Il s'agit d'un tableau
d'entiers à deux dimensions de trois lignes et trois colonnes. Les lignes et les
colonnes sont indicées de 0 à 2.

Déclarez ce tableau en utilisant de préférence les constantes NC (nombre de

colonnes) et NL (nombre de lignes).

2) Initialisation du tableau
Pour que le programme affiche correctement le jeu au début, il vous faudra
complèter la procédure MettreLesChiffresDansLOrdre.

Cette procédure affecter les nombres 0, 1, 2, 3, ..., 8 au éléments du tableau

afin qu'ils soient rangés dans l'ordre. Le nombre 0 représente la case vide.

3) Gestion du clic sur une case du jeu

Lorsque l'utilisateur clique sur une case, la procédure GererClicSurCase est
appelé avec les indices de l'élément correspondant du tableau TabJeu.
GererClicSurCase (i,j: integer);
// Echange TabJeu[i,j] avec l'élément de TabJeu contenant le trou
Cette procédure est à complèter.
C'est dans cette procédure qu'il faudra intervertir le trou avec le chiffre, à condition
bien sur que l'utilisateur clique sur un chiffre voisin du trou.

2023-2024 55 P. Renouprez
 ECCSA Programmation 6U
Pour échanger les deux cases du tableau TabJeu vous utiliserez la procédure
EchangerLesCases:
EchangerLesCases(i1,j1,i2,j2:integer);
//Echange TabJeu[i1,j1] avec TabJeu[i2,j2]
Pour afficher le jeu après avoir modifié le tableau, appelez la procédure
AfficherLeJeu.

4) Mélange des chiffres

La procédure MelangerLesChiffres est appelée, lorsque l'utilisateur clique sur
le bouton Shuffle.
Cette procédure doit changer aléatoirement l'ordre des éléments du tableau
TabJeu de manière à ce qu'il soit possible de les remettre dans l'ordre.

On pourra utiliser la fonction Random ( n ) qui retourne un nombre entier au

hasard compris entre 0 inclu et n exclu. Pour ne pas générer systématiquement la
même suite de nombre aléatoire appelez la procédure Randomize (elle n'a pas de
paramètres).

2023-2024 56 P. Renouprez
 ECCSA Programmation 6U
9.3.5. Le Solitaire
Ouvrir : Exo-Tableaux/Solitaire/[Link]
Le solitaire est un jeu compsé de 32 billes déposées dans des creux et disposées en
croix. Le creux central est initialement vide:

Le but du jeu est d'enlever toutes les billes du jeu en respectant la règle
suivante: pour enlever une bille, il faut la faire sauter par dessus une bille voisine et
cela n'est possible que si le creux se situant derrière elle est inoccupé. Les sauts en
diagonale sont interdits.

Pour jouer, l'utilisateur clique sur une bille. S'il peut la jouer elle apparait en
rouge et les creux dans lequels il peut la déplacer apparaissent en bleu. Il clique
ensuite sur un des creux en bleu (le plus souvent, il n'y en a qu'un seul) pour
déplacer la bille à cet endroit. Dans l'exemple suivant, il y a trois creux possibles:

La bille (en rouge) peut être déplacée dans trois creux (en bleu)

Etat du jeu après avoir avoir sélectionné le creux se situant à droite de la bille.

Représentation graphique du jeu

Le jeu est représenté graphiquement par 49 composants de type TShape
disposés en carré:

Les TShapes blancs sont invisibles à l'exécution du programme.

Ils ont été nommés en fonction de leur position dans le carré et stockés par
la procédure InitialiserTabShape dans le tableau TabShape à 7 lignes et 7 colonnes:
Shape1_1 Shape1_2 Shape1_3 Shape1_4 Shape1_5 Shape1_6 Shape1_7
Shape2_1 Shape2_2 Shape2_3 Shape2_4 Shape2_5 Shape2_6 Shape2_7
Shape3_1 Shape3_2 Shape3_3 Shape3_4 Shape3_5 Shape3_6 Shape3_7
Shape4_1 Shape4_2 Shape4_3 Shape4_4 Shape4_5 Shape4_6 Shape4_7
Shape5_1 Shape5_2 Shape5_3 Shape5_4 Shape5_5 Shape5_6 Shape5_7
Shape6_1 Shape6_2 Shape6_3 Shape6_4 Shape6_5 Shape6_6 Shape6_7
Shape7_1 Shape7_2 Shape7_3 Shape7_4 Shape7_5 Shape7_6 Shape7₇

Représentation interne du jeu

Le jeu est représenté de manière interne par un tableau à deux dimensions
nommé TabJeu possédant 7 lignes et 7 colonnes indicées de 1 à 7.

2023-2024 57 P. Renouprez
 ECCSA Programmation 6U
Un élément TabJeu [ i , j ] correspond au composant graphique Shapei_j. Il a
cinq valeurs possibles:
● 1 : creux occupé par une bille (représenté graphiquement en gris clair)
● 0 : creux vide (représenté en gris foncé)
● -1: absence de creux (invisible)

● 2 : creux où il est possible de déposer une bille (représentée en bleu)

● 3 : bille sur laquelle l'utilisateur à cliqué et qu'il peut déplacer (représenté en
rouge).
Au début ,le tableau contient donc les valeurs suivantes:

/ 1 2 3 4 5 6 7

1 -1 -1 1 1 1 -1 -1
2 -1 -1 1 1 1 -1 -1
3 1 1 1 1 1 1 1
4 1 1 1 0 1 1 1
5 1 1 1 1 1 1 1
6 -1 -1 1 1 1 -1 -1
7 -1 -1 1 1 1 -1 -1
La représentation graphique du jeu à partir de cette représentation interne est déjà
réalisée. Votre travail consistera uniquement à agir sur la représentation interne.
Pour mettre à jour la représentation graphique après avoir modifié la représentation
interne, il vous suffira d'appeler la procédure AfficherJeu.

Question 1: Initialisation du jeu

Complètez la procédure InitialiserTabJeu, de manière à que cette procédure initialise
correctement le tableau TabJeu. Cette procédure est appelée dans FormCreate. Il
vous suffira donc de lancer le programme pour voir si elle fonctionne correctement.

Question 2: Indication des possibilités

Dans cette question, il s'agit simplement de faire fonctionner l'indication des
possibilités de jeu. Pour cela, le programme doit être en mode test. Vous pouvez
activer ou désactiver ce mode en cochant la case à cocher du formulaire. Le booléen
ModeTest vaut true si et seulement si elle est cochée. Votre travail consistera à
complèter deux procédures:

● IndiquerLesPossibilites (i, j)
Indique les possibilités de jeu lorsque l'utilisateur clique sur le composant Shapei_j.
L'effet de cette procédure doit être le suivant:
2023-2024 58 P. Renouprez
 ECCSA Programmation 6U
○ Le nombre de possibilités de jeu doit être stocker dans la variable globale
NP prévue à cet effet.

○ Si l'emplacement i, j est vide et que le programme est en mode test,

affichage du message "Ce creux ne contient aucune bille !!".

○ Si l'emplacement i, j contient une bille, mais qu'elle ne peut pas être jouée
et que le programme est en mode test, affichage du message"Impossible de
jouer cette bille !!".

○ Si l'emplacement i, j contient une bille pouvant être jouée:

■ Cette bille doit s'afficher en rouge.

■ Les creux où elle peut être déposée doivent s'afficher en bleu.

■ En mode test uniquement:

● Le nombre de coups possibles est affiché dans une boite de dialogue.

● Dès que l'utilisateur clique sur Ok, la bille réapparait en gris clair et les creux vides
où pouvait être déposé la bille, réapparaissent en gris foncé. Vous utiliserez pour
cela la procédure EffacerLesPossibilites ( i, j).

● EffacerLesPossibilites ( i, j) L'appel de cette procédure suppose que l'utilisateur a

cliqué une bille jouable située à la ligne i et à la colonne j. Elle apparait donc pour
l'instant en rouge et les creux où elle peut être déposée apparaissent en bleu. L'effet
de cette procédure doit être de faire réapparaitre les creux en gris foncé et la bille en
gris clair.

Pour tester le bon fonctionnement de ces deux procédures vous pouvez utiliser le
bouton permettant de retirer des billes du jeu.

Question 3: Déplacement d'une bille

Décochez le mode test et completez la procédure suivante:

JouerLeCoup (i1, j1, i2, j2): déplace la bille située en ligne i1, colonne j1 dans le
creux situé en ligne i2, colonne j2. La bille se trouvant entre ces deux emplacements
est retirée du jeu.

Question 4: Impossibilité de gagner

Complèter le programme de manière à ce que l'utilisateur soit averti de l'impossibilité
de gagner dès que possible.

2023-2024 59 P. Renouprez
 ECCSA Programmation 6U
9.3.6. le jeu du tic-tac-toe

Une fenêtre graphique 300 x 300 est découpée 9 carrés de 100 x

100. Un joueur (vous) joue contre l'ordinateur en cliquant dans un des
carrés et fait apparaître une croix pour essayer de faire une ligne.
L'ordinateur essaie d'empêcher le joueur de créer un alignement

On ne demande pas ici de faire tout le programme mais juste de

réfléchir et répondre aux questions suivantes

1. On veut garder en mémoire sous la forme d'un tableau 2D

nommé plateauJeu l'état actuel du Jeu. Quelles sont les dimensions
du tableau ?

Réaliser la déclaration et l'allocation de plateauJeu dans le setup()

2. Définir la correspondance entre le tableau et la fenêtre

graphique

3. Processing ayant initialisé le tableau avec des 0, on va remplir

le tableau au fur et à mesure de l'avancement du jeu soit par des 1
(pour vous) soit par des 2 (pour l'ordinateur)

4. Créer une fonction boolean estGagnante(int[][] tableau) qui

dit s'il y a un gagnant sur le plateau du Jeu

9.3.7. Exercice de révision

Soit la structure Personne schématisée par le nom (chaîne de 30

caractères maximum), le numéro de téléphone (10 caractères maximum),
le numéro de carte banquaire (entier non signé).

Ecrire le programme qui permet l'enregistrement de 100 personnes

dans un tableau.

2023-2024 60 P. Renouprez
 ECCSA Programmation 6U
10. Les tris
Algorithme de tri : il en existe plusieurs qui vont plus du simple au
plus complexe, ayant chacun ses avantages et inconvénients.

10.1. Le tri à Bulle

10.1.1. Principe

Balayer tout le tableau, et comparer les éléments 2 à 2, l’élément

courant avec l'élément suivant. Si l'élément courant est plus grand que le
suivant on les permute.

A la fin d'un tour l'élément le plus grand est placé et beaucoup de

permutations ont été effectuées

10.1.2. Algorithme de base

Begin
for j:=1 to NbElement do
begin
for i:=1 to (NbElement-1) do
begin
if ( element[i] > element[i+1])
then begin//permutation
elementPermute := element[i+1];
element[i+1] := element[i];
element[i] := elementPermute;
permutation := true ;
end;
end; //for i
end;// for j
End

10.1.3. Algorithme amélioré

Begin
permutation := true;
while permutation do
begin
permutation := false;
for i:=1 to (NbElement-1) do
begin
if ( element[i] > element[i+1])
then begin//permutation
elementPermute := element[i+1];
element[i+1] := element[i];
element[i] := elementPermute;
permutation := true ;
end;
end;

2023-2024 61 P. Renouprez
 ECCSA Programmation 6U
end;// While
End

2023-2024 62 P. Renouprez
 ECCSA Programmation 6U

10.2. Tri par insertion

10.2.1. Principe

Le principe du tri par insertion est d'insérer au n-ième tour le n-ième

élément à la bonne place dans les éléments qui le précèdent.

A la fin du tour i, les i premiers éléments du tableau sont triés

10.2.2. Algorithme
For j := 1 to (NbElement-1) do
begin
elementAInserer:= element[j];
i :=j-1
while ( element[i] < element[i+1]) and i>1
begin
element[i+1] := element[i];
element[j] := elementAInserer;
end;
end;//while
end;// For j

10.3. Le tri par sélection (du plus petit)

10.3.1. Principe

Balayer tout le tableau pour trouver l'élément le plus petit et le

mettre en première position. Recommencer à partir du deuxième élément
et ainsi de suite.

A la fin du tour i, les i plus petits éléments du tableau sont triés en

début de tableau

10.3.2. Algorithme
For j := 1 to (NbElement-1) do
begin
min := j
for i:=j+1 to (NbElement) do
begin
if ( element[j] < element[min])
then //changer de min
begin
min;
end;
end;
// mettre le minimum en premiere position
elementMin:= element[min];

2023-2024 63 P. Renouprez
 ECCSA Programmation 6U
element[min] := element[j];
element[j] := elementMin;
end;// For j

2023-2024 64 P. Renouprez
 ECCSA Programmation 6U

10.4. Quick Sort

Le tri le plus rapide, tri à l’aide de procédures de récursives.

On choisit une valeur dans centrale dans le tableau. et on cherche la

position définitive de cette valeur. Ensuite on exécute des déplacements.
On compare la valeur médiane. Puis au décale la médiane vers la gauche
et en redivise par 2.

10.4.1. Algorithme
const
NBElement = 20;
var
element: array [1..NBElement] of integer =

(2,6,5,12,2,16,7,9,11,20,14,3,15,1,3,10,18,16,4,8);
elementPermute : integer;
i : integer;
permutation : boolean;

procedure trier(Gauche, Droite : integer);

var i,j : integer;
elementPivot,w : integer; //TYPEElement

begin
i := Gauche;
j := Droite;
elementPivot := element[(i+j) DIV 2]; (*Div pour que la division
donne un entier*)
repeat
begin
while element[i] < elementPivot do i:=i+1;
while elementPivot < element[j] do j:=j-1;
if i <= j
then
begin //permuter el i et el j
w := element[i];
element[i] := element[j];
element[j] := w;
i := i+1;
j := j-1;
end;
end;
until i > J;
if gauche < J then trier (Gauche, j);
if droite > I then trier (i, droite);
end;//procedure

begin
writeln('avant tri');
For i := 1 to NbElement do write(element[i], ' ');
permutation := true;

2023-2024 65 P. Renouprez
 ECCSA Programmation 6U
trier(1,NbElement);
writeln('Après tri');
For i := 1 to NbElement do write(element[i], ' ');
Readln();
end.

10.4.2. PgmTri

Tri par sélection: perm(x,y) est une procédure échangeant les

contenus des
mémoires x et y ; On considère l'algorithme de tri croissant des n
éléments d'un
tableau a:

Pour i=1 à n-1 faire

Pour j=i +1 à n faire
Si a > a[j] alors faire perm(a,a[j]) finSi
FinPour
FinPour
Construire des modules (procedure ou function) de

1. Permutation des contenus de 2 mémoires de type REAL (0.5 ).

2. Tri croissant par sélection des éléments de type REAL d'un tableau
de N
éléments saisis au clavier (1.5 ).

3. Construire un programme principal qui teste la procédure de tri.

Modifier les
modules et le programme principal afin qu'il trie une liste de noms
par ordre
alphabétique (1 ).

2023-2024 66 P. Renouprez