Vous êtes sur la page 1sur 25

Objectif:

• Rappel des concepts de base de l'algorithmique et de la


programmation
Département de Math-Informatique
Année Universitaire 2017-2018 • Mettre en œuvre ces concepts pour analyser des problèmes
simples et écrire les programmes correspondants

Dr Farikou Ousmane Plan:


• Généralités (matériel d’un ordinateur, systèmes d’exploitation, langages
Maître-Assistant CAMES de programmation, …)

• Algorithmique (affectation, instructions conditionnelles, instructions


itératives, fonctions, procédures, …)

• Structure de données (liste simplement chainée, pile, file, ….)

SDD 1 SDD 2

Techniques du traitement automatique de l’information au


moyen des ordinateurs Unité centrale (le boîtier)
• Processeur ou CPU (Central Processing Unit)
Eléments d’un système informatique • Mémoire centrale
• Disque dur, lecteur disquettes, lecteur CD-ROM
Applications • Cartes spécialisées (cartes vidéo, réseau, ...)
(Word, Excel, Jeux, Maple, etc.)
• Interfaces d'entrée-sortie (Ports série/parallèle, …)
Langages
(Java,C/C++, Fortran,etc.)
Système d’exploitation Périphériques
(DOS,Windows, Unix, etc.) • Moniteur (l'écran), clavier, souris
Matériel • Modem, imprimante, scanner, …
(PC, Macintosh, station SUN, etc.)

SDD 3 SDD 4

1
! " # $ $
Ensemble de programmes qui gèrent le matériel et
contrôlent les applications Un langage informatique est un outil permettant de
donner des ordres (instructions) à la machine
• Gestion des périphériques (affichage à l'écran, lecture du
• A chaque instruction correspond une action du processeur
clavier, pilotage d’une imprimante, …)

• Gestion des utilisateurs et de leurs données (comptes, Intérêt : écrire des programmes (suite consécutive
partage des ressources, gestion des fichiers et répertoires, …) d’instructions) déstinés à effectuer une tache donnée
• Interface avec l’utilisateur (textuelle ou graphique): • Exemple: un programme de gestion de comptes bancaires
Interprétation des commandes

• Contrôle des programmes (découpage en taches, partage Contrainte: être compréhensible par la machine
du temps processeur, …)

SDD 5 SDD 6

# $ $ % #&
Problème: le langage machine est difficile à comprendre par l'humain
Langage binaire: l’information est exprimée et manipulée sous
forme d’une suite de bits Idée: trouver un langage compréhensible par l'homme qui sera
ensuite converti en langage machine
Un bit (binary digit) = 0 ou 1 (2 états électriques) • Assembleur (1er langage): exprimer les instructions élémentaires
de façon symbolique
Une combinaison de 8 bits= 1 Octet 28 = 256 possibilités qui permettent
de coder tous les caractères alphabétiques, numériques, et symboles tels que ?,*,&, … ADD A, 4
traducteur langage machine
LOAD B
• Le code ASCII (American Standard Code for Information Interchange) donne les MOV A, OUT
correspondances entre les caractères alphanumériques et leurs
représentation binaire, Ex. A= 01000001, ?=00111111 …
• +: déjà plus accessible que le langage machine
• -: dépend du type de la machine (n’est pas portable)
Les opérations logiques et arithmétiques de base (addition, • -: pas assez efficace pour développer des applications complexes
multiplication, … ) sont effectuées en binaire
Apparition des langages évolués
SDD 7 SDD 8

2
# $ $ % ' (
Compilateur: traduire le programme entier une fois pour toutes
Intérêts multiples pour le haut niveau:
• proche du langage humain «anglais» (compréhensible) exemple.c
Compilateur
exemple
exécution
• permet une plus grande portabilité (indépendant du matériel) fichier source fichier exécutable
• Manipulation de données et d’expressions complexes (réels, • + plus rapide à l’exécution
objets, a*b/c, …) • + sécurité du code source
Nécessité d’un traducteur (compilateur/interpréteur), • - il faut recompiler à chaque modification

exécution plus ou moins lente selon le traducteur Interpréteur: traduire au fur et à mesure les instructions du
programme à chaque exécution
Code source Compilateur ou Interprétation+exécution
Langage machine exemple.bas
en langage évolué fichier source
interpréteur
• + exécution instantanée appréciable pour les débutants
• - exécution lente par rapport à la compilation
SDD 9 SDD 10

# $ $ $ ) $
Enoncé du problème
Deux types de langages: Spécification
• Langages procéduraux Cahier des charges
• Langages orientés objets Analyse
Algorithme
Traduction en langage
Exemples de langages:
Programme source
• Fortran, Cobol, Pascal, C, … Compilation
• C++, Java, … Programme exécutable
Tests et modifications

Choix d’un langage? Version finale et résultats

La réalisation de programmes passe par l’écriture d’algorithmes


D’où l’intérêt de l’Algorithmique

SDD 11 SDD 12

3
*$ % + $ %
Le terme algorithme vient du nom du mathématicien arabe
Al-Khawarizmi (820 après J.C.)
Historiquement, deux façons pour représenter un algorithme:

Un algorithme est une description complète et détaillée des actions à • L’Organigramme: représentation graphique avec des symboles
effectuer et de leur séquencement pour arriver à un résultat donné (carrés, losanges, etc.)
• offre une vue d’ensemble de l’algorithme
• Intérêt: séparation analyse/codage (pas de préoccupation de syntaxe) • représentation quasiment abandonnée aujourd’hui
• Qualités: exact (fournit le résultat souhaité), efficace (temps d’exécution,
mémoire occupée), clair (compréhensible), général (traite le plus grand
nombre de cas possibles), … • Le pseudo-code: représentation textuelle avec une série de
conventions ressemblant à un langage de programmation (sans
L’algorithmique désigne aussi la discipline qui étudie les algorithmes les problèmes de syntaxe)
et leurs applications en Informatique • plus pratique pour écrire un algorithme

Une bonne connaissance de l’algorithmique permet d’écrire des


• représentation largement utilisée
algorithmes exacts et efficaces
SDD 13 SDD 14

, '
*$ % Dans les langages de programmation une variable sert à stocker
la valeur d’une donnée

Une variable désigne en fait un emplacement mémoire dont


le contenu peut changer au cours d’un programme (d’où le nom
variable)

Notions et instructions de base Règle : Les variables doivent être déclarées avant d’être
utilisées, elle doivent être caractérisées par :
• un nom (Identificateur)
• un type (entier, réel, caractère, chaîne de caractères, …)

SDD 15 SDD 16

4
% -./ % -0/
Le choix des noms de variables est soumis à quelques règles qui Conseil: pour la lisibilité du code choisir des noms significatifs
varient selon le langage, mais en général: qui décrivent les données manipulées
Un nom doit commencer par une lettre alphabétique exemples: TotalVentes2004, Prix_TTC, Prix_HT
exemple valide: A1 exemple invalide: 1A

doit être constitué uniquement de lettres, de chiffres et du


soulignement _ (Eviter les caractères de ponctuation et les espaces) Remarque: en pseudo-code algorithmique, on va respecter
valides: SMIP2007, SMP_2007 invalides: SMP 2005,SMI-2007,SMP;2007
les règles citées, même si on est libre dans la
doit être différent des mots réservés du langage (par exemple en syntaxe
Java: int, float, else, switch, case, default, for, main, return, …)

La longueur du nom doit être inférieure à la taille maximale spécifiée


par le langage utilisé

SDD 17 SDD 18

1! ' '
Le type d’une variable détermine l’ensemble des valeurs qu’elle peut Rappel: toute variable utilisée dans un programme doit avoir
prendre, les types offerts par la plus part des langages sont: fait l’objet d’une déclaration préalable
Type numérique (entier ou réel) En pseudo-code, on va adopter la forme suivante pour la
• Byte (codé sur 1octet): de 0 à 255 déclaration de variables
• Entier court (codé sur 2 octets) : -32 768 à 32 767
• Entier long (codé sur 4 ou 8 octets)
Variables liste d'identificateurs : type
• Réel simple précision (codé sur 4 octets) Exemple:
• Réel double précision (codé sur 8 octets) Variables i, j,k : entier
Type logique ou booléen: deux valeurs VRAI ou FAUX x, y : réel
Type caractère: lettres majuscules, minuscules, chiffres, symboles, … OK: booléen
exemples: ’A’, ’a’, ’1’, ’?’, … ch1, ch2 : chaîne de caractères
Type chaîne de caractère: toute suite de caractères,
Remarque: pour le type numérique on va se limiter aux entiers
exemples: " Nom, Prénom", "code postale: 1000", …
et réels sans considérer les sous types
SDD 19 SDD 20

5
#
l’affectation consiste à attribuer une valeur à une variable
(ça consiste en fait à remplir où à modifier le contenu d'une zone mémoire) Beaucoup de langages de programmation (C/C++, Java, …) utilisent
le signe égal = pour l’affectation . Attention aux confusions:
En pseudo-code, l'affectation se note avec le signe
Var e: attribue la valeur de e à la variable Var • l'affectation n'est pas commutative : A=B est différente de B=A
• l'affectation est différente d'une équation mathématique :
- e peut être une valeur, une autre variable ou une expression
- Var et e doivent être de même type ou de types compatibles • A=A+1 a un sens en langages de programmation
- l’affectation ne modifie que ce qui est à gauche de la flèche • A+1=2 n'est pas possible en langages de programmation et n'est
pas équivalente à A=1
Ex valides: i 1 j i k i+j
x 10.3 OK FAUX ch1 "SMI" Certains langages donnent des valeurs par défaut aux variables
ch2 ch1 x 4 x j déclarées. Pour éviter tout problème il est préférable d'initialiser les
variables déclarées
(voir la déclaration des variables dans le transparent précédent)
non valides: i 10.3 OK "SMI" j x
SDD 21 SDD 22

) & -./ ) & -0/


Donnez les valeurs des variables A, B et C après exécution Donnez les valeurs des variables A et B après exécution des
des instructions suivantes ? instructions suivantes ?

Variables A, B, C: Entier Variables A, B : Entier


Début Début
A 3 A 1
B 7 B 2
A B A B
B A
B A+5
Fin
C A+B
C B–A Les deux dernières instructions permettent-elles d’échanger les
Fin valeurs de A et B ?

SDD 23 SDD 24

6
) & -2/ )
Une expression peut être une valeur, une variable ou une
Ecrire un algorithme permettant d’échanger les opération constituée de variables reliées par des opérateurs
valeurs de deux variables A et B exemples: 1, b, a*2, a+ 3*b-c, …

L'évaluation de l'expression fournit une valeur unique qui est le


résultat de l'opération

Les opérateurs dépendent du type de l'opération, ils peuvent être :


• des opérateurs arithmétiques: +, -, *, /, % (modulo), ^ (puissance)
• des opérateurs logiques: NON, OU, ET
• des opérateurs relationnels: =, ≠ , <, >, <=, >=
• des opérateurs sur les chaînes: & (concaténation)

Une expression est évaluée de gauche à droite mais en tenant


compte de priorités
SDD 25 SDD 26

# & 3
-./

Pour les opérateurs arithmétiques donnés ci-dessus, l'ordre de Les instructions de lecture et d'écriture permettent à la machine de
priorité est le suivant (du plus prioritaire au moins prioritaire) : communiquer avec l'utilisateur

La lecture permet d'entrer des donnés à partir du clavier


• ^ : (élévation à la puissance)
• * , / (multiplication, division) • En pseudo-code, on note: lire (var)
• % (modulo)
la machine met la valeur entrée au clavier
• + , - (addition, soustraction)
dans la zone mémoire nommée var
exemple: 2+3*7 vaut 23
• Remarque: Le programme s'arrête lorsqu'il rencontre une
En cas de besoin (ou de doute), on utilise les parenthèses pour instruction Lire et ne se poursuit qu'après la frappe d’une valeur
indiquer les opérations à effectuer en priorité au clavier et de la touche Entrée
exemple: (2 + 3) * 7 vaut 35

SDD 27 SDD 28

7
# & 3
-0/ ) (lecture et écriture)
Ecrire un algorithme qui demande un nombre entier à l'utilisateur, puis
L'écriture permet d'afficher des résultats à l'écran (ou de les écrire qui calcule et affiche le double de ce nombre
dans un fichier)

• En pseudo-code, on note: écrire (var)


Algorithme Calcul_double
la machine affiche le contenu de la variables A, B : entier
zone mémoire var Début
écrire("entrer le nombre ")
• Conseil: Avant de lire une variable, il est fortement conseillé
d’écrire des messages à l’écran, afin de prévenir l’utilisateur de lire(A)
ce qu’il doit frapper B 2*A
écrire("le double de ", A, "est :", B)
Fin
SDD 29 SDD 30

) (lecture et écriture) 1 -./


Les instructions conditionnelles servent à n'exécuter une instruction
Ecrire un algorithme qui vous demande de saisir votre nom puis
ou une séquence d'instructions que si une condition est vérifiée
votre prénom et qui affiche ensuite votre nom complet
On utilisera la forme suivante: Si condition alors
Algorithme AffichageNomComplet instruction ou suite d'instructions1
variables Nom, Prenom, Nom_Complet : chaîne de caractères Sinon
Début instruction ou suite d'instructions2
écrire("entrez votre nom") Finsi
lire(Nom)
• la condition ne peut être que vraie ou fausse
écrire("entrez votre prénom")
lire(Prenom) • si la condition est vraie, se sont les instructions1 qui seront exécutées
Nom_Complet Nom & Prenom • si la condition est fausse, se sont les instructions2 qui seront exécutées
écrire("Votre nom complet est : ", Nom_Complet) • la condition peut être une condition simple ou une condition composée de
Fin plusieurs conditions
SDD 31 SDD 32

8
1 -0/ ) - 4* 4 /
La partie Sinon n'est pas obligatoire, quand elle n'existe pas et que
Algorithme AffichageValeurAbsolue (version1)
la condition est fausse, aucun traitement n'est réalisé
Variable x : réel
• On utilisera dans ce cas la forme simplifiée suivante: Début
Ecrire (" Entrez un réel : “)
Si condition alors Lire (x)
instruction ou suite d'instructions1 Si (x < 0) alors
Finsi Ecrire ("la valeur absolue de ", x, "est:",-x)
Sinon
Ecrire ("la valeur absolue de ", x, "est:",x)
Finsi
Fin

SDD 33 SDD 34

) - 4* / ) (tests)
Ecrire un algorithme qui demande un nombre entier à l'utilisateur,
Algorithme AffichageValeurAbsolue (version2)
puis qui teste et affiche s'il est divisible par 3
Variable x,y : réel
Algorithme Divsible_par3
Début
Ecrire (" Entrez un réel : “) Variable n : entier
Lire (x) Début
Ecrire " Entrez un entier : "
y x
Lire (n)
Si (x < 0) alors
y -x Si (n%3=0) alors
Ecrire (n," est divisible par 3")
Finsi
Ecrire ("la valeur absolue de ", x, "est:",y) Sinon
Ecrire (n," n'est pas divisible par 3")
Fin
Finsi
Fin
SDD 35 SDD 36

9
1 '
Une condition composée est une condition formée de plusieurs C1 C2 C1 ET C2 C1 C2 C1 OU C2
conditions simples reliées par des opérateurs logiques:
VRAI VRAI VRAI VRAI VRAI VRAI
ET, OU, OU exclusif (XOR) et NON
VRAI FAUX FAUX VRAI FAUX VRAI
Exemples : FAUX VRAI FAUX FAUX VRAI VRAI
• x compris entre 2 et 6 : (x > 2) ET (x < 6) FAUX FAUX FAUX FAUX FAUX FAUX

• n divisible par 3 ou par 2 : (n%3=0) OU (n%2=0)


C1 C2 C1 XOR C2 C1 NON C1
• deux valeurs et deux seulement sont identiques parmi a, b et c :
VRAI VRAI FAUX VRAI FAUX
(a=b) XOR (a=c) XOR (b=c)
VRAI FAUX VRAI FAUX VRAI
FAUX VRAI VRAI
L'évaluation d'une condition composée se fait selon des règles
présentées généralement dans ce qu'on appelle tables de vérité FAUX FAUX FAUX

SDD 37 SDD 38

1 1 -' ./
Les tests peuvent avoir un degré quelconque d'imbrications Variable n : entier
Si condition1 alors Début
Ecrire ("entrez un nombre : ")
Si condition2 alors
Lire (n)
instructionsA Si (n < 0) alors
Sinon Ecrire ("Ce nombre est négatif")
instructionsB Sinon
Finsi Si (n = 0) alors
Sinon Ecrire ("Ce nombre est nul")
Si condition3 alors Sinon
instructionsC Ecrire ("Ce nombre est positif")
Finsi Finsi
Finsi
Finsi
Fin
SDD 39 SDD 40

10
1 -' 0/ 1
Variable n : entier
Début Le prix de photocopies dans une reprographie varie selon le
Ecrire ("entrez un nombre : ") nombre demandé: 0,5 DH la copie pour un nombre de copies
Lire (n) inférieur à 10, 0,4DH pour un nombre compris entre 10 et 20 et
Si (n < 0) alors Ecrire ("Ce nombre est négatif") 0,3DH au-delà.
Finsi
Si (n = 0) alors Ecrire ("Ce nombre est nul") Ecrivez un algorithme qui demande à l’utilisateur le nombre de
Finsi photocopies effectuées, qui calcule et affiche le prix à payer
Si (n > 0) alors Ecrire ("Ce nombre est positif")
Finsi
Fin
Remarque : dans la version 2 on fait trois tests systématiquement alors que
dans la version 1, si le nombre est négatif on ne fait qu'un seul test
Conseil : utiliser les tests imbriqués pour limiter le nombre de tests et placer
d'abord les conditions les plus probables
SDD 41 SDD 42

1 $ & '
Variables copies : entier Les boucles servent à répéter l'exécution d'un groupe d'instructions
prix : réel un certain nombre de fois
Début
Ecrire ("Nombre de photocopies : ") On distingue trois sortes de boucles en langages de programmation :
Lire (copies)
Si (copies < 10) Alors • Les boucles tant que : on y répète des instructions tant qu'une certaine
prix copies*0.5 condition est réalisée
Sinon Si (copies) < 20
prix copies*0.4
• Les boucles jusqu'à : on y répète des instructions jusqu'à ce qu'une
certaine condition soit réalisée
Sinon
prix copies*0.3 • Les boucles pour ou avec compteur : on y répète des instructions en
Finsi faisant évoluer un compteur (variable particulière) entre une valeur initiale
Finsi et une valeur finale
Ecrire (“Le prix à payer est : ”, prix)
(Dans ce cours, on va s'intéresser essentiellement aux boucles Tant que et
Fin
boucles Pour qui sont plus utilisées et qui sont définies en Maple)
SDD 43 SDD 44

11
# 1 # 1
Le nombre d'itérations dans une boucle TantQue n'est pas connu
TantQue (condition) au moment d'entrée dans la boucle. Il dépend de l'évolution de la
valeur de condition
instructions condition Vrai instructions

FinTantQue Une des instructions du corps de la boucle doit absolument changer


Faux la valeur de condition de vrai à faux (après un certain nombre
d'itérations), sinon le programme tourne indéfiniment

la condition (dite condition de contrôle de la boucle) est évaluée avant chaque Attention aux boucles infinies
itération
Exemple de boucle infinie :
si la condition est vraie, on exécute instructions (corps de la boucle), puis, on i 2
retourne tester la condition. Si elle est encore vraie, on répète l'exécution, … TantQue (i > 0)
si la condition est fausse, on sort de la boucle et on exécute l'instruction qui i i+1 (attention aux erreurs de frappe : + au lieu de -)
est après FinTantQue FinTantQue
SDD 45 SDD 46

5 1 . 5 1 0
Contrôle de saisie d'une lettre majuscule jusqu’à ce que le caractère Un algorithme qui détermine le premier nombre entier N tel que la
entré soit valable somme de 1 à N dépasse strictement 100

version 1
Variable C : caractère Variables som, i : entier
Debut Debut
Ecrire (" Entrez une lettre majuscule ") i 0
Lire (C) som 0
TantQue (C < 'A' ou C > 'Z') TantQue (som <=100)
Ecrire ("Saisie erronée. Recommencez") i i+1
Lire (C) som som+i
FinTantQue FinTantQue
Ecrire ("Saisie valable") Ecrire (" La valeur cherchée est N= ", i)
Fin Fin

SDD 47 SDD 48

12
5 1 0 (version2) #
Un algorithme qui détermine le premier nombre entier N tel que la
somme de 1 à N dépasse strictement 100 Pour compteur allant de initiale à finale par pas valeur du pas

version 2: attention à l'ordre des instructions et aux valeurs initiales instructions


Variables som, i : entier FinPour
Debut
som 0 i initiale
i 1
TantQue (som <=100)
som som + i
Vrai
i i+1 i n'a pas atteint finale instructions i i + pas
FinTantQue
Ecrire (" La valeur cherchée est N= ", i-1) Faux
Fin
SDD 49 SDD 50

#
Remarque : le nombre d'itérations dans une boucle Pour est connu 1) La valeur initiale est affectée à la variable compteur
avant le début de la boucle
2) On compare la valeur du compteur et la valeur de finale :

Compteur est une variable de type entier (ou caractère). Elle doit a) Si la valeur du compteur est > à la valeur finale dans le cas d'un pas
être déclarée positif (ou si compteur est < à finale pour un pas négatif), on sort de la
boucle et on continue avec l'instruction qui suit FinPour

Pas est un entier qui peut être positif ou négatif. Pas peut ne pas b) Si compteur est <= à finale dans le cas d'un pas positif (ou si compteur
être mentionné, car par défaut sa valeur est égal à 1. Dans ce cas, le est >= à finale pour un pas négatif), instructions seront exécutées
nombre d'itérations est égal à finale - initiale+ 1 i. Ensuite, la valeur de compteur est incrémentée de la valeur du pas
si pas est positif (ou décrémenté si pas est négatif)
Initiale et finale peuvent être des valeurs, des variables définies ii. On recommence l'étape 2 : La comparaison entre compteur et
avant le début de la boucle ou des expressions de même type que finale est de nouveau effectuée, et ainsi de suite …
compteur

SDD 51 SDD 52

13
5 . 5 . (version 2)
Calcul de x à la puissance n où x est un réel non nul et n un Calcul de x à la puissance n où x est un réel non nul et n un entier
entier positif ou nul positif ou nul (version 2 avec un pas négatif)
Variables x, puiss : réel
Variables x, puiss : réel
n, i : entier
Debut n, i : entier
Ecrire (" Entrez la valeur de x ") Debut
Lire (x) Ecrire (" Entrez respectivement les valeurs de x et n ")
Ecrire (" Entrez la valeur de n ")
Lire (n) Lire (x, n)
puiss 1
puiss 1 Pour i allant de n à 1 par pas -1
Pour i allant de 1 à n
puiss puiss*x puiss puiss*x
FinPour FinPour
Ecrire (x, " à la puissance ", n, " est égal à ", puiss) Ecrire (x, " à la puissance ", n, " est égal à ", puiss)
Fin
Fin
SDD 53 SDD 54

5 # 1
Il faut éviter de modifier la valeur du compteur (et de finale) à La boucle Pour est un cas particulier de Tant Que (cas où le nombre
l'intérieur de la boucle. En effet, une telle action : d'itérations est connu et fixé) . Tout ce qu'on peut écrire avec Pour peut être
remplacé avec TantQue (la réciproque est fausse)
• perturbe le nombre d'itérations prévu par la boucle Pour
• rend difficile la lecture de l'algorithme Pour compteur allant de initiale à finale par pas valeur du pas
• présente le risque d'aboutir à une boucle infinie instructions
Exemple : Pour i allant de 1 à 5 FinPour
i i -1 peut être remplacé par : compteur initiale
écrire(" i = ", i)
Finpour
(cas d'un pas positif) TantQue compteur <= finale
instructions
compteur compteur+pas
FinTantQue

SDD 55 SDD 56

14
# 1 5
Calcul de x à la puissance n où x est un réel non nul et n un entier positif ou
nul (version avec TantQue) Les instructions d'une boucle peuvent être des instructions
Variables x, puiss : réel
itératives. Dans ce cas, on aboutit à des boucles imbriquées
n, i : entier
Debut Exemple: Exécution
Ecrire (" Entrez la valeur de x ")
Lire (x) Pour i allant de 1 à 5 OX
Ecrire (" Entrez la valeur de n ")
Lire (n)
Pour j allant de 1 à i OOX
écrire("O") OOOX
puiss 1
i 1 FinPour OOOOX
TantQue (i<=n) écrire("X") OOOOOX
puiss puiss*x
i i+1 FinPour
FinTantQue
Ecrire (x, " à la puissance ", n, " est égal à ", puiss)
Fin

SDD 57 SDD 58

# + 4 64 5 + 6
Un algorithme qui détermine le premier nombre entier N tel que la somme de 1
Répéter à N dépasse strictement 100 (version avec répéter jusqu'à)

instructions instructions
Variables som, i : entier
Jusqu'à condition Debut
Faux som 0
condition
i 0
Répéter
Vrai
i i+1
Condition est évaluée après chaque itération som som+i
les instructions entre Répéter et jusqu’à sont exécutées au moins une fois et
Jusqu'à ( som > 100)
leur exécution est répétée jusqu’à ce que condition soit vrai (tant qu'elle est Ecrire (" La valeur cherchée est N= ", i)
fausse) Fin

SDD 59 SDD 60

15
% & !
Si on peut déterminer le nombre d'itérations avant l'exécution de la
boucle, il est plus naturel d'utiliser la boucle Pour
*#7 + 18 9)
S'il n'est pas possible de connaître le nombre d'itérations avant
l'exécution de la boucle, on fera appel à l'une des boucles TantQue
ou répéter jusqu'à

Pour le choix entre TantQue et jusqu'à :

• Si on doit tester la condition de contrôle avant de commencer les


Fonctions et procédures
instructions de la boucle, on utilisera TantQue

• Si la valeur de la condition de contrôle dépend d'une première


exécution des instructions de la boucle, on utilisera répéter jusqu'à

SDD 61 SDD 62

: :
Certains problèmes conduisent à des programmes longs, difficiles à Le rôle d'une fonction en programmation est similaire à celui d'une
écrire et à comprendre. On les découpe en des parties appelées fonction en mathématique : elle retourne un résultat à partir des
sous-programmes ou modules valeurs des paramètres

Les fonctions et les procédures sont des modules (groupe d'instructions) Une fonction s'écrit en dehors du programme principal sous la forme :
indépendants désignés par un nom. Elles ont plusieurs intérêts : Fonction nom_fonction (paramètres et leurs types) : type_fonction
• permettent de "factoriser" les programmes, càd de mettre en commun
Instructions constituant le corps de la fonction
les parties qui se répètent
retourne …
• permettent une structuration et une meilleure lisibilité des programmes FinFonction
• facilitent la maintenance du code (il suffit de modifier une seule fois) Pour le choix d'un nom de fonction il faut respecter les mêmes règles que celles
pour les noms de variables
• ces procédures et fonctions peuvent éventuellement être réutilisées dans
d'autres programmes type_fonction est le type du résultat retourné
L'instruction retourne sert à retourner la valeur du résultat
SDD 63 SDD 64

16
: 9
La fonction SommeCarre suivante calcule la somme des carrées de L'utilisation d'une fonction se fera par simple écriture de son nom
deux réels x et y : dans le programme principale. Le résultat étant une valeur, devra
être affecté ou être utilisé dans une expression, une écriture, ...
Fonction SommeCarre (x : réel, y: réel ) : réel
variable z : réel Exepmle : Algorithme exepmleAppelFonction
z x^2+y^2 variables z : réel, b : booléen
retourne (z) Début
FinFonction b Pair(3)
z 5*SommeCarre(7,2)+1
La fonction Pair suivante détermine si un nombre est pair : écrire("SommeCarre(3,5)= ", SommeCarre(3,5))
Fin
Fonction Pair (n : entier ) : booléen
retourne (n%2=0) Lors de l'appel Pair(3) le paramètre formel n est remplacé par le
FinFonction paramètre effectif 3
SDD 65 SDD 66

" * &
Dans certains cas, on peut avoir besoin de répéter une tache dans plusieurs L'appel d'une procédure, se fait dans le programme principale ou dans une
endroits du programme, mais que dans cette tache on ne calcule pas de autre procédure par une instruction indiquant le nom de la procédure :
résultats ou qu'on calcule plusieurs résultats à la fois
Procédure exemple_proc (…)
Dans ces cas on ne peut pas utiliser une fonction, on utilise une procédure …
FinProcédure
Une procédure est un sous-programme semblable à une fonction mais qui
ne retourne rien Algorithme exepmleAppelProcédure
Une procédure s'écrit en dehors du programme principal sous la forme : Début
exemple_proc (…)
Procédure nom_procédure (paramètres et leurs types) …
Fin
Instructions constituant le corps de la procédure
Remarque : contrairement à l'appel d'une fonction, on ne peut pas affecter la
FinProcédure procédure appelée ou l'utiliser dans une expression. L'appel d'une
Remarque : une procédure peut ne pas avoir de paramètres procédure est une instruction autonome

SDD 67 SDD 68

17
" & 1 "
Les paramètres servent à échanger des données entre le programme Il existe deux modes de transmission de paramètres dans les langages de
principale (ou la procédure appelante) et la procédure appelée programmation :

La transmission par valeur : les valeurs des paramètres effectifs sont


Les paramètres placés dans la déclaration d'une procédure sont appelés affectées aux paramètres formels correspondants au moment de l'appel de la
paramètres formels. Ces paramètres peuvent prendre toutes les valeurs procédure. Dans ce mode le paramètre effectif ne subit aucune modification
possibles mais ils sont abstraits (n'existent pas réellement)
La transmission par adresse (ou par référence) : les adresses des
Les paramètres placés dans l'appel d'une procédure sont appelés paramètres effectifs sont transmises à la procédure appelante. Dans ce
paramètres effectifs. ils contiennent les valeurs pour effectuer le mode, le paramètre effectif subit les mêmes modifications que le paramètre
traitement formel lors de l'exécution de la procédure

• Remarque : le paramètre effectif doit être une variable (et non une
Le nombre de paramètres effectifs doit être égal au nombre de paramètres valeur) lorsqu'il s'agit d'une transmission par adresse
formels. L'ordre et le type des paramètres doivent correspondre
En pseudo-code, on va préciser explicitement le mode de transmission dans
la déclaration de la procédure
SDD 69 SDD 70

1 " 1 ' ;
Procédure incrementer1 (x : entier par valeur, y : entier par adresse) Procédure qui calcule la somme et le produit de deux entiers :
x x+1 Procédure SommeProduit (x,y: entier par valeur, som, prod : entier par adresse)
y y+1 som x+y
FinProcédure prod x*y
Algorithme Test_incrementer1 FinProcédure
variables n, m : entier
Début Procédure qui échange le contenu de deux variabales :
n 3 Procédure Echange (x : réel par adresse, y : réel par adresse)
m 3 variables z : réel
incrementer1(n, m) résultat : z x
écrire (" n= ", n, " et m= ", m) n=3 et m=4 x y
Fin y z
FinProcédure
Remarque : l'instruction x x+1 n'a pas de sens avec un passage par valeur
SDD 71 SDD 72

18
< $ -./ < $ -0/
On peut manipuler 2 types de variables dans un module (procédure ou La manière de distinguer la déclaration des variables locales et globales
fonction) : des variables locales et des variables globales. Elles se diffère selon le langage
distinguent par ce qu'on appelle leur portée (leur "champ de définition", leur
"durée de vie") • En général, les variables déclarées à l'intérieur d'une fonction ou
procédure sont considérées comme variables locales
Une variable locale n'est connue qu'à l'intérieur du module ou elle a été
définie. Elle est créée à l'appel du module et détruite à la fin de son exécution • En pseudo-code, on va adopter cette règle pour les variables locales et on
déclarera les variables globales dans le programme principale
Une variable globale est connue par l'ensemble des modules et le
programme principale. Elle est définie durant toute l’application et peut être • Conseil : Il faut utiliser autant que possible des variables locales plutôt que
utilisée et modifiée par les différents modules du programme des variables globales. Ceci permet d'économiser la mémoire et d'assurer
l'indépendance de la procédure ou de la fonction

SDD 73 SDD 74

)
*#7 + 18 9) Supposons qu'on veut conserver les notes d'une classe de 30 étudiants
pour extraire quelques informations. Par exemple : calcul du nombre
d'étudiants ayant une note supérieure à 10

Le seul moyen dont nous disposons actuellement consiste à déclarer 30


variables, par exemple N1, …, N30. Après 30 instructions lire, on doit écrire
30 instructions Si pour faire le calcul
nbre 0
Si (N1 >10) alors nbre nbre+1 FinSi
Les tableaux ….
Si (N30>10) alors nbre nbre+1 FinSi
c'est lourd à écrire
Heureusement, les langages de programmation offrent la possibilité de
rassembler toutes ces variables dans une seule structure de donnée
appelée tableau
SDD 75 SDD 76

19
1 1
Un tableau est un ensemble d'éléments de même type désignés L'accès à un élément du tableau se fait au moyen de l'indice. Par exemple,
par un identificateur unique notes[i] donne la valeur de l'élément i du tableau notes

Une variable entière nommée indice permet d'indiquer la position Selon les langages, le premier indice du tableau est soit 0, soit 1. Le plus
souvent c'est 0 (c'est ce qu'on va adopter en pseudo-code). Dans ce cas,
d'un élément donné au sein du tableau et de déterminer sa valeur
notes[i] désigne l'élément i+1 du tableau notes
La déclaration d'un tableau s'effectue en précisant le type de ses Il est possible de déclarer un tableau sans préciser au départ sa dimension.
éléments et sa dimension (le nombre de ses éléments) Cette précision est faite ultérieurement .

• En pseudo code :
• Par exemple, quand on déclare un tableau comme paramètre d'une procédure,
variable tableau identificateur[dimension] : type on peut ne préciser sa dimension qu'au moment de l'appel
• Exemple :
• En tous cas, un tableau est inutilisable tant qu’on n’a pas précisé le nombre de
variable tableau notes[30] : réel ses éléments

On peut définir des tableaux de tous types : tableaux d'entiers, de Un grand avantage des tableaux est qu'on peut traiter les données qui y
réels, de caractères, de booléens, de chaînes de caractères, … sont stockées de façon simple en utilisant des boucles
SDD 77 SDD 78

1 -./ 1 % $
Pour le calcul du nombre d'étudiants ayant une note supérieure à Procédures qui permettent de saisir et d'afficher les éléments d'un tableau :
10 avec les tableaux, on peut écrire : Procédure SaisieTab(n : entier par valeur, tableau T : réel par référence )
variable i: entier
Variables i ,nbre : entier Pour i allant de 0 à n-1
tableau notes[30] : réel écrire ("Saisie de l'élément ", i + 1)
Début lire (T[i] )
nbre 0 FinPour
Pour i allant de 0 à 29 Fin Procédure
Si (notes[i] >10) alors
Procédure AfficheTab(n : entier par valeur, tableau T : réel par valeur )
nbre nbre+1
variable i: entier
FinSi
Pour i allant de 0 à n-1
FinPour écrire ("T[",i, "] =", T[i])
écrire ("le nombre de notes supérieures à 10 est : ", nbre) FinPour
Fin Fin Procédure
SDD 79 SDD 80

20
1 & 1 $
Algorithme principale où on fait l'appel des procédures SaisieTab et La plus part des langages offrent une fonction longueur qui donne la dimension
AfficheTab : du tableau. Les procédures Saisie et Affiche peuvent être réécrites comme suit :
Procédure SaisieTab( tableau T : réel par référence )
variable i: entier
Algorithme Tableaux
Pour i allant de 0 à longueur(T)-1
variable p : entier écrire ("Saisie de l'élément ", i + 1)
tableau A[10] : réel lire (T[i] )
Début FinPour
p 10 Fin Procédure
SaisieTab(p, A) Procédure AfficheTab(tableau T : réel par valeur )
variable i: entier
AfficheTab(10,A)
Pour i allant de 0 à longueur(T)-1
Fin écrire ("T[",i, "] =", T[i])
FinPour
Fin Procédure
SDD 81 SDD 82

1 6 ) &
Les langages de programmation permettent de déclarer des Procédure qui permet de saisir les éléments d'une matrice :
tableaux dans lesquels les valeurs sont repérées par deux indices.
Procédure SaisieMatrice(n : entier par valeur, m : entier par valeur ,
Ceci est utile par exemple pour représenter des matrices
tableau A : réel par référence )
Début
En pseudo code, un tableau à deux dimensions se déclare ainsi : variables i,j : entier
variable tableau identificateur[dimension1] [dimension2] : type Pour i allant de 0 à n-1
écrire ("saisie de la ligne ", i + 1)
• Exemple : une matrice A de 3 lignes et 4 colonnes dont les éléments Pour j allant de 0 à m-1
sont réels écrire ("Entrez l'élément de la ligne ", i + 1, " et de la colonne ", j+1)
lire (A[i][j])
variable tableau A[3][4] : réel
FinPour
FinPour
A[i][j] permet d'accéder à l’élément de la matrice qui se trouve à
l’intersection de la ligne i et de la colonne j Fin Procédure

SDD 83 SDD 84

21
) % $ & )
Procédure qui permet d'afficher les éléments d'une matrice : Procédure qui calcule la somme de deux matrices :

Procédure AfficheMatrice(n : entier par valeur, m : entier par valeur Procédure SommeMatrices(n, m : entier par valeur,
,tableau A : réel par tableau A, B : réel par valeur , tableau C : réel par référence )
valeur ) Début
Début variables i,j : entier
variables i,j : entier Pour i allant de 0 à n-1
Pour i allant de 0 à n-1 Pour j allant de 0 à m-1
Pour j allant de 0 à m-1 C[i][j] A[i][j]+B[i][j]
écrire ("A[",i, "] [",j,"]=", A[i][j]) FinPour
FinPour FinPour
FinPour Fin Procédure
Fin Procédure

SDD 85 SDD 86

# !
*
$
Exemple d'algorithme principale où on fait l'appel des procédures définies
précédemment pour la saisie, l'affichage et la somme des matrices :

Algorithme Matrices
variables tableau M1[3][4],M2 [3][4],M3 [3][4] : réel
Début
SaisieMatrice(3, 4, M1)
SaisieMatrice(3, 4, M2)
AfficheMatrice(3,4, M1)
AfficheMatrice(3,4, M2)
SommeMatrice(3, 4, M1,M2,M3)
AfficheMatrice(3,4, M3)
Fin
SDD 87

22
& !

= & $ = &
6 & ! $

23
5= $
% &

=9 %

24
=# & $
- /

9 %

25

Vous aimerez peut-être aussi