Ch. 01 · Leçon 1
Les variables et les types standard de données
Ce que vous saurez faire
- →Distinguer une constante d'une variable.
- →Déclarer constantes et variables en analyse et en Pascal.
- →Identifier les types standard : entier, réel, booléen, caractère, chaîne.
- →Utiliser les opérateurs et fonctions arithmétiques standards.
- →Évaluer des expressions logiques selon l'ordre de priorité.
id: 33-206-variables-et-types-standards slug: 33-206-variables-et-types-standards titre: Les variables et les types standard de données chapitre: 1 chapitre_titre: Les structures de données lecon: 1 niveau: 4eme-sci ordre: 1 prerequis: [] duree_estimee_min: 60 mots_cles:
- constante
- variable
- identificateur
- type entier
- type reel
- type booleen
- type caractere
- chaine de caracteres
- pascal
- affectation langages:
- analyse
- pascal objectifs:
- Distinguer une constante d'une variable.
- Déclarer constantes et variables en analyse et en Pascal.
- 'Identifier les types standard : entier, réel, booléen, caractère, chaîne.'
- Utiliser les opérateurs et fonctions arithmétiques standards.
- Évaluer des expressions logiques selon l'ordre de priorité. status: published source_pdf: 33_206.pdf source_pages:
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12 kind: cours
Les objets manipulés par un algorithme ou un programme peuvent être des constantes ou des variables, de type simple ou de type structuré. Cette première leçon présente ces deux notions ainsi que les principaux types standard de données.
I. Les constantes
1. Définition
Une constante est caractérisée par :
- son nom (un identificateur unique) ;
- sa valeur.
Exemples : pi = 3.14, message = 'Bonjour'.
2. Déclaration
Dans le tableau de déclaration des objets (T.D.O) :
| objet | Type / nature |
|---|---|
| Pi | Constante = 3.14 |
| message | Constante = "Bonjour" |
Dans le tableau de déclaration des objets (T.D.O) :
| objet | Type / nature |
|---|---|
| Pi | Constante = 3.14 |
| message | Constante = "Bonjour" |
Const
nom_constante = valeur_constante ;
Exemple :
Const
pi = 3.14 ;
message = 'Bonjour' ;
II. Les variables
1. Définition
Une variable est caractérisée par :
- son nom (un identificateur unique) ;
- son type ;
- son contenu.
2. Déclaration
Dans le tableau de déclaration des objets (T.D.O) :
| objet | Type / nature |
|---|---|
| n | entier |
| x | réel |
Dans le tableau de déclaration des objets (T.D.O) :
| objet | Type / nature |
|---|---|
| n | entier |
| x | réel |
var
<nom_variable> : type_variable ;
Exemple :
var
n : integer ;
x : real ;
Dire si l'utilisation de ces identificateurs est permise dans le langage Pascal ou non. Justifier votre réponse.
Code ProduitCode+ProduitCode_Produit3etapesCapacité
Voir le corrigé
Code Produit❌ un identificateur ne peut pas comporter un espace.Code+Produit❌ un identificateur ne peut pas comporter le signe +.Code_Produit✓3etapes❌ un identificateur doit commencer par une lettre.Capacité❌ un identificateur ne peut pas comporter de caractères accentués.
3. Activité : trace d'une séquence d'affectations
Soit la séquence d'affectations suivantes :
1) x ← 15
2) y ← 10
3) x ← y
4) y ← x
Donner le résultat d'exécution de cette séquence.
Voir le corrigé
| N° | Instruction | x | y |
|---|---|---|---|
| 01 | ··· | ? | ? |
| 02 | ··· | ? | ? |
| 03 | ··· | ? | ? |
| 04 | ··· | ? | ? |
On constate qu'après l'instruction 3, la valeur initiale de x est perdue : on ne peut donc pas permuter ainsi deux variables sans précaution.
Écrire une séquence permettant de permuter deux variables en utilisant une variable intermédiaire (temporaire ou auxiliaire).
Voir le corrigé
1) x ← 15
2) y ← 10
3) z ← x
4) x ← y
5) y ← z
| N° | Instruction | x | y | z |
|---|---|---|---|---|
| 01 | ··· | ? | ? | ? |
| 02 | ··· | ? | ? | ? |
| 03 | ··· | ? | ? | ? |
| 04 | ··· | ? | ? | ? |
| 05 | ··· | ? | ? | ? |
Écrire une séquence permettant de permuter deux variables sans utiliser de variable intermédiaire.
Voir le corrigé
1) x ← 15
2) y ← 10
3) x ← x + y
4) y ← x - y
5) x ← x - y
| N° | Instruction | x | y |
|---|---|---|---|
| 01 | ··· | ? | ? |
| 02 | ··· | ? | ? |
| 03 | ··· | ? | ? |
| 04 | ··· | ? | ? |
| 05 | ··· | ? | ? |
III. Les types de données
Le type d'une variable permet :
- de déterminer l'ensemble des valeurs qui peuvent lui être affectées ;
- de fixer implicitement l'ensemble des opérateurs valides sur cette variable.
1. Type entier
Sous-types en Pascal :
| Type | Domaine de définition | Nombre de bits |
|---|---|---|
| SHORTINT | -128 .. 127 | Signé 8 bits |
| INTEGER | -32768 .. 32767 | Signé 16 bits |
| LONGINT | -2 147 483 648 .. 2 147 483 647 | Signé 32 bits |
| BYTE | 0 .. 255 | Non signé 8 bits |
| WORD | 0 .. 65535 | Non signé 16 bits |
Opérateurs arithmétiques : +, -, *, div, mod.
div: donne le quotient dans la division entière.mod: donne le reste de la division entière.
Exemple : 23 div 7 = 3 et 23 mod 7 = 2.
| objet | Type/nature |
|---|---|
| m, i, j | entier |
| objet | Type/nature |
|---|---|
| m, i, j | entier |
var m, i, j : integer ;
- Quel est l'ordre de grandeur de la valeur maximale d'un entier ?
- Rappeler les opérateurs arithmétiques sur les entiers.
- Évaluer les expressions arithmétiques suivantes :
- a)
17 DIV 5 - b)
17 MOD 5 - c)
((58 DIV 7) MOD 2) + 5 - d)
(49 MOD 17) DIV (4*3)
- a)
- Peut-on utiliser le type entier pour représenter :
- a) Nombre de jours de l'année
- b) Durée en heures d'une séance de cours ou TP
- c) Nombre de jours du mois de février
- d) Salaire mensuel exprimé en dinar d'un employé
- Définir l'effet de débordement pour une variable de type entier.
- Déclarer 3 variables entières
i,jetken Pascal.
Voir le corrigé
- En mathématiques, les entiers forment l'ensemble infini ℤ. En informatique, un entier a une représentation en machine limitée à un nombre fini d'octets (généralement 2 octets). La valeur maximale d'un entier est alors égale à 32767.
- Les opérateurs arithmétiques sont
+,-,*,DIV(quotient de la division entière) etMOD(reste de la division entière). - Résultats :
- a)
17 DIV 5 = 3 - b)
17 MOD 5 = 2 - c)
((58 DIV 7) MOD 2) + 5 = (8 MOD 2) + 5 = 0 + 5 = 5 - d)
(49 MOD 17) DIV (4*3) = 15 DIV 12 = 1
- a)
- Représentation par un entier :
- a) Nombre de jours de l'année : oui (365 ou 366).
- b) Durée en heures d'une séance : non (peut être 1,5 h → réel).
- c) Nombre de jours du mois de février : oui.
- d) Salaire mensuel en dinars : non (réel).
- Débordement : quand on dépasse les valeurs minimale ou maximale représentables, les calculs deviennent erronés ou provoquent des erreurs d'exécution selon les langages.
- Déclaration :
Var i, j, k : INTEGER ;
Dire si l'on peut utiliser le type entier pour représenter les quantités suivantes :
- a) La note obtenue dans un examen
- b) Le nombre de matières étudiées pendant un trimestre
- c) Le coefficient d'une matière
- d) La moyenne générale du trimestre
Voir le corrigé
- a) Note d'examen : non (ex. 13,5).
- b) Nombre de matières : oui.
- c) Coefficient : non (ex. 1,5).
- d) Moyenne générale : non (réel).
2. Type réel
Opérateurs arithmétiques : +, -, *, / (division réelle).
| objet | Type/nature |
|---|---|
| x, y | réel |
| objet | Type/nature |
|---|---|
| x, y | réel |
var x, y : real ;
- Quel est le domaine de valeurs du type réel ?
- Quels sont les opérateurs arithmétiques valides sur des variables de type réel ?
- Déclarer deux variables
xetyde type réel en Pascal.
Voir le corrigé
- Sous-ensemble de ℝ. Un réel occupe en général 6 octets en Pascal ; on peut le coder dans l'intervalle de -10³⁸ à 10³⁸. Exemples :
0.,-55.36,3.14,60E-9,1.23,-38.0,5.6E+6. La lettreEse lit « dix puissance ». - Opérateurs :
+,-,*,/(division réelle). - Déclaration :
Var x, y : REAL ;
On se propose de calculer la surface d'un rectangle. Établir un tableau de déclaration des objets nécessaires.
Voir le corrigé
Formule : SURFACE = LONGUEUR × LARGEUR.
| Objet | Type/nature | Rôle |
|---|---|---|
| a | réel | Longueur |
| b | réel | Largeur |
| S | réel | Surface |
Fonctions arithmétiques standards
| Nom (analyse) | Code Pascal | Type paramètre | Type résultat | Rôle | Exemple |
|---|---|---|---|---|---|
Tronc(x) | TRUNC(x) | Entier/Réel | Entier | Supprime la partie décimale | Tronc(3.14) = 3 ; Tronc(-1.25) = -1 |
ENT(x) | INT(x) | Entier/Réel | Réel | Partie entière d'un réel | ENT(3.14) = 3.00 |
Arrondi(x) | ROUND(x) | Entier/Réel | Entier | Arrondi à l'entier le plus proche | Arrondi(9.49) = 9 ; Arrondi(2.5) = 3 |
Abs(x) | ABS(x) | Entier/Réel | Même type que x | Valeur absolue | Abs(-20) = 20 |
Carré(x) | SQR(x) | Entier/Réel | Même type que x | Carré de x | Carré(5) = 25 |
RacineCarrée(x) | SQRT(x) | Entier/Réel | Réel | Racine carrée (erreur si x < 0) | RacineCarrée(2) ≈ 1.4142 |
Aléa | RANDOM | — | Réel | Réel entre 0 et 1 exclu | |
Aléa(n) | RANDOM(n) | Entier | Entier | Entier entre 0 et n-1 | Aléa(3) ∈ {0,1,2} |
Sin(x) | SIN(x) | Entier/Réel | Réel | Sinus de x (en radians) | Sin(π/2) = 1 |
Cos(x) | COS(x) | Entier/Réel | Réel | Cosinus de x (en radians) | Cos(π/2) = 0 |
Arctan(x) | ARCTAN(x) | Entier/Réel | Réel | Arctangente de x (en radians) | Arctan(1) ≈ 0.785 |
Tan(x) | TAN(x) | Entier/Réel | Réel | Tangente de x (en radians) | Tan(π/4) = 1 |
Exp(x) | EXP(x) | Entier/Réel | Réel | Exponentielle de x | Exp(0) = 1 |
Ln(x) | LN(x) | Entier/Réel | Réel | Logarithme népérien (erreur si x ≤ 0) | Ln(1) = 0 |
3. Type booléen
Opérateurs logiques :
| Analyse | Pascal | Rôle |
|---|---|---|
| NON | NOT | Négation |
| ET | AND | Conjonction |
| OU | OR | Disjonction |
| OUex | XOR | Ou exclusif |
Table de vérité :
| x | y | NON(x) | x ET y | x OU y | x OUex y |
|---|---|---|---|---|---|
| Faux | Faux | Vrai | Faux | Faux | Faux |
| Faux | Vrai | Vrai | Faux | Vrai | Vrai |
| Vrai | Vrai | Faux | Vrai | Vrai | Faux |
| Vrai | Faux | Faux | Faux | Vrai | Vrai |
Ordre de priorité : parenthèses > NON > ET > OU = OUex.
| objet | Type/nature |
|---|---|
| flag, test | booléen |
| objet | Type/nature |
|---|---|
| flag, test | booléen |
var flag, test : boolean ;
begin
flag := true ;
test := 5 < 2 ;
end.
Exemples d'évaluation :
(15>5) ET (3<6)→Vrai ET Vrai= Vrai(15>5) OU (2>5)→Vrai OU Faux= Vrai(10>5) OU (20>40) ET (3<2)→Vrai OU (Faux ET Faux)=Vrai OU Faux= Vrai
a) Donner l'expression mathématique correspondant au code Pascal : sqrt( abs(x+1) ).
b) Représenter l'expression |2·x² + 5| avec les fonctions arithmétiques standards.
c) Évaluer les expressions suivantes :
tronc(20.5) + arrondi(2.45)(24>2) ou (8<4) et (15=2)
Voir le corrigé
a) sqrt( abs(x+1) ) = √|x+1|.
b) |2·x² + 5| s'écrit : abs(2*x*x + 5) ou abs(2*sqr(x) + 5).
c) Évaluations :
tronc(20.5) + arrondi(2.45) = 20 + 2 = 22(24>2) ou (8<4) et (15=2)=Vrai ou (Faux et Faux)=Vrai ou Faux= Vrai
4. Type caractère
Tous les caractères sont ordonnés selon leur code ASCII (American Standard Code For Information Interchange), norme à 256 caractères :
"0" < "1" < ... < "A" < "B" < ... < "a" < "b" < ...
L'espace " " est un caractère blanc.
Opérateurs sur les caractères : comme le type est ordonné, les opérateurs relationnels sont définis : <, >, =, <=, >=, <>.
Exemple : "A" < "B" est vrai.
| objet | Type/nature |
|---|---|
| c1, c2 | caractère |
| objet | Type/nature |
|---|---|
| c1, c2 | caractère |
var c1, c2 : char ;
begin
c1 := 'A' ;
c2 := 'B' ;
end.
Fonctions prédéfinies sur les caractères (x entier entre 0 et 255) :
| Nom (analyse) | Code Pascal | Rôle | Exemples |
|---|---|---|---|
ORD(c) | ORD(c) | Code ASCII du caractère c (entier positif) | ORD("A") = 65 ; ORD("a") = 97 |
CHR(x) | CHR(x) | Caractère dont le code ASCII est x | CHR(65) = "A" ; CHR(97) = "a" |
SUCC(c) | SUCC(c) | Caractère successeur de c | SUCC("C") = "D" |
PRED(c) | PRED(c) | Caractère prédécesseur de c | PRED("C") = "B" |
MAJUS(c) | UPCASE(c) | Convertit c en majuscule si possible | MAJUS("d") = "D" |
5. Type chaîne de caractères
| objet | Type/nature |
|---|---|
| nom | chaîne[10] |
| prenom | chaîne (max 255) |
| objet | Type/nature |
|---|---|
| nom | chaîne[10] |
| prenom | chaîne (max 255) |
var
nom : string[10] ;
prenom : string ; { max = 255 }
begin
nom := 'Bac2018' ;
end.
Exemples :
Nom ← "" { chaîne vide }
Prénom ← " " { un espace }
Ville ← "Sousse"
Fonctions et procédures standards sur les chaînes :
| Nom (analyse) | Code Pascal | Rôle | Exemple |
|---|---|---|---|
Long(ch) | LENGTH(ch) | Longueur de la chaîne (entier) | Long("Bonjour") = 7 |
Pos(ch1, ch2) | POS(ch1, ch2) | Position de ch1 dans ch2 (0 si absente) | Pos("ac", "Bac") = 2 |
Sous_chaine(ch, p, nbc) | COPY(ch, p, nbc) | Sous-chaîne de nbc caractères à partir de la position p | Sous_chaine("Baccalauréat", 1, 3) = "Bac" |
Concat(ch1, …, chn) | CONCAT(ch1, …, chn) | Concaténation des chaînes | Concat("14", ":", "10") = "14:10" |
Efface(ch, p, n) | DELETE(ch, p, n) | Enlève n caractères à partir de la position p (procédure) | Efface("CD ROM", 3, 4) → "CD" |
Insère(ch1, ch2, p) | INSERT(ch1, ch2, p) | Insère ch1 dans ch2 à la position p (procédure) | Insère("ur", "cos", 3) → "cours" |
Convch(d, ch1) | STR(d, ch1) | Convertit un nombre d en chaîne ch1 (procédure) | Convch(2018, ch) → ch = "2018" |
Valeur(ch, d, erreur) | VAL(ch, d, erreur) | Convertit la chaîne ch en valeur numérique d ; erreur = 0 si OK | Valeur("10.50", d, e) → d = 10.50, e = 0 ; Valeur("20/20", d, e) → d = 0, e = 3 |
Écrire les instructions Pascal permettant de réaliser les objectifs suivants sur la chaîne "Informatique" :
- Obtenir la longueur de la chaîne.
- Récupérer la sous-chaîne de 5 caractères à partir de la position 8.
- Effacer les 5 premiers caractères de la chaîne.
Voir le corrigé
On pose ch := 'Informatique' ;.
-
Longueur :
l := length(ch) ; { l = 12 } -
Sous-chaîne :
ch2 := copy(ch, 8, 5) ; { ch2 = 'tique' } -
Suppression :
delete(ch, 1, 5) ; { ch devient 'matique' }
Programme complet :
Program longueur ;
uses wincrt ;
var
l : integer ;
ch, ch2 : string ;
begin
ch := 'informatique' ;
l := length(ch) ;
writeln(l) ;
ch2 := copy(ch, 8, 5) ;
writeln(ch2) ;
delete(ch, 1, 5) ;
writeln(ch) ;
end.
Soient a un entier, x un réel et ch un caractère. Dire pourquoi les instructions suivantes sont erronées et les corriger si possible.
a := 3.4x := 5,16ch := xa := maxent + 5
Voir le corrigé
| Instruction erronée | Erreur | Correction proposée |
|---|---|---|
a := 3.4 | On ne peut pas affecter un réel à un entier. | a := 3 ; ou a := trunc(3.4) ; |
x := 5,16 | La virgule n'est pas utilisée pour les réels, mais le point. | x := 5.16 ; |
ch := x | On ne peut pas affecter un réel à un caractère. | ch := 'x' ; |
a := maxent + 5 | maxent n'est ni variable ni constante déclarée. | Déclarer la constante : const maxent = 1000 ; puis a := maxent + 5 ; |
Soit la partie déclarative du programme Pascal suivant :
PROGRAM Dates ;
CONST
Date1 = '03/07/2006' ;
VAR
Date2 : STRING[10] ;
Jour : STRING[2] ;
Mois : STRING[2] ;
Annee : STRING[4] ;
Compléter le corps du programme (bloc BEGIN ... END) pour :
- Mettre
Date1dansDate2sous la formejjmmaaaa(par exempleDate2 = "03072006"). - Mettre le jour dans
Jour, le mois dansMoiset l'année dansAnnee.
Voir le corrigé
BEGIN
{ 1) Construire Date2 sans les '/' }
Date2 := Date1 ;
Delete(Date2, 3, 1) ; { supprime le 1er '/' }
Delete(Date2, 5, 1) ; { supprime le 2e '/' }
{ Date2 contient maintenant '03072006' }
{ 2) Extraire jour, mois, année à partir de Date1 }
Jour := Copy(Date1, 1, 2) ; { '03' }
Mois := Copy(Date1, 4, 2) ; { '07' }
Annee := Copy(Date1, 7, 4) ; { '2006' }
END.
Soit le programme Pascal incomplet ci-dessous qui manipule la constante Date1 = '03/07/2006'. Le compléter pour :
- placer dans
Date2la chaîneDate1sans les séparateurs/, - extraire le jour, le mois et l'année dans trois variables distinctes.
Voir le corrigé
PROGRAM Dates;
CONST
Date1 = '03/07/2006';
VAR
Date2 : STRING[10];
Jour : STRING[2];
Mois : STRING[2];
Annee : STRING[4];
Begin
date2 := date1 ;
delete(date2, 3, 1) ;
delete(date2, 5, 1) ;
jour := copy(date1, 1, 2) ;
mois := copy(date1, 4, 2) ;
annee := copy(date1, 7, 4) ;
end.
Soit la partie déclarative du programme Pascal suivant :
PROGRAM mots ;
CONST
m1 = 'abcd';
m2 = 'ordinateur';
m3 = 'scalaire';
VAR
symetrie : STRING[8];
compose : STRING ;
......
Compléter la partie déclarative (si nécessaire) et écrire le bloc BEGIN ... END pour :
- Avoir dans la variable
symetrieune chaîne de caractères symétrique obtenue à partir dem1. - Avoir dans la variable
composeune chaîne obtenue en combinant la première moitié dem2et la deuxième moitié dem3en utilisant les fonctionsconcat()etcopy().
Voir le corrigé
PROGRAM mots ;
uses wincrt ;
CONST
m1 = 'abcd';
m2 = 'ordinateur';
m3 = 'scalaire';
VAR
symetrie : STRING[8];
compose : STRING ;
Begin
{ 1- Avoir dans la variable "symetrie" une chaîne symétrique à partir de m1 }
symetrie := concat(m1, m1) ; { autre méthode : symetrie := m1 + m1 ; }
writeln(symetrie) ;
{ 2- Combiner la première moitié de m2 et la deuxième moitié de m3 }
compose := concat( copy(m2,1,5), copy(m3,5,4) ) ;
{ autre méthode : compose := copy(m2,1,5) + copy(m3,5,4) ; }
writeln(compose) ;
end.
Méthode générale (avec calcul automatique des longueurs) :
var a2, a3 : integer ;
...
a2 := length(m2) ;
a3 := length(m3) ;
compose := copy(m2, 1, a2 div 2) + copy(m3, a3 div 2 + 1, a3 - a3 div 2) ;
Écrire un programme Pascal qui permet de transformer la chaîne "informatique" en majuscule sans utiliser la fonction upcase(), et de la placer dans une variable nommée maj.
Indication : le code ASCII de 'a' est 97 et celui de 'A' est 65 (écart de 32).
Voir le corrigé
PROGRAM majus ;
uses wincrt ;
VAR
ch, maj : string ;
Begin
ch := 'informatique' ;
ch[1] := chr( ord(ch[1]) - 32 ) ;
ch[2] := chr( ord(ch[2]) - 32 ) ;
{ ... }
ch[12] := chr( ord(ch[12]) - 32 ) ;
{ On peut utiliser une boucle :
var i : integer;
for i := 1 to length(ch) do
ch[i] := chr( ord(ch[i]) - 32 ) ; }
maj := ch;
end.
Leçon 2 — Les expressions
I. Définition
Exemple : 5 + 3.14
5: premier opérande+: opérateur3.14: second opérande
Il existe deux types d'expressions :
- les expressions arithmétiques,
- les expressions logiques.
II. Les opérateurs
1. Opérateurs arithmétiques
- Opérateur unaire (appliqué à un seul opérande) — exemple :
-6 - Opérateur binaire (appliqué à deux opérandes) — exemples :
3+5,6 mod 4
→ Type du résultat : entier ou réel.
2. Opérateurs logiques
Non, ET, OU, OUex → type du résultat toujours booléen.
3. Opérateurs relationnels
<, >, =, <=, >=, <> → type du résultat toujours logique (booléen).
III. Évaluation d'une expression
L'évaluation suit un ordre de priorité strict :
- Contenu des parenthèses
- Les fonctions
- Opérateur unaire (
-,Non) - Opérateurs multiplicatifs (
*,/,div,mod,Et) - Opérateurs additifs (
+,-,ou) - Opérateurs relationnels
Exemples d'évaluation
Évaluer : 12 + 4*5 - 2*(4 mod 3 + 5)
4 mod 3 = 1 → 1 + 5 = 6
12 + 4*5 - 2*6
= 12 + 20 - 12
= 20
Évaluer : 12 + 2 * 4 - 4
= 12 + 8 - 4
= 16
Évaluer : 10 mod 10 - 3
= 0 - 3
= -3
Évaluer les expressions suivantes :
a) ch ← "Bon" + "jour"
b) ch1 ← sous_chaine("Tunisie", pos("B","Bonjour"), long("matin"))
Voir le corrigé
a) ch ← "Bon" + "jour" ⇒ ch = "Bonjour"
b) ch1 ← sous_chaine("Tunisie", pos("B","Bonjour"), long("matin"))
pos("B","Bonjour")= 1long("matin")= 5- d'où
ch1 ← sous_chaine("Tunisie", 1, 5)⇒ ch1 = "Tunis"
Exercices du livre scolaire
1) Donner les expressions arithmétiques correspondantes aux expressions Pascal suivantes :
sqrt(2 * a + 3 / b - 2) / 3 + x4 * x / c * 6 - x10 * x / 2 + 4
2) Réciproquement, écrire en Pascal les expressions arithmétiques suivantes :
Voir le corrigé
1) Expressions Pascal → notation mathématique
| Expression en Pascal | Expression arithmétique |
|---|---|
sqrt(2*a + 3/b - 2) / 3 + x | √(2a + 3/b − 2) ⁄ 3 + x |
4 * x / c * 6 - x | (4x ⁄ c) × 6 − x |
10 * x / 2 + 4 | (10x) ⁄ 2 + 4 |
2) Notation mathématique → Pascal
| Expression arithmétique | Expression Pascal |
|---|---|
| (4x² + 2x − 5) / √(x + 5y/2) | (4*x*x + 2*x - 5) / sqrt(x + 5*y/2) |
| (y + 2) / (10x) + 1 | (y + 2) / (10*x) + 1 |
| √((x² − y) / (y − x/2)) | sqrt( (sqr(x) - y) / (y - x/2) ) |
Évaluer les expressions logiques A, B, C et D pour chacune des combinaisons (p, q, r, s) suivantes :
(p, q, r, s) = (-3, 5, 4, 9)(p, q, r, s) = (3, 7, 4, 9)(p, q, r, s) = (5, 13, 7, 3)
- A.
(p < q) OU (r > s) - B.
(p < q) ET NON (r > s) - C.
(p > q) OU (r ≠ p) - D.
(p + q < r) ET (p + q > r)
Voir le corrigé
Pour (p, q, r, s) = (-3, 5, 4, 9) :
| Expression | Évaluation | Résultat |
|---|---|---|
(p < q) OU (r > s) | (-3<5) OU (4>9) = Vrai OU Faux | Vrai |
(p < q) ET NON (r > s) | Vrai ET NON(Faux) = Vrai ET Vrai | Vrai |
(p > q) OU (r ≠ p) | (-3>5) OU (4 ≠ -3) = Faux OU Vrai | Vrai |
(p + q < r) ET (p + q > r) | (2<4) ET (2>4) = Vrai ET Faux | Faux |
Le même raisonnement s'applique aux deux autres combinaisons.
L'écriture suivante, censée vérifier si le caractère C est une voyelle, est erronée. Pourquoi ? Qu'aurait-il fallu écrire ?
C='A' OR C='E' OR C='I' OR C='O' OR C='U'
Voir le corrigé
Cette écriture ne vérifie que les voyelles MAJUSCULES, et la lettre Y est oubliée.
Correction pour inclure Y :
C='A' OR C='E' OR C='I' OR C='O' OR C='U' OR C='Y'
Cas général (majuscules ou minuscules) :
C='A' OR C='E' OR C='I' OR C='O' OR C='U' OR C='Y'
OR C='a' OR C='e' OR C='i' OR C='o' OR C='u' OR C='y'
Autre méthode (avec upcase) :
upcase(C)='A' OR upcase(C)='E' OR upcase(C)='I'
OR upcase(C)='O' OR upcase(C)='U' OR upcase(C)='Y'
Avec l'opérateur ensembliste in :
C in ['A','E','I','O','U','Y','a','e','i','o','u','y']
Ou encore, plus concis :
upcase(C) in ['A','E','I','O','U','Y']
- Rappeler l'ordre de priorités dans lequel une expression doit être évaluée.
- Comment évaluer deux opérateurs ayant la même priorité ?
- Compléter le tableau suivant par le type du résultat :
| Opérateur | Type opérande 1 | Type opérande 2 | Type du résultat |
|---|---|---|---|
Div | entier | entier | ... |
/ | entier | entier | ... |
+ | réel | entier | ... |
- | entier | entier | ... |
Voir le corrigé
Ordre de priorités :
- Contenu des parenthèses
- Les fonctions
- Opérateur unaire (
-,Non) - Opérateurs multiplicatifs (
*,/,div,mod,Et) - Opérateurs additifs (
+,-,ou) - Opérateurs relationnels
Deux opérateurs de même priorité s'évaluent de gauche à droite.
Tableau complété :
| Opérateur | Type opérande 1 | Type opérande 2 | Type du résultat |
|---|---|---|---|
Div | entier | entier | entier |
/ | entier | entier | réel |
+ | réel | entier | réel |
- | entier | entier | entier |
Leçon 3 — Le type scalaire énuméré et le type intervalle
I. Le type scalaire énuméré
1. Définition
Activité : définir le type Jour contenant les jours de la semaine.
Tableau de déclaration des nouveaux types
| Types |
|---|
Jour = (Lundi, Mardi, Mercredi, Jeudi, Vendredi, Samedi, Dimanche) |
Tableau de déclaration des nouveaux types
| Types |
|---|
Jour = (Lundi, Mardi, Mercredi, Jeudi, Vendredi, Samedi, Dimanche) |
Type
jour = (Lundi, Mardi, Mercredi, Jeudi,
Vendredi, Samedi, Dimanche) ;
var
j : jour ;
Propriétés :
- On peut appliquer la fonction
Ordsur les valeurs pour déterminer leur numéro d'ordre.Ord(Lundi) = 0Ord(Mardi) = 1
- Les opérateurs applicables sont :
- les opérateurs de relation (
<,>,=, …), - les fonctions
Pred(prédécesseur) etSucc(successeur).
- les opérateurs de relation (
Syntaxe Pascal :
Type <nom_type> = (constante_1, constante_2, ..., constante_n) ;
Var <nom_variable> : <nom_type> ;
La déclaration suivante est-elle correcte ? Justifier.
Pair = (0, 2, 4) ;
Voir le corrigé
La déclaration Pair = (0, 2, 4) ; est fausse.
Justification : un type scalaire énuméré doit être défini par des identificateurs, et non par des entiers comme 0, 2, 4.
En utilisant le type scalaire énuméré, déclarer en algorithmique puis en Pascal les types suivants :
couleur_de_basejour_de_la_semaine
Voir le corrigé
Tableau de déclaration de nouveaux types
| Type |
|---|
couleur_de_base = (rouge, bleu, jaune) |
jour_de_la_semaine = (lundi, mardi, mercredi, jeudi, vendredi, samedi, dimanche) |
Tableau de déclaration de nouveaux types
| Type |
|---|
couleur_de_base = (rouge, bleu, jaune) |
jour_de_la_semaine = (lundi, mardi, mercredi, jeudi, vendredi, samedi, dimanche) |
Type
couleur_de_base = (rouge, bleu, jaune) ;
jour_de_la_semaine = (lundi, mardi, mercredi,
jeudi, vendredi, samedi,
dimanche) ;
II. Le type intervalle
1. Définition
Activité : définir le type mois, le type week_end et le type lettres.
Tableau de déclaration des nouveaux types :
| Types |
|---|
Jour = (Lundi, Mardi, Mercredi, Jeudi, Vendredi, Samedi, Dimanche) |
week_end = samedi..dimanche |
mois = 1..12 |
lettres = 'a'..'z' |
Syntaxe Pascal :
Type <nom_type> = borne_inf..borne_sup ;
Var <nom_variable> : <nom_type> ;
Exemple complet :
type
jour = (Lundi, Mardi, Mercredi, Jeudi,
Vendredi, Samedi, Dimanche) ;
week_end = samedi..dimanche ;
mois = 1..12 ;
lettres = 'a'..'z' ;
var
j : jour ;
m : mois ;
w : week_end ;
l : lettres ;
En utilisant le type intervalle, déclarer en algorithmique et en Pascal les variables :
jourmois
Voir le corrigé
Première solution (intervalle d'entiers) :
| Type |
|---|
Jour = 1..31 |
mois = 1..12 |
| Type |
|---|
Jour = 1..31 |
mois = 1..12 |
Type
Jour = 1..31 ;
mois = 1..12 ;
Autre solution (jour comme intervalle d'un type énuméré) :
| Type |
|---|
semaine = (lundi, mardi, mercredi, jeudi, vendredi, samedi, dimanche) |
Jour = lundi..dimanche |
mois = 1..12 |
| Type |
|---|
semaine = (lundi, mardi, mercredi, jeudi, vendredi, samedi, dimanche) |
Jour = lundi..dimanche |
mois = 1..12 |
Type
semaine = (lundi, mardi, mercredi, jeudi,
vendredi, samedi, dimanche) ;
Jour = lundi..dimanche ;
mois = 1..12 ;
var
j : jour ;
Le programme Pascal suivant comporte de nombreuses erreurs. Les trouver.
PROGRAM deserreurs ;
CONST
I = 10 ; J = 40 ; K = 5 ;
TYPE
integer = -32000..+32000
voyelles1 = ('A','E','I','O','U');
voyelles2 = (A,E,I,O,U);
Abscisses = 0..0.001;
Indice = -10..+10;
VAR
S : Indice ; V : voyelle2 ; R : REAL;
BEGIN
R := 35;
V := R + 1;
S := 2*J + K;
END
Voir le corrigé
Erreurs corrigées :
PROGRAM deserreurs ;
CONST
I = 10 ; J = 40 ; K = 5 ;
TYPE
integer = -32000..+32000 ; { point-virgule manquant }
voyelles1 = (A,E,I,O,U,Y); { un type énuméré ne contient pas
des caractères entre guillemets }
voyelles2 = (A,E,I,O,U,Y);
Abscisses = 0..10; { les bornes d'un intervalle ne
peuvent pas être réelles }
Indice = -10..+10;
VAR
S : Indice ; V : voyelles2 ; R : REAL; { voyelles2 et non voyelle2 }
BEGIN
R := 35;
V := A; { V est de type voyelles2 : ne
peut être affectée que par
A,E,I,O,U,Y }
S := 2*J + K - 80; { S doit être dans -10..+10 }
END. { point final manquant }
Soit le programme Pascal suivant :
PROGRAM erreurs
TYPE
eleves : (Ali,Safa,Sami,Wissem,Kamel) ;
moyenne = 0..20
VAR
e1 : eleves;
e2 : eleves;
n1 : moyenne
n2 : moyenne ;
reussir : BOOLEAN ;
BEGIN
e1 := "Safa";
n1 = ORD(Kamel) + 2 * SUCC(Ali) ;
e2 := Sami ;
n2 := -15;
russir := ( n2 > 10 ) ;
END.
- Corriger les erreurs.
- Évaluer le contenu des variables utilisées.
Voir le corrigé
1) Correction des erreurs
PROGRAM erreurs ; { ; manquant }
TYPE
eleves = (Ali,Safa,Sami,Wissem,Kamel) ; { = au lieu de : }
moyenne = 0..20 ; { ; manquant }
VAR
e1 : eleves;
e2 : eleves;
n1 : moyenne ; { ; manquant }
n2 : moyenne ;
reussir : BOOLEAN ;
BEGIN
e1 := Safa; { identificateur, pas "Safa" }
n1 := ORD(Kamel) + 2 * ORD( SUCC(Ali) ); { := et ORD obligatoire pour
obtenir un entier }
e2 := Sami ;
n2 := 15; { -15 hors intervalle 0..20 }
reussir := ( n2 > 10 ) ; { reussir et non russir }
END.
2) Évaluation des variables
| N° | Instruction | e1 | n1 | e2 | n2 | reussir |
|---|---|---|---|---|---|---|
| 01 | ··· | ? | ? | ? | ? | ? |
| 02 | ··· | ? | ? | ? | ? | ? |
| 03 | ··· | ? | ? | ? | ? | ? |
| 04 | ··· | ? | ? | ? | ? | ? |
| 05 | ··· | ? | ? | ? | ? | ? |
Détail du calcul de n1 :
ORD(Kamel)= 4 (Kamel est la 5ᵉ valeur, indice 4)SUCC(Ali)=Safa, doncORD(SUCC(Ali))=ORD(Safa)= 1n1 = 4 + 2 × 1 = 6
Leçon 4 : Les tableaux
Activité introductive
On veut écrire un programme qui permet de saisir puis afficher la moyenne de 5 élèves d'une classe dans une matière donnée.
I. Déclaration d'un tableau
Tableau de déclaration des objets :
| Objet | Type/Nature |
|---|---|
| Ident_tableau | Tableau de taille et de type_element |
Tableau de déclaration des objets :
| Objet | Type/Nature |
|---|---|
| Ident_tableau | Tableau de taille et de type_element |
Var
Ident_tableau : ARRAY [B_inf..B_sup] of type_element;
Exemple
Tableau de déclaration des objets :
| Objet | Type/Nature | Rôle |
|---|---|---|
| Moyenne | Tableau de 5 réels | Stocker les notes de 5 élèves |
Tableau de déclaration des objets :
| Objet | Type/Nature | Rôle |
|---|---|---|
| Moyenne | Tableau de 5 réels | Stocker les notes de 5 élèves |
Var
Moyenne : ARRAY [1..5] OF REAL;
II. Le type tableau
On peut aussi déclarer un tableau en définissant d'abord un nouveau type.
Exemple : deux classes d'élèves
On a deux classes pour lesquelles on veut stocker le nom de l'élève, sa moyenne et son rang.
En analyse :
Tableau de déclaration des nouveaux types :
| TYPES |
|---|
| Classe = tableau de 20 chaînes de caractères |
| T_Moyenne = tableau de 20 réels |
| T_rang = tableau de 20 entiers |
Tableau de déclaration des objets :
| Objet | Type/Nature | Rôle |
|---|---|---|
| CL1 | Classe | Tableau des noms des élèves de la classe 1 |
| CL2 | Classe | Tableau des noms des élèves de la classe 2 |
| moyCl1 | T_Moyenne | Tableau des moyennes de CL1 |
| moyCl2 | T_Moyenne | Tableau des moyennes de CL2 |
| rangCl1 | T_rang | Tableau des rangs des élèves de CL1 |
| rangCl2 | T_rang | Tableau des rangs des élèves de CL2 |
En Pascal :
Type
classe = array [1..5] of real;
Var
cl1 : classe;
Exercice d'application
Soit la séquence suivante :
T[1] ← 30T[2] ← 7T[3] ← T[1] div T[2]T[4] ← T[3] * 10T[5] ← T[1] + T[3] * T[4]
Questions :
- Déclarer le tableau T.
- Quel est le contenu de chaque élément du tableau ?
Voir le corrigé
1) Déclaration du tableau T
Première méthode :
Tableau de déclaration des objets :
| Objet | Type/Nature |
|---|---|
| T | Tableau de 5 entiers |
Tableau de déclaration des objets :
| Objet | Type/Nature |
|---|---|
| T | Tableau de 5 entiers |
Var
T : array[1..5] of integer;
Deuxième méthode (avec un type nommé) :
Tableau de déclaration des nouveaux types :
| TYPES |
|---|
| Tab = Tableau de 5 entiers |
Tableau de déclaration des objets :
| Objet | Type/Nature |
|---|---|
| T | Tab |
Tableau de déclaration des nouveaux types :
| TYPES |
|---|
| Tab = Tableau de 5 entiers |
Tableau de déclaration des objets :
| Objet | Type/Nature |
|---|---|
| T | Tab |
Type
tab = array[1..5] of integer;
Var
T : tab;
2) Contenu du tableau après exécution
| N° | Instruction | T[1] | T[2] | T[3] | T[4] | T[5] |
|---|---|---|---|---|---|---|
| 01 | ··· | ? | ? | ? | ? | ? |
| 02 | ··· | ? | ? | ? | ? | ? |
| 03 | ··· | ? | ? | ? | ? | ? |
| 04 | ··· | ? | ? | ? | ? | ? |
| 05 | ··· | ? | ? | ? | ? | ? |
Exercices complémentaires
Soit A un tableau de 3 chaînes de caractères et B un tableau de 2 entiers.
Soit la séquence d'affectation suivante :
A[1] ← sous-chaine("communication", 1, 3)A[2] ← concat("sports", ".", A[1])B[1] ← pos("o", A[2])convch(2007, ch)A[3] ← "www." + A[2]insérer(ch, A[3], 11)B[2] ← long(A[1])
Questions :
- Quel est le contenu de chaque élément des deux tableaux A et B ?
- Traduire cet algorithme en Pascal.
Voir le corrigé
1) Contenu des tableaux
Tableau A :
| Indice | 1 | 2 | 3 |
|---|---|---|---|
| A | com | sports.com | www.sports2007.com |
Tableau B :
| Indice | 1 | 2 |
|---|---|---|
| B | 3 | 3 |
2) Traduction en Pascal
Program ex6page51;
uses wincrt;
var
A : array[1..3] of string;
B : array[1..2] of integer;
ch : string;
begin
A[1] := copy('communication', 1, 3);
A[2] := concat('sports', '.', A[1]);
B[1] := pos('o', A[2]);
str(2007, ch);
A[3] := 'www.' + A[2];
insert(ch, A[3], 11);
B[2] := length(A[1]);
End.
Soit le tableau suivant :
| Indice | 1 | 2 | 3 | 4 | 5 |
|---|---|---|---|---|---|
| T | 14 | 10 | 19 | 84 | 92 |
- Déclarer le tableau T en algorithmique et en Pascal.
- Donner les affectations permettant de remplir T.
- Inverser les éléments du tableau T sans utiliser un autre tableau.
Soit V et W deux tableaux d'entiers, de types respectifs T1 et T2 et de tailles respectives 4 et 3.
Soit la séquence d'affectations suivante :
V[1] ← 300
V[2] ← 50
W[1] ← V[1] + V[2] * 2
V[3] ← W[1] DIV 3
W[2] ← W[1] MOD V[1]
W[3] ← V[2] * 2 + 2
V[4] ← (V[2] DIV 4) MOD 2
V[8] ← V[4]
Questions :
- Déclarer les deux tableaux V et W.
- Trouver les erreurs d'affectation dans la séquence précédente.
- Quel est le contenu de chaque élément des deux tableaux V et W ?
Trouver les erreurs du programme Pascal suivant :
PROGRAM pleinerreurs;
CONST
N = 5;
VAR
I, J, N, M : INTEGER;
C : CHAR;
A : ARRAY[1..N] of CHAR;
B : ARRAY[1..M] of CHAR;
BEGIN
I := 0;
C := '0';
M := 4;
A[1] := C;
A[2] := SUCC(C);
B[1] := A[1];
END.
Sujet de baccalauréat — Session juin 2013
Sections : Mathématiques, Sciences expérimentales et Sciences techniques Durée : 1 h 30 — Coefficient : 0,5
Exercice 1 (3 points)
Pour chacune des instructions suivantes, valider chaque proposition en mettant V si elle est correcte ou F dans le cas contraire.
a. Soit l'instruction C ← Sous_chaîne("Baccalauréat", 4, 1)
- Elle permet d'affecter le caractère
"c"à la variable C. - La variable C doit être déclarée de type caractère.
- La variable C doit être déclarée de type chaîne.
b. L'instruction X ← Aléatoire(6) + 4 permet d'affecter à la variable X une valeur aléatoire de l'intervalle :
- [4, 6]
- [4, 10]
- [4, 9]
c. L'instruction R ← Arrondi(12.5) permet d'affecter à la variable R :
- l'entier 12
- l'entier 13
- le réel 13.0
d. Soit l'affectation C ← Majus(" ?").
- Elle permet d'affecter à la variable C le caractère
"?"en gras. - Elle permet d'affecter à la variable C le caractère
"?". - La variable C doit être de type caractère.
Voir le corrigé
a. C ← Sous_chaîne("Baccalauréat", 4, 1)
| Proposition | Réponse |
|---|---|
Affecte le caractère "c" à C | V |
| C doit être de type caractère | F |
| C doit être de type chaîne | V |
b. X ← Aléatoire(6) + 4 — Aléatoire(6) renvoie un entier de [0, 5], donc X ∈ [4, 9]
| Intervalle | Réponse |
|---|---|
| [4, 6] | F |
| [4, 10] | F |
| [4, 9] | V |
c. R ← Arrondi(12.5)
| Valeur | Réponse |
|---|---|
| L'entier 12 | F |
| L'entier 13 | V |
| Le réel 13.0 | F |
d. C ← Majus(" ?")
| Proposition | Réponse |
|---|---|
"?" en gras | F |
"?" | V |
| C de type caractère | V |
Exercice 2 (2 points)
Soit la partie déclarative suivante d'un programme Pascal :
Program Composer;
Const mot1 = 'informatique'; mot2 = '3D';
Var mot3, mot4 : string; n, m : integer;
En utilisant des fonctions et des procédures prédéfinies, donner les instructions Pascal permettant de réaliser les traitements suivants :
a. À partir de la constante mot1, mettre dans la variable mot3 le terme "format".
b. À partir de mot3 et mot2, mettre dans la variable mot4 le terme "format 3D".
c. Mettre dans n la longueur de la chaîne mot4.
d. À partir de la constante mot2, mettre dans m la valeur 3.
Voir le corrigé
{ a. }
mot3 := copy(mot1, 3, 6);
{ b. }
mot4 := concat(mot3, ' ', mot2);
{ c. }
n := length(mot4);
{ d. }
Val(copy(mot2, 1, 1), m, n);
Exercice 3 (3 points)
Soit le type Examen contenant les valeurs suivantes :
Math, Anglais, Physique et Informatique
-
Qu'appelle-t-on le type Examen décrit ci-dessus ?
-
Proposer une déclaration Pascal du type Examen en respectant l'ordre des valeurs proposé.
-
Compléter le tableau ci-dessous par les types et les valeurs des variables A, B et C après exécution des instructions Pascal suivantes :
A := PRED(Informatique); B := ORD(Anglais) * 8 DIV 4; C := (Math < Physique);Variable Type Valeur A ... ... B ... ... C ... ...
Voir le corrigé
1. Le type Examen est un type scalaire énuméré.
2. Déclaration Pascal :
Type
Examen = (Math, Anglais, Physique, Informatique);
3. Tableau des résultats :
| Variable | Type | Valeur |
|---|---|---|
| A | Examen | Physique |
| B | Tout type numérique (integer) | 2 |
| C | Boolean (booléen) | True |
Explications :
PRED(Informatique)→ le prédécesseur de Informatique dans l'énumération est Physique.ORD(Anglais) = 1, donc1 * 8 DIV 4 = 8 DIV 4 = 2.Matha pour ordinal 0 etPhysiquea pour ordinal 2 :0 < 2est True.
Quiz : variables, constantes et types
6 questions pour vérifier que vous avez bien assimilé les notions clés du chapitre. Cliquez sur "Voir le résultat" après avoir répondu — chaque correction est expliquée.
Quiz (6 questions)
Une **constante** déclarée `Pi = 3.14` peut être modifiée en cours d'exécution.
Parmi ces identificateurs, lesquels sont **valides** en Pascal ?(plusieurs réponses)
Le symbole d'**affectation** est :
Combien d'octets occupe une variable de type `entier` en Pascal (Turbo Pascal classique) ?
Pascal distingue-t-il les majuscules des minuscules dans les identificateurs ?
Après cette séquence, que vaut `x` ? ``` x ← 8 y ← 3 x ← x + y y ← x - y x ← x - y ```