1ere Chapitre1 - Rappel Algo Diapos v1.7

Académie militaire - Fondouk Jedid
Cycle préparatoire - Bouficha
Module : Informatique
Classes: 1ères Années
Chapitre 1:
RAPPEL DES NOTIONS
ALGORITHMIQUES
Enseignant : Dr. Khemaies GHALI (ghali.khemaies@gmail.com)
Année universitaire 2019/2020

Plan
1. Notion d’algorithme
2. Opérations élémentaires : Affectation, Entrée/Sortie
3. Structures conditionnelles
4. Structures itératives
5. Création et manipulation des tableaux
6. Notion de coût d'un algorithme et classes de

complexité
A.U. 2019/2020 1ère Année Académie Militaire – Informatique – Chapitre 1 2/110

1ère Partie:
NOTION
D’ALGORITHME

Définition et Propriétés d’un
Algorithme (1/2)
Un algorithme est une description des étapes de la résolution d’un
problème selon une syntaxe;
c’est donc la description logique d’un procédé.
Le point de départ de l’élaboration d’un algorithme est d’identifier les :
1. résultats à obtenir,
2. les données en entrée et
3. les moyens pour obtenir les résultats recherchés à partir des

données.
A un problème donné, peut correspondre plusieurs algorithmes.
Un algorithme exécute un ordonnancement d’un ensemble fini d’actions

sur des données concrètes pour obtenir un ou plusieurs résultats.

Définition et Propriétés d’un
algorithme (2/2)
Tout algorithme possède:
1. une entête,
2. une partie déclarative (optionnelle),
3. et un corps regroupant l’ensemble des actions à exécuter.
Le corps de chaque algorithme comporte les trois parties suivantes :
1. La préparation des données nécessaires à la résolution du

problème et la vérification de leur cohérence si nécessaire.
2. Le traitement : définir les actions à effectuer ainsi que leur

enchaînement pour résoudre le problème.
3. La restitution du (ou des) résultat(s) à l’utilisateur.

Structure d’un Algorithme (1/2)
ALGORITHME nom_Algo
entête
CONSTANTE nom_Constante = Valeur de la constante
Déclaration des objets/actions définies
TYPE nom_Type = Définition du type

{Cette partie est utile lorsqu’il y a des
types définis par l’utilisateur}
VARIABLE nom_Var1 : type1
(optionnelle)
nom_Var2, ..., nom_Varp : type2

{type1 ou type2 peuvent êtres des
types élémentaires ou définis}
PROCEDURE ... FONCTION ...

{Cette partie sera traitée au chapitre 4}
DEBUT
corps Séquence d’instructions (*)
FIN
Structure d’un Algorithme (2/2)
DEBUT
Opérations de lecture
Opérations élémentaires
Séquence d’instructions
Opérations d’affectation
Opérations d’écriture
Structures Conditionnelles
Structures répétitives/itératives
Appels à des modules

(procédures et fonctions)
FIN
Algorithme : Les déclarations
Toute information manipulée doit faire l'objet d’une déclaration
préalable sauf si cette information est prédéfinie.
La déclaration est constituée essentiellement de deux grandes

parties dont l'ordre doit être respecté :
1. La déclaration des objets (ou entités) manipulés :
Les objets élémentaires,
Les objets structurés définis par l’utilisateur.
2. La déclaration des actions définies par l’utilisateur
REMARQUE : Les actions ou les instructions élémentaires (prédéfinis

par les langages de programmation) ne doivent pas être déclarées.

Algorithme : Les Objets
Les entités ou encore les objets manipulés peuvent être :
Simples (objets élémentaires)
Complexes (objets structurés) construits à partir des objets

élémentaires et définis par l’utilisateur.
Exemple : les intervalles, les enregistrements, les tableaux,

les ensembles, les listes, etc. (à voir plus tard)
Tout objet élémentaire doit être bien spécifié et caractérisé par :

• un identificateur
spécifiés lors de la déclaration
• un type
• une valeur spécifiée lors de :
- l’exécution si l’objet est variable.
- la déclaration si l’objet est fixe.
Objets Elémentaires(1/2)
Un identificateur est un nom désignant l’objet et qui doit être
unique dans l’algorithme et invariant et ne doit :
être formé que de lettres et/ou de chiffres non séparée par un

espace mais pouvant être attachées par « _ » et commençant
impérativement par une lettre,
pas comporter de caractères spéciaux (+,*,/,(,à,…),
pas être un mot réservé (Algorithme, début, fin, SI,…).
Le type est la nature de l’objet qui représente:
le domaine de définition dans lequel l’objet prend ses valeurs
ainsi que les opérations de base qui lui sont appliquées.

Objets Elémentaires(2/2)
Le type simple ou scalaire représente le type prédéfini par
la majorité des langages de programmation sur machine et
qui regroupe :
le type entier (entiers relatifs), le type réel, le type

booléen et le type caractère.
La valeur est une instance quelconque de l’ensemble de

définition décrit par le type:
Lorsque la valeur de l’objet dans l’algorithme ne change pas

d’une exécution à l’autre on parle alors de constante (Exp.
Pi=3.14).
Lorsque la valeur de l’objet change au cours de l’algorithme

ou d’une exécution à l’autre on parle alors de variable.

2ème Partie:
OPÉRATIONS
ÉLÉMENTAIRES

Opérations Elémentaires: Affectation (1/2)
On rappelle qu’un algorithme exécute un ordonnancement fini

d’actions sur des données concrètes pour obtenir un ou
plusieurs résultats.
Parmi ces opérations, on trouve les opérations élémentaires

d’affectation, de lecture et d’écriture.
L’opération élémentaire d’affectation attribue une valeur à une

variable, qu’il s’agisse d’une première valeur ou d’une valeur
calculée au cours de l’exécution de l’algorithme.
Elle fait appel à la notation « ← ». L’opération s’écrit comme

suit :
Identificateur_var ← valeur

Opérations Elémentaires: Affectation (2/2)
Une variable ne peut avoir qu’une seule valeur à un instant
donné et qui doit être compatible avec son type.
La valeur précédente (si elle existe) est écrasée par la
nouvelle valeur.
La valeur attribuée à un objet peut être:
une valeur particulière.
Exemple : A ← 5 X ← ‘b’
une valeur contenue dans une autre variable.
Exemple : A ← 5 B←2 A←B
une valeur numérique calculée par l’évaluation d’une
expression (pouvant être une expression de cumul).
Le résultat d’une fonction.

Opérations Elémentaires:
Lecture/Ecriture (1/2)
L’instruction de base permettant à la machine de récupérer (ou

lire) les valeurs introduites au clavier est l’opération de lecture
des données dont le format est :
Lire (ind_variable1,..., ind_variableN)

Ou
Lire (ind_variable1),..., Lire(ind_variableN) ...
Exemples:
Lire(A, B)
Ou
Lire(A), Lire(B)

Opérations Elémentaires:
Lecture/Ecriture (2/2)
Le format général de l’opération élémentaire de sortie ou

d’affichage est :
Ecrire(expression1, …, expressionN)
avec une expression soit :
• un nom de variable
• une chaîne de caractères
Exemple :
Ecrire(‘la surface du rectangle est = ‘, S)

Exemple (1/2)
ALGORITHME Circ_Surface_Cercle
CONSTANTE Pi=3.14
VARIABLE R, Circ_Cercle, Surf_Cercle :réel
DEBUT
Ecrire(‘donner le rayon du cercle R:’)
Lire(R)
Surf_Cercle ← R * R * Pi {ou R^2 * Pi}
Circ_Cercle ← 2*Pi*R
Ecrire(‘la circonférence et la surface du
cercle de rayon’, R, ‘sont respectivement
égales à ‘, Circ_Cercle, ‘, ‘, Surf_Cercle)
FIN
Exemple (2/2): Erreurs à ne pas faire
CONSTANTE Pi = 3.14
VARIABLE R, Circ_Cercle, Surf_Cercle :réel
DEBUT
Ecrire(‘donner le rayon du cercle’, R)
Lire(R)
Surf_Cercle ← R * R * Pi
Circ_Cercle = 2*Pi*R
Ecrire(‘la circonférence et la surface du
cercle de rayon R sont respectivement égales
à ‘, Circ_Cercle, ‘, ‘, Surf_Cercle)
Lire(Surf_Cercle)
FIN
Traduction en Python
Opéra-
Algorithmique Python Exemples
tions
[>from math import factoriel
Affect- Var ← valeur L’opérateur est : « = » [> e = factorial(5)
ation [>var = valeurs [>e
120
LIRE(var1) [>var1 = input() [>nom = input()
LIRE(var2) [>var2 = input() [>annee = int(input())
[>var = input(" texte ") [>poids = float(input())
Entrée
Ou [>NM = input(" Donner
ECRIRE(" texte ") [> print(" texte ") valeur de NM: ")
LIRE(var) [>var = input()
ECRIRE("texte", [> print("la note de maths est

Sortie [> print("texte", var)
égale à ", NM)
var,…)

Exemple1 en Python
Version 1:
from math import pi
R = float(input("entrer la valeur du rayon"))
C = 2 * pi * R
S = pi * R ** 2
print("le périmètre du cercle de rayon", R,
"est ", C, "et la surface du même cercle est ", S)
Version 2:
from math import *
print("entrer la valeur du rayon")
R = float(input())
C = 2 * pi * R
S = pi * R * R
print("le périmètre du cercle de rayon", R,
"est ", C, "et la surface du même cercle est ", S)

3ème Partie :
STRUCTURES
CONDITIONNELLES

Définition et Structure (1/2)
Lorsque l’exécution d’un traitement est conditionné c.-à-d.
s’exécute selon l’évaluation d’une condition,
les instructions séquentielles sont inadéquates => utiliser des
structures conditionnelles.
La structure conditionnelle exprime la possibilité de choisir entre
deux alternatives selon la valeur de l’évaluation d’une condition.
Dans ce cas, la condition doit être booléenne donc formulée de
telle sorte à n’offrir que deux réponses :
oui, si la condition est remplie (vérifiée),
non, si la condition n’est pas remplie.
non Test oui
?
Traitement1 Traitement2

Définition et Structure (2/2)
A chacune des deux réponses peut correspondre une ou plusieurs
instructions pouvant être (1) des instructions de base, (2) des
structures de contrôle ou (3) des appels à des « Actions ».
Remarque: A l’une des alternatives peut ne correspondre
aucun traitement!
Le format général d’une structure conditionnelle s’exprime comme
suit :
oui
SI condition ALORS instructions1

SINON instructions 2
FINSI
non Optionnelle

Exemple : Calcul de surface OU de circonférence d’un
cercle (version1)
ALGORITHME Circ_Surface_Cercle //Version recommandée dans ce cas

CONSTANTE Pi=3.14
VARIABLE R, Circ_Cercle, Surf_Cercle :réel choix : caractère
DEBUT
Ecrire("donner le rayon du cercle") Lire(R)
Ecrire("donner votre choix") Lire(choix)
{on suppose qu’il n’y a pas d’erreurs de saisie c.à.d que choix = ‘S’ pour
surface et choix = ‘C’ pour circonférence}
Si choix =‘S’ ou choix =‘s’ ALORS
SINON {choix ici est forcément égal à ‘C’ ou ‘c’}
FINSI

Ecrire("la surface du cercle de rayon", R, "est = ", Surf_Cercle)
SINON {choix ici est forcément égal à ‘C’ ou ‘c’}
Ecrire("la circonf. du cercle de rayon", R, "est = ", Circ_Cercle)
FINSI
FIN
Exemple : Calcul de surface OU de circonférence
d’un cercle avec des « Si » séquentiels (version2)
CONSTANTE Pi = 3.14
DEBUT
Début
Fin
FINSI
Si choix =‘C’ ou choix =‘c’ ALORS
Début
Ecrire(« Circonférence du cercle de rayon", R, "est =",Circ_Cercle)
Fin
FINSI
FIN
NB: ici on regroupe chaque type de traitement avec leur affichage du
résultat

Exemple : Calcul de surface OU de
circonférence d’un cercle avec des « Si »
séquentiels (version3)
ALGORITHME Circ_Surface_Cercle //Version non recommandée dans ce cas
CONSTANTE Pi=3.14
DEBUT
SI choix =‘S’ ou choix =‘s’ ALORS Surf_Cercle ← R * R * Pi FINSI
SI choix =‘C’ ou choix =‘c’ ALORS Circ_Cercle ← 2*Pi*R FINSI
SI choix =‘S’ ou choix =‘s’ ALORS
FINSI
SI choix =‘C’ ou choix =‘c’ ALORS
Ecrire("la circonf. du cercle de rayon", R, "est = ", Circ_Cercle)
FINSI
FIN
N.B.: Cette solution est moins conseillée car la machine effectue un test
inutile => dans ce cas les versions 1 et 2 sont meilleures.

La condition (1/2)
La condition de l’alternative est soit simple soit complexe :
– La condition simple: utilise des opérateurs relationnels (tels
que. X>Y ; X<Y ; X>=Y ; X<=Y ; X=Y ; X ≠Y) ou des
verbes logiques (tels que existe=Vrai, NON(existe), … où «
existe » est une variable booléenne).
– La condition complexe: combine plusieurs conditions
simples à l’aide des opérations logiques ET, OU et NON :
• Si (condition1 ET condition2) => vraie lorsque les deux
conditions sont vraies simultanément;
Exemple : (X>5) ET (X<=10)
• Si (condition1 OU condition2) => vraie lorsque l’une
des deux conditions est vraie;
Exemple : (X>=5) OU (X<1)
La condition (2/2)
• Si NON (condition1) => vraie lorsque la condition1
n’est pas vraie.
Exemple : NON(X>5) → X<=5
Il est possible qu’une condition complexe combine d’autres

conditions complexes à l’aide des opérateurs ET, OU et NON.
Exemples :
• ((X>5) ET (X<10)) OU (NON(X>=5) ET (X>0))
• (le feu est rouge) ET (le passage est fermé)

L’Instruction
Instruction
Appels à des
Vide Actions
(Voir chapitre4)
Elémentaire
Structures
Répétitives/Itératives
Bloc Cas4 (Voir chapitre suivant)
D’opérations
Structures
Conditionnelles

L’Instruction (cas 1)
Cas1 : Absence de traitement correspondant à l’une des deux
alternatives :
Absence de traitement associée à la réponse NON:
SI condition ALORS
instructions1
FINSI
Absence de traitement associée à la réponse OUI => dans
ce cas prendre la négation de la condition:
SI NON(condition) ALORS
instructions2
FINSI

L’Instruction (cas1)
Exemple : Algorithme qui Calcule la somme des inverses de X
et Y:
ALGORITHME CalculSomInverseXY
VARIABLE X,Y: entier SomI: réel
DEBUT
Ecrire("donner deux entiers")
Lire(X) Lire(Y)
SI X≠0 ET Y≠0 ALORS SomI ← 1/X +1/Y FINSI
Si X≠0 et Y≠0 ALORS
Ecrire("la somme des inverses de ", X, "et", Y,
"est égale à ", SomI)
SINON
Ecrire("impossible de calculer la somme des
inverses de ", X, " et ", Y)
FINSI
FIN

L’Instruction (cas2 et cas3)
Cas2 : les instructions 1 et 2 sont simples.
Séquence d’un algorithme Séquence d’un algorithme
calculant le Sup: affichant le Sup:
SI X>Y ALORS Sup←X SI X>Y ALORS Ecrire("le sup est", X)
SINON Sup←Y SINON Ecrire("le sup est", Y)
FINSI FINSI
Cas3 : Bloc d’instructions encadré par DEBUT et FIN.

SI X>Y ALORS
Début
Sup ←X Inf ←Y
Fin
SINON
Début
Sup ←Y Inf ←X
Fin
FINSI

L’Instruction (cas4)
Cas4: Structure conditionnelle imbriquée ou emboîtée.
SI condition1 ALORS
SI condition2 ALORS
Instruction_c1_c2
SINON
Instruction_c1_non(c2)
FINSI
SINON
SI condition3 ALORS
Instruction_non(c1)_c3
SINON
Instruction_non(c1)_non(c3)
FINSI
FINSI

Équivalence en structures
séquentielles du cas 4
SI condition1 et condition2
ALORS Instruction_c1_c2 N.B: Dans ce cas, la version
FINSI imbriquée est meilleure car si
SI condition1 et non(condition2) les conditions 1 et 2 sont
ALORS Instruction_c1_non(c2)
vérifiées, la machine teste les
FINSI
3 autres alternatives
SI non(condition1) et condition3
inutilement.
ALORS Instruction_non(c1)_c3
FINSI Conclusion : Lorsque l’ensemble
SI non(condition1) et d’intersection entre les
non(condition3) différentes conditions est {Ø},
ALORS
les structures conditionnelles
Instruction_non(c1)_non(c3)
séquentielles doivent être
FINSI
utilisées.
1ère Année Académie Militaire –
A.U. 2019/2020 Informatique – Chapitre 1 34/110
Exemple1 (1/2)
ALGORITHME CalculSomInverseXY
VARIABLE X,Y: entier SomI : réel
DEBUT
Ecrire("donner deux entiers ")
Lire(X,Y)
SI X≠0 ALORS
SI Y≠0 ALORS SomI ← 1/X + 1/Y FINSI
FINSI
Si X≠ 0 et Y≠ 0 ALORS
Ecrire("la somme des inverses de ", X,
"et", Y, "est égale à ", SomI)
SINON
Ecrire("impossible de calculer la somme des
inverses de ", X, " et ", Y)
FINSI
FIN

Exemple1 (2/2): Détaillant
d’avantage l’affichage
1. ALGORITHME CalculSomInverseXY
2. VARIABLE X,Y: entier SomI : réel
3. DEBUT
4. Ecrire("donner deux entiers") Lire(X) Lire(Y)
5. SI X≠0 ET Y≠0 ALORS SomI ← 1/X + 1/Y FINSI
6.
7. SI X≠0 ET Y≠0 ALORS
8. Ecrire("la somme des inverses de", X, "et", Y,
9. "est égale à ", SomI)
10. SINON {plus de précision sur l’origine du problème}
11. SI X≠ 0 Alors Ecrire("Calcul impossible car Y est nul")
12. SINON
13. SI Y ≠ 0 ALORS Ecrire("Calcul impossible X =0")
14. Sinon Ecrire("Calcul impossible car X et
Y égaux à 0")
15. FINSI
16. FINSI
17. FINSI
18.FIN

Exemple 2 : Résolution de Ax+B=0
1. ALGORITHME sol_prem_degre
2. VARIABLE A,B,x : réel Drapeau : entier
3. DEBUT
4. Ecrire("Donner les coefficients de l’équation: ")
5. Lire(A,B)
6. SI A=0 ALORS
7. SI B=0 ALORS drapeau ← 0
8. SINON drapeau ← -1 FINSI
9. SINON DEBUT x ← -B/A
10. drapeau ← 1
11. FIN
12. FINSI
13. SI drapeau = 1 ALORS
14. Ecrire("la solution de l’équation", A,"* x +", B,
15. "=0 est x=", x)
16. SINON
17. SI drapeau = -1 ALORS Ecrire("pas de solution")
18. SINON Ecrire("infinité des solutions")
19. FINSI
20. FINSI
21.FIN

Structure conditionnelle en
Python (1/2)
1. if condition:
2. bloc_instruction1
3. else:
4. bloc_instruction2
La condition est une expression booléenne composée d'opérateurs

relationnels, d'opérateurs logiques et des verbes logiques (True,
False).
L'évaluation de la condition doit donner True ou False, autrement une

erreur se produit.
La clause else s'exécute lorsque l'évaluation de toutes les

conditions précédentes donne False. Cette clause est optionnelle.
ATTENTION : Python est sensible à la casse.

Structure conditionnelle en Python (2/2)
Si l’instruction1 et (ou) l’instruction2 est à son tour une
structure conditionnelle, la structure s’écrit alors :
1. if condition_1:
2. bloc_instruction_1
3. else:
4. if condition_2:
6. else:
La structure peut s’écrire encore en remplaçant else if par elif :
1. if condition_1:
3. elif condition_2:
5. else:

Indentation signifiante (1/2)
Un bloc est une suite d’instructions qui s’exécutent les unes
après les autres.
Pour identifier sans ambiguïté les instructions appartenant
au bloc du if, il est nécessaire de les indenter.
Indenter signifie ajouter un même nombre d’espaces devant
chacune des lignes définissant les instructions.
Alors que dans certains langages cette pratique n’est qu’une
recommandation,
Elle est une obligation dans Python!
On peut se fixer par convention qu’une indentation est
constituée de quatre espaces (ou un simple appuis sur la
touche Tabulation).

Indentation signifiante (2/2)
1. #cette ligne a un niveau d'indentation de 0
Au sein d’un bloc, le niveau d’indentation doit être le même.

Le code suivant est valide et la ligne y = y // x ne s’exécute que si x
est non nul :
1. if x != 0:
2. y = 3
3. y = y // x # division entière

Exemple (1/3)
Le programme suivant exécute trois instructions différentes
suivant la valeur de x % 3:
1. #ici, les trois instructions

1. if x % 3 == 0 :
2. #sont au même niveau.
2. x = x + 1
3. else: 3. if x % 3 == 0 :
4. if x % 3 == 1 : 4. x = x + 1
5. x = x – 1 5. elif x % 3 == 1 :
6. else: 6. x = x – 1
7. x = 2 * x 7. else:
8. x = 2 * x

Exemple (2/3)
1. X = int(input("Donner entier X: "))
2. Y = int(input("Donner entier Y: "))
3. if X != 0 and Y != 0:
4. SomI = 1/X + 1/Y
5. print("la somme des inverses de", X, "et",
6. Y, "est égale à ", SomI)
7. elif X != 0:
8. print("Calcul impossible car Y est nul")
9. elif Y != 0:
10. print("Calcul impossible car X = 0 ")
11.else:
12. print("Calcul impossible car X et Y égaux à 0")

Exemple (3/3)
1. #programme pour la résolution de l’équation Ax+B=0
2. A = float(input("Donner le coefficient A: "))
3. B = float(input("Donner le coefficient B: "))
4. if A == 0:
5. if B == 0: drapeau = 0
6. else: drapeau = -1
7. else:
8. x = -B/A
9. drapeau = 1
10.#affichage en fonction de la valeur de « drapeau »
11.if drapeau == 1:
12. print("Sol. de l’équation",A,"*x+",B,"=0 est x=",x)
13.elif drapeau == -1:
14. print("pas de solution")
15.else:
16. print("infinité de solution")

4ème Partie :
STRUCTURES ITÉRATIVES
ET RÉPÉTITIVES

Problématique : Exemple1
Reprenons l’exemple du calcul de la surface ou de la

circonférence d’un cercle selon le choix de l’utilisateur:
L’utilisateur doit répondre par ‘S’ ou ‘C’. Mais il risque fort, tôt
ou tard, de taper autre chose que cela!
Si on veut se protéger en cas d’erreur, il faudrait

conditionner la saisie à l’aide de structures conditionnelles.

Problématique : Exemple1 (suite)
...
Ecrire ("Donner votre choix: S pour surface et C
pour circonférence")
Lire (choix)
Si choix <> ‘S’ ET choix <> ’C’ Alors
Début
Ecrire ("Saisie erronée à refaire")
Lire (choix )
Si choix <> ‘S’ ET choix <> ’C’ Alors
Début
Ecrire ("Saisie erronée. Recommencez")
boucler
Lire (choix )
. . .
Fin
FinSi
Fin
FinSi …
MAIS !!! Combien de structures conditionnelles (Si … FinSi)?
D’où le besoin d’utiliser des structures répétitives.

Problématique : Exemple2
On veut calculer la somme de N entiers.
X←1
S←0 S←0
S ← S+x x←1
x ← x+1 (x=2)
S ← S+x S ← S+x
x ← x+1 (x=3) x ← x+1
…
Arrêter la boucle
x ← x+1 (x=N) quand x > N
S ← S+x
On remarque que le même traitement se répète un certains nombre de
fois.
Problème : combien d’instructions séquentielles va-t-on écrire ?
N est inconnue lors de l’écriture de l’algorithme !!!
mais sera connue pendant l’exécution (lors de la saisie de N), d’où le
besoin d’utiliser des structures itératives.

Définitions (1/3)
En général, lorsque plusieurs opérations se répètent:
nous représentons celles-ci par une même séquence
d’instructions
et nous répétons l'exécution de la séquence plusieurs fois.
L’exécution de toute séquence d’instructions répétitive ou itérative
est une boucle.
Un traitement répétitif ou itératif peut être vu comme un traitement
conditionnel:
qu’on exécute un certains nombre de fois connu,
ou non connu d’avance (y compris zéro fois) selon la valeur de
la condition.

Définitions (2/3)
Les boucles permettent ainsi d’exécuter une séquence
d’instructions soit un certains nombre de fois :
Connu d’avance. Exemple : calcul du Nème terme d’une suite.
Non connu d’avance. Exemple : le contrôle de saisie de données
qui consiste à vérifier que les valeurs des données entrées au
clavier correspondent bien à celles attendues par l’algorithme.
La séquence d’instructions peut être :
Une répétition : Le passage courant dans la boucle est
indépendant du passage précèdent.
Exemple : calcul des moyennes des étudiants (la même
séquence d’opérations se répète pour le calcul de la moyenne de
chaque étudiant; MAIS aucune relation n’existe entre la moyenne
d’un étudiant et celle d’un autre).

Définitions (3/3)
Une itération : chaque passage dans la boucle est dépendant
du passage précèdent.
Ainsi, une itération permet de calculer une valeur par étapes
successives (la valeur calculée à une étape est dépendante
de la valeur déterminée aux étapes précédentes).
Exemples :
Calcul de la pluviométrie d’une région pendant un mois.
Calcul d’un terme d’une suite récurrente à partir d’un terme
initial.
Un passage dans la boucle est une exécution une fois de
l’ensemble des opérations se trouvant dans la boucle (qu’il
s’agisse d’une itération ou d’une répétition).

Les Différentes Structures
Répétitives/Itératives (1/2)
Trois formes existent :
La structure TANTQUE … FIN_TANTQUE
S’exécute un certain nombre de fois (ou zéro fois), connu ou

non, d’avance.
La structure REPETER … JUSQU’À
S’exécute un certain nombre de fois (au moins une), connu ou

non, d’avance.
La structure POUR … FIN_POUR
S’exécute un certain nombre de fois (ou zéro fois) connu

d’avance. Elle permet d’exprimer les boucles à index numérique.

Les Différentes Structures
Répétitives/Itératives (2/2)
TRES IMPORTANT :
Chaque structure répétitive/itérative se caractérise par :
une initialisation,
une condition,
une séquence logique d’instructions.
Toute modification de l’une des trois caractéristiques

nécessite une vérification des deux autres.

Boucle conditionnelle
TANTQUE … FIN_TANTQUE
Cette structure s’applique aussi bien dans le cas où le nombre de
passages dans la boucle (c.à.d. itération ou répétition) est connu ou
inconnu d’avance:
…
Initialisation
TANTQUE (condition d’EXECUTION est vraie) FAIRE
oui
Instructions (incluent au moins une instruction
qui change la valeur de la condition)
FIN_TANTQUE
… non

Exemple de Calcul du produit des N premiers
entiers positifs avec TANTQUE (1/2)
ALGORITHME Produit
VARIABLE P, N, x : entier
DEBUT
ECRIRE(" Donner N > 0: ")
LIRE(N)
TANTQUE (N<=0) FAIRE
ECRIRE(" Donner N > 0: ")
LIRE(N)
FIN_TANTQUE
x ← 1
P ← 1
TANTQUE (x <= N) FAIRE
P ← P * x
x ← x + 1
FIN_TANTQUE
ECRIRE(" Le produit des ",N, " entiers est ", P)
FIN

entiers positifs avec TANTQUE (2/2)
ALGORITHME Produit_2 ALGORITHME Produit_3

VARIABLE P, N, x : entier VARIABLE P, N, x : entier
DEBUT DEBUT
ECRIRE("Donner N > 0") ECRIRE("Donner N > 0")
LIRE(N) LIRE(N)
TANTQUE (N <= 0) FAIRE TANTQUE (N <= 0) FAIRE
ECRIRE("Donner N > 0") ECRIRE("Donner N > 0")
LIRE(N) LIRE(N)
FIN_TANTQUE FIN_TANTQUE
x ← N x ← 0
P ← 1 P ← 1
TANTQUE (x > 0) FAIRE TANTQUE (x < N) FAIRE
P ← P * x x ← x + 1
x ← x - 1 P ← P * x
FIN_TANTQUE FIN_TANTQUE
ECRIRE("Le produit des", ECRIRE("Le produit des",
N, "entiers est P=", P) N, "entiers est P=", P)
FIN FIN

Caractéristiques de la Structure
TANTQUE
La condition peut être simple ou complexe.
Les instructions sont exécutées tant que la condition est toujours
Vraie.
Si dès le départ la condition n’est pas vérifiée alors la structure
répétitive (ou itérative) n’est jamais exécutée (exécutée 0 fois).
L’exécution de la structure répétitive (ou itérative) s’arrête dès que
la condition cesse d’être vérifiée.
Lorsque la condition cesse d’être vraie, l’algorithme exécute
l’instruction qui suit la structure répétitive ou itérative (si elle existe)
ou arrêt de l’exécution.

Remarques importantes
ALGORITHME Somme_Pairs L’exécution pour N=10 est :
VARIABLE S, N, i: entier S=0+2+4+6+8+10
DEBUT => arrêt de la boucle pour la
ECRIRE(" Donner N > 0 ")
valeur de i=10
LIRE(N)
TANTQUE N<=0 FAIRE L’exécution pour N=9 est :
ECRIRE(" Donner N > 0 ") S=0+2+4+6+8+10+12+…
LIRE(N) => boucle infini car le « i » n’est
FIN_TANTQUE
jamais égal à N=9
i ← 0
S ← 0 En conclusion il faut que la
TANTQUE i <> N FAIRE condition perche par excès et
i ← i + 2 utiliser :
S ← S + i TANTQUE i <N-1 FAIRE
FIN_TANTQUE
ECRIRE("La somme des entiers à la place de
pairs < à ", N, " est= ", S) TANTQUE i <> N FAIRE
FIN

Boucle while en Python
Syntaxe d’une boucle while:
while condition:
bloc_instructions
Exemple: Calcul factoriel de N

1. N = int(input("Donner N > 0: "))
2. while N<=0:
3. N=int(input("Donner N > 0: "))
4. C = N
5. P = 1
6. while C > 0:
7. P = P * C
8. C = C - 1
9. print(" Le factoriel de ",N, “ est ", P)

Terminaison d’une boucle
Dans l’exemple précédent:
La variable « C » joue le rôle d’un compteur
Au départ « C » contient le nombre des itérations à faire
La condition d’arrêt test si le « N » itération ont été faites
Mathématiquement, la fin de la boucle est garantie:
La valeur de « C » est un entier strictement positif;
Elle décroît strictement après chaque itération.
Et comme il n’existe pas de suite infinie strictement
décroissante d’entier naturels,
Il ne peut y avoir qu’un nombre fini d’itérations.

Invariant de boucle (1/2)
Il s’agit de démontrer qu’une boucle produit l’effet attendu au
moyen d’un invariant, c’est-à-dire une propriété:
Qui est vérifiée avant d’entrer dans la boucle,
Si elle est vérifiée avant une itération, est vérifiée après
celle-ci,
Lorsqu’elle est vérifiée en sortie de boucle permet d’en
déduire que le programme est correct.
Exemple:
Démontrer que le programme de calcul de « 2n » suivant est
correct, c.-à-d. lorsque l’exécution se termine, la variable « p »
contient bien la valeur « 2n » où « n >0 » est la valeur initiale de
la variable « c ».

Invariant de boucle (2/2)
c = n pour toute « i » on a pi=2n-ci et ci≥0
p = 1
Pour i=0: p0=1=20=2n-c0 et
while c > 0 : c0=n ≥0
p = p * 2
pi+1=2pi=2n-ci+1=2n-ci+1 et
c = c – 1 ci+1=ci-1 => pi=2n-ci
Soit ci et pi à l’itération « i » Or ci>0 => ci+1 ≥0
L’état initial: c0 = n, p0 = 1 Si (ci>0) n’est pas vérifiée =>
Et d’après la boucle on a: ci+1 on quitte la boucle avec ci=0,
= ci - 1 et pi+1 = 2Pi donc pi=2n-ci => pi=2n
Et on remarque que la => La subtilité de ce

propriété suivante est raisonnement tient dans le
toujours vérifiée, choix de bon invariant!

Boucle conditionnelle
REPETER … JUSQU’A
La structure REPETER … JUSQU’A s’applique aussi bien dans
le cas où le nombre de passages dans la boucle est connu ou
inconnu d’avance :
…
Initialisation non
REPETER
Instructions (incluent au moins une instruction

qui change la valeur de la condition)
JUSQU’A (condition d’ARRET est Vraie)

…
oui

Exemple de Calcul du produit des N
premiers entiers positifs avec REPETER
1. ALGORITHME Produit
2. VARIABLE P, N, x : entier
3. DEBUT
4. REPETER
5. ECRIRE("Donner N:")
6. LIRE(N)
7. JUSQU'A (N > 0)
8. x ← 1
9. P ← 1
10. REPETER
11. P ← P * x
12. x ← x + 1
13. JUSQU'A (x > N)
14. ECRIRE("Le produit des",N, "entiers est =", P)
15. FIN

Caractéristiques de la structure
REPETER
La condition peut être simple ou complexe.
Les instructions sont exécutées jusqu’à ce que la condition
d’arrêt devienne vraie.
On exécute au moins une fois l’itération (ou la répétition) avant
de vérifier la condition d’arrêt.
Les instructions sont exécutées tant que la condition est toujours
à la valeur Faux.
REMARQUE IMPORTANTE :
Un traitement exprimé avec TANTQUE ne peut pas être exprimé
avec REPETER en inversant juste la condition (la négation).
Ceci n’est vrai que pour un traitement dont le nombre de
passages dans la boucle TANTQUE est au moins égal à une
fois.
REMARQUES IMPORTANTES
…
ALGORITHME Somme_Pairs i ← 2
VARIABLE S, N, i: entier S ← 0
DEBUT REPETER
REPETER S ← S + i
ECRIRE("Donner N") i ← i + 2
LIRE(N) JUSQU’À i > N
JUSQU'À (N > 0) …
i ← 2 PROBLEME : Si N=1 Alors S = 2.
S ← 0 Solution :
TANTQUE (i<=N) FAIRE …
S ← S + i S ←0
i ← i + 2 Si N>1 Alors
FIN_TANTQUE Début i ← 2 , S ← 0
ECRIRE("La somme des REPETER
entiers pairs < à", N, S ← S + i
"est= ", S) i ← i + 2
FIN JUSQU’À i > N
Remarque : Si N=1 Alors S=0. Fin
Finsi
… Militaire –
1ère Année Académie
Boucle répéter en Python
Ce type de boucle n’existe

pas en Python, mais on Exemple: Calcul factoriel de N
peut, facilement, là simulée while True:
par la technique suivante: N = int(input("Donner
N > 0: "))
Syntaxe d’une boucle répéter: if N > 0:
break
1. while True: C = N
P = 1
2. bloc_instructions while True:
3. if condition: P = P * C
C = C - 1
4. break if C <= 0:
break
print("Le factoriel de ",
N, " est ", P)

Boucle inconditionnelle
POUR … FIN_POUR
Boucle croissante :
...
Initialisation partielle
POUR var de V_I à V_F FAIRE
(POUR var = V_I à V_F FAIRE)
Instructions
FIN_POUR
...
Boucle décroissante :
...
Initialisation partielle
POUR var = V_I à V_F avec pas=-1 FAIRE
Instructions
FIN_POUR
...
Caractéristiques de la structure POUR
La structure POUR…FIN_POUR (boucles à index numérique)
ne s’applique que dans le cas où le nombre de passages dans
la boucle est connu d’avance.
Les instructions encadrées par POUR et FIN_POUR sont
exécutées :
(V_F – V_I + 1) fois, dans le cas d’une boucle croissante à
condition que V_I <= V_F, autrement la boucle s’exécute 0
fois.
(V_I – V_F + 1) fois, dans le cas d’une boucle décroissante
à condition que V_I >= V_F, autrement la boucle s’exécute
0 fois.
Le pas est par défaut égal à 1 pour une boucle croissante et
égal à -1 pour une boucle décroissante.

entiers positifs avec POUR croissante
3. DEBUT
4. REPETER
5. ECRIRE("Donner N:")
6. LIRE(N)
7. JUSQU'A N>0
8. P ← 1
9. x ← 1 {pas d’initialisation manuelle de x}
10. POUR x = 1 à N FAIRE
11. P ← P * x
12. x ← x + 1 {pas d’incrémentation manuelle de x}
13. FIN_POUR
14. ECRIRE("Le produit des",N, "entiers est =", P)
15.FIN

entiers positifs avec POUR décroissante
3. DEBUT
4. REPETER
5. ECRIRE(" Donner N")
6. LIRE(N)
7. JUSQU'A N > 0
8. P ← 1
9. POUR x = N à 1 avec pas = -1 FAIRE
10. P ← P * x
11. FIN_POUR
12. ECRIRE("Le produit des",N, "entiers est ", P)
13.FIN

Applications (1/3)
Exemple 1 : ALGORITHME AfoisB
VARIABLE P,A,B,i : entier
Ecrire un algorithme qui calcule DEBUT
le produit de deux nombres REPETER
entiers positifs par additions ECRIRE("Donner le
successives du multiplicande multiplicande:")
LIRE(A)
autant de fois que nécessaire: JUSQU'A A>0
A*B = A + A + … + A REPETER
ECRIRE("Donner le
B fois multiplicateur:")
LIRE(B)
Exemple2 : JUSQU'A B>0
Soit N couples de nombres P ← 0
entiers positifs, modifier POUR i=1 à B FAIRE
l’algorithme pour qu’il calcule et P ← P + A
FIN_POUR
affiche au fur et à mesure le ECRIRE("Le produit de", A,"*",B,
produit des 2 termes de chaque "par additions successives est =
couple selon le même principe. ",P)
FIN
Applications (2/3)
ALGORITHME N_AfoisB REPETER
VARIABLE N,P,A,B,i,j: entier ECRIRE("Donner le
DEBUT multiplicateur")
REPETER LIRE(B)
ECRIRE("Nombre de JUSQU'A B> 0
couples?") P ← 0
LIRE(N) POUR i=B à 1 avec pas =-1
JUSQU'À N>0 FAIRE
j ← N P ← P + A
TANTQUE j>0 FAIRE FIN_POUR
REPETER ECRIRE("Le produit de",
ECRIRE("Donner le A, "*", B, "par additions
multiplicande") successives est = ",P)
LIRE(A) j ← j - 1
JUSQU'A A>0 FIN_TANTQUE
FIN

Applications (3/3)
Exemple3 : Calcul de A fois B avec N couples en calculant la
somme des produits des différents couples.
ALGORITHME N_AfoisB REPETER
VARIABLE N,P,A,B,i,j,S_C : ECRIRE("Donner le
entier multiplicateur:")
DEBUT LIRE(B)
REPETER JUSQU'A B>0
ECRIRE("Le nombre P ←0
couples?") POUR i=1 à B FAIRE
LIRE(N) P ← P + A
JUSQU'A N>0 FIN_TANTQUE
S_C ← 0 ECRIRE("Le produit de",
POUR j=1 à N FAIRE A, "*", B, "par additions
REPETER successives est =", P)
ECRIRE("Donner le S_C ← S_C + P
multiplicande:") FIN_POUR
LIRE(A) FIN
JUSQU'A A>0
Structures Répétitives/Itératives en
Python (1/4)
1- Syntaxe d’une boucle conditionnelle:
En Python, on écrit une boucle conditionnelle ainsi :
1. while condition:
2. bloc_d_instructions #Corps de boucle
Les contraintes d’indentation pour le bloc d’instructions sont les

mêmes que pour une instruction conditionnelle,
et la fin du bloc est marquée par le retour au niveau
d’indentation du while.
Ce bloc d’instructions est appelé le corps de boucle et chaque
passage dans ce bloc est appelé une itération.

Python (2/4)
2- Exemple:
Le programme calculant 2n deviendra alors :
1. c = n
2. p = 1
3. while c > 0:
4. p = p * 2
5. c = c - 1
On va détailler l’exécution de ce programme à partir de l’état c = 3
Après Après Après
itération Initial
itér.1 itér.2 itér.3
p 1 2 4 8
c 3 2 1 0

Python (3/4)
3- Syntaxe d’une boucle inconditionnelle:
Les boucles conditionnelles sont nécessaires pour effectuer des
calculs lorsqu’il n’est pas possible de borner le nombre d’étapes
nécessaires.
En pratique, dans de nombreux cas, on connaît à l’avance le nombre
d’itérations qu’il faudra effectuer, ce qui rend inutile d’utiliser une
boucle conditionnelle.
En Python, on écrit une boucle inconditionnelle « for » ainsi :

1. for i in range(x):
2. bloc_d_instructions

Python (4/4)
4- Exemple:
Si on reprend le programme de calcul de 2n, on aura juste à écrire :
1. p = 1
2. for c in range(n):
3. p = 2 * p # p *= 2
Le compteur de boucle est ici entièrement géré par la boucle for.

Il n’est pas besoin de l’incrémenter, ni de tester qu’il ne dépasse
pas une certaine limite.
Il reste possible d’utiliser ce compteur au sein du corps de la
boucle.
Dans la boucle for c in range(n), la variable « c » parcourt les
entiers de 0 à n − 1.
On remarque que le paramètre passé à range() est donc la valeur
avant laquelle on s’arrête.
Comme souvent en informatique, on numérote à partir de 0.

Correspondance entre les Structures
Répétitives/Itératives en Algorithmique et
Python
Algorithmique Python
Pour var de v_i à v_f faire for var in range(v_i, v_f):
instructions instructions
Fin_Pour
Tantque condition faire while condition:
Fin_Tantque
Répeter while True :
Jusqu'à condition if condition:
break

Exemple en Python
Programme utilisant “while …” Programme utilisant “for …”
N = int(input(“Entrer N>0: ”)) #boucle répeter
while not isinstance(N, int) or N<=0 : while True :
N=int(input("entrer de nouv. N>0")) N=int(input("Entrer N>0: "))
i=1 if isinstance(N, int) and N>0 :
P=1 break
while i<=N : P=1
P =P*i #boucle pour
i=i+1 for i in range(N) :
print("Le produit des ", N, "premiers P = P * (i + 1)
entiers positifs est P=", P) print("Le produit des ", N, "premiers
entiers positifs est P=", P)
Résultat de l’exécution
Entrer N>0 : 0 Résultat de l’exécution
entrer de nouv. N>0 : 0 Entrer N>0: -6
entrer de nouv. N>0 : -5 Entrer N>0: 0
entrer de nouv. N>0 : 5 Entrer N>0: 4
Le produit des 5 premiers entiers Le produit des 4 premiers entiers positifs
positifs est P= 120 est P= 24

5ème Partie :
CRÉATION ET
MANIPULATION DES
TABLEAUX

Problématique
Parfois on a besoin de manipuler plusieurs variables de même
type c.à.d. leur appliquer le même traitement.
Exemples : - les notes des élèves d’une classe,
- longueurs des mois d’une année non bissextile.
Dans ce cas, au lieu de déclarer un nombre faramineux de
variables, on fait recours à des structures de données adéquates
tels que les tableaux.
Exemple : Pour ranger les longueurs des mois d’une année non
bissextile, on utilise le tableau suivant :
31 28 31 30 31 30 31 31 30 31 30 31
positions 1 2 3 … 12
=> On constate que ce tableau contient 12 éléments de même type.

Définitions
Chacune des valeurs (des cases) est repérée par son rang ou
sa position appelé encore indice.
Exemple : pour accéder à la valeur 28 on donne l’indice 2.
Dans le cas où l’indice est unique, on parle de tableau à une

dimension (monodimensionnel) ou vecteur.
Dans le cas où un élément est repéré par 2 indices, le tableau
est dit à deux dimensions (bidimensionnel) ou encore
matrice.
Lorsqu’un élément est repéré par N indices, le tableau est dit à
N dimensions (ce cas dépasse le cadre de ce cours).

Définition d’un tableau à une
dimension (1/2)
Un tableau de nom « T » et de longueur « N » est une suite de
« N » variables « T[i] » (ayant tous le même type) où « i » est un
indice entier compris entre la position inférieure et la position
supérieure (à définir).
« [ ] » représente l’opérateur de sélection d’éléments.
La variable « T[i] » s’appelle l’élément d’indice « i » ou encore le
ième élément du tableau « T ».
Tous les éléments « T[i] » sont de même type.
Un tableau à une dimension où l’indice inférieur vaut « 1 » et
l’indice supérieur vaut « N » se présente comme suit :
T T[1] T[2] … T[i] … T[N-1] T[N]
indices 1 2 i N-1 N

Définition d’un tableau à 1D (2/2)
Jusque-là, nous avons considéré qu’un tableau commence
forcément par l’indice « 1 » jusqu’à l’indice « N » pour simplifier le
discours mais ceci n’a rien d’obligatoire algorithmiquement.
En effet, la borne inférieure d’un tableau (éventuellement la
borne supérieure) peut être négative mais forcément inférieure à
la borne supérieure.
De manière générale, un tableau à une dimension ayant (bsup –
binf + 1) éléments se présente comme suit :
T[binf] T[binf+1] … T[i] … T[bsup-1] T[bsup]
Exemples:
[binf .. bsup] = [-10 ..-1] [binf .. bsup] = [-10 ..10]
[binf .. bsup] = [-10 .. 0] [binf .. bsup] = [ 0 ..10]
[binf .. bsup] = [1 ..10] etc.

Déclaration d’un tableau à 1D (1/3)
Un tableau est une variable qui doit avoir un nom, un nombre
d’éléments (borne_sup - borne_inf + 1) et un type qui représente
le type de ses éléments.
Il est nécessaire de déclarer un tableau avant sa première
utilisation.
Cette déclaration peut se faire directement dans la partie
variable,
Ou en définissant un type tableau dans la partie type et
déclarer ensuite la variable de ce type défini comme suit:
Type NomType = tableau [borne_inf .. borne_sup]
de type des éléments

Déclaration d’un tableau à 1D (2/3)
Si « Tab » est une variable « tableau » pouvant contenir
« N » entiers (avec borne_inf = 1 et borne_sup = N) alors la
déclaration de Tab peut se faire:
soit :
1.Constante N = valeur
2.Variable Tab : tableau [1 .. N] d’entiers
Soit encore :
1.Constante N = valeur
2.Type TABENT = tableau [1..N] d’entiers
3.Variable Tab : TABENT

Déclaration d’un Tableau à 1D (3/3)
Il est préférable d’utiliser la deuxième déclaration surtout avec la
programmation modulaire (utilisation des types définis dans les
entêtes des procédures et fonctions).
Possibilité 1:
1. Constante N = 30 C = 6
2. Variable Tab_note, Tab_moy: tableau [1..N] de réel
3. Tab_coeff: tableau [1..C] d’entier
Possibilité 2:
1. Constante N = 30 C = 6
2. Type TNote = tableau [1..N] de réel
3. TCoeff = tableau [1..C] d’entier
4. Variable Tab_note, Tab_moy : TNote
5. Tab_coeff : TCoeff

Manipulation d’un tableau à 1D
Si T est un tableau à « N » entiers, défini comme un tableau
[1..N] d’entier avec « N » constante déjà défini.
L’accès à la case d’indice « i » se fait par T[i].
Lorsque l’indice « i » est inférieur à « 1 » ou supérieur à « N
», T[i] génère une erreur.
La variable « T[i] » peut être manipulée comme n’importe
quelle variable scalaire :
Lire(T[i]) Ecrire(T[i])
T[i] ← valeur T[i] ← T[i]+T[i-1]
Si T[i] > T[i-1] Alors ….
Remarque importante : Attention, les instructions de lecture,
d’écriture et d’affectation ne sont pas applicables au tableau T.
Lire(T) Ecrire(T) T ← valeur

Remplissage d’un tableau à 1D
Dans la suite, on suppose avoir effectué les déclarations suivantes :
une constante Nmin=1 Nmax=10
un type Tab1 = tableau [Nmin..Nmax] de entier
« x » et « y » représentent respectivement la borne « inf » et la
borne « sup » de début et de fin de remplissage.
Procédure Remplir_Tab Remplissage complet
(S T: Tab1, Algorithme Remplir_Complet
E x, y: entier) Constante Nmin=1 Nmax=10
Variable i : entier Type Tab1=tableau[Nmin..Nmax]
Début d’entier
Pour i = x à y Faire Variable V:Tab1 …
Ecrire (‘donner
T[‘,i,’]=’) Début …
Lire(T[i]) Remplir_Tab(V, Nmin, Nmax)
FinPour …
Fin Fin

Affichage d’un tableau à 1D
Affichage du contenu d’un tableau:
Procédure Affich_Tab (E T: Tab1, E x, y: entier)
Variable i: entier
Début
Pour i = x à y Faire
Ecrire (‘T[‘,i,’]=’, T[i])
FinPour
Fin
Appels :
Affichage complet :
Affich_Tab(T,1,Nmax)
Affichage partiel :
Affich_Tab(T,1,p) avec p < Nmax

Définition d’un Tableau à deux
dimensions – 2D (1/2)
Hypothèse : On suppose que la borne inférieure des lignes et celle
des colonnes vaut 1.
Un tableau à deux dimensions de nom « T » a « L » lignes et « C »
colonnes est une suite de L*C variables T[i,j] où l’entier « i » varie
entre « 1 » et « L » et l’entier « j » varie entre « 1 » et « C ».
Lorsque L=C le tableau est dit carré. On appelle ordre le nombre
des éléments des lignes ou des colonnes.
La variable « T[i,j] » s’appelle l’élément d’indice « i » et « j » du
tableau « T ».
Le premier indice est l’indice des lignes et le deuxième est celui
des colonnes.
Tous les éléments « T[i,j] » sont de même type.
De manière générale un tableau à deux dimensions « 2D » se
présente comme suit :

Définition d’un Tableau à 2D (2/2)
jème
colonne
T[1,1] T[1,2] … T[1, j] … T[1, C]

T[2,1] T[2,2] … T[2, j] … T[2, C]
… … … …
ième T[i,1] T[i,2] … T[i, j] … T[i, C]
ligne
… … … …
T[L,1] T[L,2] … T[L, j] … T[L, C]

Déclaration d’un Tableau à 2D
Un tableau à deux dimensions (matrice) doit être déclaré en
précisant son nom, le type de ses éléments, le nombre de ses
lignes (L) et celui de ses colonnes (C).
Cette déclaration se présente comme suit :

1. Constante L=valeur1 C=valeur2
2. Type nomtype = tableau[1..L,1..C] type
3. des éléments
4. Variable T : nomtype ...
Exemple :
1. Constante L=5 C=5
2. Type Tab2d = tableau [1..L, 1..C] d’entier
3. Variable T : Tab2d ...

Manipulation d’un tableau à 2D
Si T est un tableau à L*C éléments, défini par exemple comme
un tableau [1..L,1..C] de réel, alors :
L’accès à la case d’indice « i » et « j » se fait par T[i,j] ;
Si « i » ou « j » est à l’extérieur des bornes, T[i,j] génère une
erreur ;
La variable T[i,j] peut être manipulée comme n’importe
quelle variable scalaire,
c.à.d. que les instructions de lecture, d’écriture et
d’affectation sont applicables aux différentes cases du
tableau et non pas au tableau « T » lui-même :
Lire(T[i,j]) Lire(T)
Ecrire(T[i,j]) Ecrire(T)
T[i,j] ← valeur
…
Remplissage d’un tableau à 2D ligne
par ligne
Dans la suite, on suppose que les déclarations suivantes sont déjà définies :
constante L=10 C=7
type Tab2 = tableau [1..L, 1..C] de réel
1. Procédure Remplir_Tab_L (S T: Tab2, E x, y: entier)

2. Variable i, j: entier
3. Début
4. Pour i = 1 à x Faire
5. Pour j = 1 à y Faire
6. Ecrire (‘donner T[‘,i,’,’,j,’]=’)
7. Lire(T[i,j])
8. FinPour
9. FinPour
10.Fin
Appels :
remplissage complet : Remplir_Tab_L(M, L, C)
remplissage partiel : Remplir_Tab_L(M, p, q) {avec p<L et q<C}

Affichage d’un tableau à 2D
1. Procédure Affich_Tab (E T: Tab2, E x, y: entier)

2. Variable i, j: entier
3. Début
4. Pour i = 1 à x Faire
5. Pour j = 1 à y Faire
6. Ecrire (‘T[‘,i,’ ,’,j,’]=’, T[i,j])
7. FinPour
8. FinPour
9. Fin

6ème Partie :
NOTION DE COÛT D'UN

ALGORITHME ET CLASSES
DE COMPLEXITÉ

Coût d’algorithme et complexité
Evaluer un algorithme revient à mesurer sa complexité.
La complexité d’un algorithme dépend:
de la complexité temporelle (temps d’exécution)
et de la complexité spatiale (taille des données).
Temps de calcul ou d’exécution est noté:
O de f(n): fonction asymptotique.
Il dépend du nombre d’opérations.

Coût d’algorithme (1/2)
Coût d’algorithme = ∑ coûts d’opérations élémentaires
+ ∑ coûts d’opérations complexes
Coût des opérations élémentaires:
Opérations élémentaires: affectation, lecture/écriture,
opérations arithmétiques, test de comparaison…
Coût d’exécution =1
Exemple Algorithme A:
1. Somme n + 1
2. Somme somme ∗ n
3. Somme somme/2
=> coût(A) = 3 (3 affectations)
ou = 6 si le calcul détaillé (3 affectations + une addition +
multiplication + division)
Coût d’algorithme (2/2)
Coût d’opérations complexes:
Opération complexe: instruction conditionnelle ou boucle ou
appel de module.
coût (inst_cond) = coût (test) + max (coût(T1),coût(T2))
coût (boucle Pour) = n * ∑ coût(inst(i))
coût (boucle TantQue) = n*∑ coût(inst(i))+coût(comparaison)
coût(module) = ∑ coûts (opérations élémentaires internes)
Exemple Algorithme B:
1. TantQue i <= n faire
2. Somme Somme + i
3. i i + 1
4. FinTantQue
⇒ coût (B) = 3n (n comparaisons + 2n affectations)
ou = 5n si calcul détaillé (n comparaisons + 2n affectations
+ 2n additions)

Complexité temporelle vs
spatiale (1/2)
Exemple : échange de deux valeurs entières
// (1) échange des valeurs // (2) échange des
de deux variables entier x, valeurs de deux variables
y à travers tmp; entier x, y;
... // initialisation de x ... // initialisation de
et y x et y
tmp <- x; x <- y-x;

x <- y; y <- y-x;
y <- tmp; x <- y+x;
La première méthode utilise une variable supplémentaire « tmp » et
réalise 3 affectations
La deuxième méthode n'utilise que les deux variables dont on veut
échanger les valeurs, mais réalise 3 affectations et 3 opérations

Complexité temporelle vs spatiale
(2/2)
L'efficacité d'un algorithme peut être évalué en temps et en
espace :
Complexité en temps : évaluation du temps d'exécution de
l'algorithme,
Complexité en espace : évaluation de l'espace mémoire
occupé par l'exécution de l'algorithme.
Espace-temps : en général pour gagner du temps de calcul, on
doit utiliser davantage d'espace mémoire.
On s'intéresse essentiellement à la complexité en temps (ce qui
n'était pas forcément le cas quand les mémoires coutaient cher)

Complexité asymptotique
Calculer la complexité de façon exacte n'est pas raisonnable vu
la quantité d'instructions de la plupart des programmes
et n'est pas utile pour pouvoir comparer deux algorithmes.
Première approximation : on ne considère souvent que la

complexité au pire,
Deuxième approximation : on ne calcule que la forme

générale de la complexité,
Troisième approximation : on ne regarde que le

comportement asymptotique de la complexité.

Domination asymptotique (1/2)
Soitent « f » et « g » étant deux fonctions,
« f = O(g) » s'il existe des constantes c>0 et n0
telles que f(x) < c*g(x) pour tout x > n0 :
f = O(g) signifie que « f » est dominée

asymptotiquement par « g ».
Domination asymptotique (2/2)
La notation O, dite notation de Landau, vérifie les propriétés
suivantes :
si f=O(g) et g=O(h) alors f=O(h)
si f=O(g) et k un nombre, alors k*f=O(g)
si f1=O(g1) et f2=O(g2) alors f1+f2 = O(g1+g2)
si f1=O(g1) et f2=O(g2) alors f1*f2 = O(g1*g2)
Exemples de domination asymptotique :
x = O(x2) car pour x>1, x<x2
x2 = O(x3) car pour x>1, x2<x3
100*x = O(x2) car pour x>100, x<x2
ln(x) = O(x) car pour x>0, ln(x)<x

Classes de complexité (1/3)
O(1) : complexité constante, pas d'augmentation du temps
d'exécution quand le paramètre croit,
O(log(n)) : complexité logarithmique, augmentation très
faible du temps d'exécution quand le paramètre croit.
Exemple : algorithmes qui décomposent un problème en
un ensemble de problèmes plus petits (dichotomie).
O(n) : complexité linéaire, augmentation linéaire du temps
d'exécution quand le paramètre croit (si le paramètre double,
le temps double).
Exemple : algorithmes qui parcourent séquentiellement
des structures linéaires.

O(n log(n)) : complexité quasi-linéaire, augmentation un peu
supérieure à O(n).
Exemple : algorithmes qui décomposent un problème en

d'autres plus simples, traités indépendamment et qui
combinent les solutions partielles pour calculer la solution
générale.
O(n2) : complexité quadratique, quand le paramètre double,

le temps d'exécution est multiplié par 4.
Exemple : algorithmes avec deux boucles imbriquées.

O(ni) : complexité polynomiale, quand le paramètre double,

le temps d'exécution est multiplié par 2i .
Exemple : algorithme utilisant « i » boucles imbriquées.
O(in) : complexité exponentielle, quand le paramètre

double, le temps d'exécution est élevé à la puissance 2.
O(n!) : complexité factorielle, asymptotiquement

équivalente à nn

Exemples
Exemple 1: Exemple 2:
n=int(input("Donner n:") n=int(input("Donner n:")
for i in range(15): for i in range(n):
print(2*i) print(i)
Ici la boucle est toujours Ici la boucle affiche le « i » pour

exécutée 15 fois (de i=0 ..14) i=[0 ..n-1] et elle comporte
et elle ne comporte que 2 qu’une opérations élémentaires
opérations élémentaires (affichage)
(multiplication + affichage)
La boucle est exécuté « n » fois
Le temps d’exec. = cte.
Indépendant de « n » Donc la complexité est O(n)
Donc la complexité est O(1)

1ere Chapitre1 - Rappel Algo Diapos v1.7

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

1ere Chapitre1 - Rappel Algo Diapos v1.7

Transféré par

Droits d'auteur :

Formats disponibles

Académie militaire - Fondouk Jedid

Cycle préparatoire - Bouficha

Année universitaire 2019/2020

2. Opérations élémentaires : Affectation, Entrée/Sortie

5. Création et manipulation des tableaux

6. Notion de coût d'un algorithme et classes de

A.U. 2019/2020 1ère Année Académie Militaire – Informatique – Chapitre 1 2/110

A.U. 2019/2020 1ère Année Académie Militaire – Informatique – Chapitre 1 3/110

c’est donc la description logique d’un procédé.

Le point de départ de l’élaboration d’un algorithme est d’identifier les :

2. les données en entrée et

3. les moyens pour obtenir les résultats recherchés à partir des

A un problème donné, peut correspondre plusieurs algorithmes.

Un algorithme exécute un ordonnancement d’un ensemble fini d’actions

A.U. 2019/2020 1ère Année Académie Militaire – Informatique – Chapitre 1 4/110

2. une partie déclarative (optionnelle),

3. et un corps regroupant l’ensemble des actions à exécuter.

Le corps de chaque algorithme comporte les trois parties suivantes :

1. La préparation des données nécessaires à la résolution du

2. Le traitement : définir les actions à effectuer ainsi que leur

3. La restitution du (ou des) résultat(s) à l’utilisateur.

A.U. 2019/2020 1ère Année Académie Militaire – Informatique – Chapitre 1 5/110

TYPE nom_Type = Définition du type

nom_Var2, ..., nom_Varp : type2

PROCEDURE ... FONCTION ...

Appels à des modules

La déclaration est constituée essentiellement de deux grandes

1. La déclaration des objets (ou entités) manipulés :

Les objets élémentaires,

Les objets structurés définis par l’utilisateur.

2. La déclaration des actions définies par l’utilisateur

REMARQUE : Les actions ou les instructions élémentaires (prédéfinis

A.U. 2019/2020 1ère Année Académie Militaire – Informatique – Chapitre 1 8/110

Simples (objets élémentaires)

Complexes (objets structurés) construits à partir des objets

Exemple : les intervalles, les enregistrements, les tableaux,

Tout objet élémentaire doit être bien spécifié et caractérisé par :

être formé que de lettres et/ou de chiffres non séparée par un

pas comporter de caractères spéciaux (+,*,/,(,à,…),

pas être un mot réservé (Algorithme, début, fin, SI,…).

Le type est la nature de l’objet qui représente:

le domaine de définition dans lequel l’objet prend ses valeurs

ainsi que les opérations de base qui lui sont appliquées.

A.U. 2019/2020 1ère Année Académie Militaire – Informatique – Chapitre 1 10/110

le type entier (entiers relatifs), le type réel, le type

La valeur est une instance quelconque de l’ensemble de

Lorsque la valeur de l’objet dans l’algorithme ne change pas

Lorsque la valeur de l’objet change au cours de l’algorithme

A.U. 2019/2020 1ère Année Académie Militaire – Informatique – Chapitre 1 11/110

A.U. 2019/2020 1ère Année Académie Militaire – Informatique – Chapitre 1 12/110

On rappelle qu’un algorithme exécute un ordonnancement fini

Parmi ces opérations, on trouve les opérations élémentaires

L’opération élémentaire d’affectation attribue une valeur à une

Elle fait appel à la notation « ← ». L’opération s’écrit comme

A.U. 2019/2020 1ère Année Académie Militaire – Informatique – Chapitre 1 13/110

A.U. 2019/2020 1ère Année Académie Militaire – Informatique – Chapitre 1 14/110

L’instruction de base permettant à la machine de récupérer (ou

Lire (ind_variable1,..., ind_variableN)

A.U. 2019/2020 1ère Année Académie Militaire – Informatique – Chapitre 1 15/110

Le format général de l’opération élémentaire de sortie ou

A.U. 2019/2020 1ère Année Académie Militaire – Informatique – Chapitre 1 16/110

ECRIRE("texte", [> print("la note de maths est

A.U. 2019/2020 1ère Année Académie Militaire – Informatique – Chapitre 1 19/110