Chapitre 1 - Rappel Algo - Imprimable - v1.7

Académie militaire - Fondouk Jedid Plan
Cycle préparatoire - Bouficha

1. Notion d’algorithme
Module : Informatique 2. Opérations élémentaires : Affectation, Entrée/Sortie

Classes: 1ères Années
3. Structures conditionnelles
Chapitre 1:
4. Structures itératives
RAPPEL DES NOTIONS
ALGORITHMIQUES 5. Création et manipulation des tableaux
Enseignant : Dr. Khemaies GHALI (ghali.khemaies@gmail.com) 6. Notion de coût d'un algorithme et classes de
complexité
Année universitaire 2019/2020
A.U. 2019/2020 1ère Année Académie Militaire – Informatique – Chapitre 1 2/110
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é.

1ère Partie: Le point de départ de l’élaboration d’un algorithme est d’identifier les :
1. résultats à obtenir,
NOTION 2. les données en entrée et
D’ALGORITHME 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.
A.U. 2019/2020 1ère Année Académie Militaire – Informatique – Chapitre 1 3/110 A.U. 2019/2020 1ère Année Académie Militaire – Informatique – Chapitre 1 4/110
Définition et Propriétés d’un
algorithme (2/2) Structure d’un Algorithme (1/2)
ALGORITHME nom_Algo
Tout algorithme possède: entête
CONSTANTE nom_Constante = Valeur de la constante
Déclaration des objets/actions définies

1. une entête, TYPE nom_Type = Définition du type
2. une partie déclarative (optionnelle), {Cette partie est utile lorsqu’il y a des
types définis par l’utilisateur}
3. et un corps regroupant l’ensemble des actions à exécuter. VARIABLE nom_Var1 : type1
(optionnelle)
nom_Var2, ..., nom_Varp : type2
Le corps de chaque algorithme comporte les trois parties suivantes :
{type1 ou type2 peuvent êtres des
1. La préparation des données nécessaires à la résolution du types élémentaires ou définis}
problème et la vérification de leur cohérence si nécessaire.
2. Le traitement : définir les actions à effectuer ainsi que leur PROCEDURE ... FONCTION ...
enchaînement pour résoudre le problème. {Cette partie sera traitée au chapitre 4}
3. La restitution du (ou des) résultat(s) à l’utilisateur. DEBUT

corps Séquence d’instructions (*)
FIN
Structure d’un Algorithme (2/2) Algorithme : Les déclarations

Toute information manipulée doit faire l'objet d’une déclaration
DEBUT préalable sauf si cette information est prédéfinie.
Opérations de lecture
La déclaration est constituée essentiellement de deux grandes
Opérations élémentaires
parties dont l'ordre doit être respecté :

Séquence d’instructions
Opérations d’affectation
1. La déclaration des objets (ou entités) manipulés :
Opérations d’écriture
Les objets élémentaires,
Structures Conditionnelles
Les objets structurés définis par l’utilisateur.
Structures répétitives/itératives 2. La déclaration des actions définies par l’utilisateur
Appels à des modules REMARQUE : Les actions ou les instructions élémentaires (prédéfinis
(procédures et fonctions) par les langages de programmation) ne doivent pas être déclarées.
FIN
Algorithme : Les Objets Objets Elémentaires(1/2)
Les entités ou encore les objets manipulés peuvent être : Un identificateur est un nom désignant l’objet et qui doit être
unique dans l’algorithme et invariant et ne doit :
Simples (objets élémentaires)
Complexes (objets structurés) construits à partir des objets être formé que de lettres et/ou de chiffres non séparée par un
élémentaires et définis par l’utilisateur. espace mais pouvant être attachées par « _ » et commençant
impérativement par une lettre,
Exemple : les intervalles, les enregistrements, les tableaux,
les ensembles, les listes, etc. (à voir plus tard) pas comporter de caractères spéciaux (+,*,/,(,à,…),
Tout objet élémentaire doit être bien spécifié et caractérisé par : pas être un mot réservé (Algorithme, début, fin, SI,…).
• un identificateur Le type est la nature de l’objet qui représente:

spécifiés lors de la déclaration
• un type le domaine de définition dans lequel l’objet prend ses valeurs
• une valeur spécifiée lors de :
- l’exécution si l’objet est variable. ainsi que les opérations de base qui lui sont appliquées.
- la déclaration si l’objet est fixe.
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 2ème Partie:

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

définition décrit par le type: OPÉRATIONS
Lorsque la valeur de l’objet dans l’algorithme ne change pas
d’une exécution à l’autre on parle alors de constante (Exp.
ÉLÉMENTAIRES
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.
Opérations Elémentaires: Affectation (1/2) Opérations Elémentaires: Affectation (2/2)
Une variable ne peut avoir qu’une seule valeur à un instant
On rappelle qu’un algorithme exécute un ordonnancement fini donné et qui doit être compatible avec son type.
d’actions sur des données concrètes pour obtenir un ou
La valeur précédente (si elle existe) est écrasée par la
plusieurs résultats.
nouvelle valeur.
Parmi ces opérations, on trouve les opérations élémentaires La valeur attribuée à un objet peut être:
d’affectation, de lecture et d’écriture.
une valeur particulière.
L’opération élémentaire d’affectation attribue une valeur à une
Exemple : A ← 5 X ← ‘b’
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. une valeur contenue dans une autre variable.
Elle fait appel à la notation « ← ». L’opération s’écrit comme Exemple : A ← 5 B←2 A←B
suit : une valeur numérique calculée par l’évaluation d’une
expression (pouvant être une expression de cumul).
Identificateur_var ← valeur
Le résultat d’une fonction.
Opérations Elémentaires: Opérations Elémentaires:

Lecture/Ecriture (1/2) Lecture/Ecriture (2/2)
L’instruction de base permettant à la machine de récupérer (ou Le format général de l’opération élémentaire de sortie ou
lire) les valeurs introduites au clavier est l’opération de lecture d’affichage est :
des données dont le format est :

Ecrire(expression1, …, expressionN)
avec une expression soit :
Lire (ind_variable1,..., ind_variableN)
• un nom de variable
Ou
• une chaîne de caractères
Lire (ind_variable1),..., Lire(ind_variableN) ...
Exemple :
Exemples:
Ecrire(‘la surface du rectangle est = ‘, S)
Lire(A, B)
Ou
Lire(A), Lire(B)
Exemple (1/2) Exemple (2/2): Erreurs à ne pas faire
ALGORITHME Circ_Surface_Cercle
CONSTANTE Pi = 3.14
CONSTANTE Pi=3.14
VARIABLE R, Circ_Cercle, Surf_Cercle :réel
VARIABLE R, Circ_Cercle, Surf_Cercle :réel
DEBUT
DEBUT
Ecrire(‘donner le rayon du cercle’, R)
Ecrire(‘donner le rayon du cercle R:’)
Lire(R)
Lire(R)
Surf_Cercle ← R * R * Pi
Surf_Cercle ← R * R * Pi {ou R^2 * Pi}
Circ_Cercle = 2*Pi*R
Circ_Cercle ← 2*Pi*R
Ecrire(‘la circonférence et la surface du
Ecrire(‘la circonférence et la surface du cercle de rayon R sont respectivement égales
cercle de rayon’, R, ‘sont respectivement à ‘, Circ_Cercle, ‘, ‘, Surf_Cercle)
égales à ‘, Circ_Cercle, ‘, ‘, Surf_Cercle)
Lire(Surf_Cercle)
FIN
FIN
Traduction en Python Exemple1 en Python

Version 1:
from math import pi
Opéra-
Algorithmique Python Exemples R = float(input("entrer la valeur du rayon"))
tions C = 2 * pi * R
[>from math import factoriel S = pi * R ** 2
Affect- Var ← valeur L’opérateur est : « = » [> e = factorial(5) print("le périmètre du cercle de rayon", R,
ation [>var = valeurs [>e "est ", C, "et la surface du même cercle est ", S)
120 Version 2:
LIRE(var1) [>var1 = input() [>nom = input() from math import *
LIRE(var2) [>var2 = input() [>annee = int(input())
print("entrer la valeur du rayon")
[>var = input(" texte ")
R = float(input())
[>poids = float(input())
Entrée C = 2 * pi * R
Ou [>NM = input(" Donner
S = pi * R * R
ECRIRE(" texte ") [> print(" texte ") valeur de NM: ")
print("le périmètre du cercle de rayon", R,
LIRE(var) [>var = input()
"est ", C, "et la surface du même cercle est ", S)
ECRIRE("texte", [> print("la note de maths est
Sortie [> print("texte", var)
égale à ", NM)
var,…)
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.
3ème Partie : 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
STRUCTURES telle sorte à n’offrir que deux réponses :
CONDITIONNELLES 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) Exemple : Calcul de surface OU de circonférence d’un

A chacune des deux réponses peut correspondre une ou plusieurs cercle (version1)
instructions pouvant être (1) des instructions de base, (2) des
structures de contrôle ou (3) des appels à des « Actions ».
ALGORITHME Circ_Surface_Cercle //Version recommandée dans ce cas
Remarque: A l’une des alternatives peut ne correspondre CONSTANTE Pi=3.14
aucun traitement! VARIABLE R, Circ_Cercle, Surf_Cercle :réel choix : caractère
DEBUT
Le format général d’une structure conditionnelle s’exprime comme Ecrire("donner le rayon du cercle") Lire(R)
suit : 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
oui Surf_Cercle ← R * R * Pi
SINON {choix ici est forcément égal à ‘C’ ou ‘c’}
FINSI
SI condition ALORS instructions1
SINON instructions 2 Si choix =‘S’ ou choix =‘s’ ALORS
Ecrire("la surface du cercle de rayon", R, "est = ", Surf_Cercle)
FINSI SINON {choix ici est forcément égal à ‘C’ ou ‘c’}
non Optionnelle Ecrire("la circonf. du cercle de rayon", R, "est = ", Circ_Cercle)
FINSI
FIN
Exemple : Calcul de surface OU de
Exemple : Calcul de surface OU de circonférence circonférence d’un cercle avec des « Si »
d’un cercle avec des « Si » séquentiels (version2) séquentiels (version3)
ALGORITHME Circ_Surface_Cercle //Version non recommandée dans ce cas
CONSTANTE Pi = 3.14
VARIABLE R, Circ_Cercle, Surf_Cercle :réel choix : caractère CONSTANTE Pi=3.14
DEBUT VARIABLE R, Circ_Cercle, Surf_Cercle :réel choix : caractère
Ecrire("donner le rayon du cercle") Lire(R) DEBUT
Ecrire("donner votre choix") Lire(choix) Ecrire("donner le rayon du cercle") Lire(R)
Si choix =‘S’ ou choix =‘s’ ALORS Ecrire("donner votre choix") Lire(choix)
Début
SI choix =‘S’ ou choix =‘s’ ALORS Surf_Cercle ← R * R * Pi FINSI
Surf_Cercle ← R * R * Pi
Ecrire("la surface du cercle de rayon", R, "est = ", Surf_Cercle) SI choix =‘C’ ou choix =‘c’ ALORS Circ_Cercle ← 2*Pi*R FINSI
Fin SI choix =‘S’ ou choix =‘s’ ALORS
FINSI Ecrire("la surface du cercle de rayon", R, "est = ", Surf_Cercle)
Si choix =‘C’ ou choix =‘c’ ALORS FINSI
Début
SI choix =‘C’ ou choix =‘c’ ALORS
Ecrire(« Circonférence du cercle de rayon", R, "est =",Circ_Cercle) Ecrire("la circonf. du cercle de rayon", R, "est = ", Circ_Cercle)
Fin FINSI
FINSI FIN
FIN N.B.: Cette solution est moins conseillée car la machine effectue un test
NB: ici on regroupe chaque type de traitement avec leur affichage du inutile => dans ce cas les versions 1 et 2 sont meilleures.
résultat
La condition (1/2) La condition (2/2)

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

conditions sont vraies simultanément; • ((X>5) ET (X<10)) OU (NON(X>=5) ET (X>0))
Exemple : (X>5) ET (X<=10) • (le feu est rouge) ET (le passage est fermé)
• Si (condition1 OU condition2) => vraie lorsque l’une
des deux conditions est vraie;
Exemple : (X>=5) OU (X<1)
L’Instruction L’Instruction (cas 1)
Instruction Cas1 : Absence de traitement correspondant à l’une des deux
alternatives :
Absence de traitement associée à la réponse NON:
Appels à des SI condition ALORS
Vide Actions instructions1
(Voir chapitre4) FINSI
Elémentaire Absence de traitement associée à la réponse OUI => dans
Structures
ce cas prendre la négation de la condition:
Répétitives/Itératives
Bloc Cas4 (Voir chapitre suivant) SI NON(condition) ALORS
D’opérations instructions2
Structures FINSI
Conditionnelles
L’Instruction (cas2 et cas3)

L’Instruction (cas1) Cas2 : les instructions 1 et 2 sont simples.
Exemple : Algorithme qui Calcule la somme des inverses de X
et Y: Séquence d’un algorithme Séquence d’un algorithme
calculant le Sup: affichant le Sup:
ALGORITHME CalculSomInverseXY
VARIABLE X,Y: entier SomI: réel SI X>Y ALORS Sup←X SI X>Y ALORS Ecrire("le sup est", X)
DEBUT SINON Sup←Y SINON Ecrire("le sup est", Y)
Ecrire("donner deux entiers") FINSI FINSI
Lire(X) Lire(Y)
Cas3 : Bloc d’instructions encadré par DEBUT et FIN.
SI X≠0 ET Y≠0 ALORS SomI ← 1/X +1/Y FINSI
Si X≠0 et Y≠0 ALORS SI X>Y ALORS
Ecrire("la somme des inverses de ", X, "et", Y, Début
"est égale à ", SomI) Sup ←X Inf ←Y
SINON Fin
Ecrire("impossible de calculer la somme des SINON
inverses de ", X, " et ", Y) Début
FINSI Sup ←Y Inf ←X
FIN Fin
FINSI
Équivalence en structures
L’Instruction (cas4) séquentielles du cas 4
SI condition1 et condition2
Cas4: Structure conditionnelle imbriquée ou emboîtée.
ALORS Instruction_c1_c2 N.B: Dans ce cas, la version
SI condition1 ALORS FINSI imbriquée est meilleure car si
SI condition2 ALORS SI condition1 et non(condition2)
Instruction_c1_c2 les conditions 1 et 2 sont
ALORS Instruction_c1_non(c2)
SINON vérifiées, la machine teste les
FINSI
Instruction_c1_non(c2) 3 autres alternatives
FINSI SI non(condition1) et condition3
inutilement.
SINON ALORS Instruction_non(c1)_c3
SI condition3 ALORS FINSI Conclusion : Lorsque l’ensemble
Instruction_non(c1)_c3 SI non(condition1) et d’intersection entre les
SINON non(condition3) différentes conditions est {Ø},
Instruction_non(c1)_non(c3) ALORS
FINSI les structures conditionnelles
Instruction_non(c1)_non(c3)
FINSI séquentielles doivent être
FINSI
utilisées.
1ère Année Académie Militaire –
A.U. 2019/2020 1ère Année Académie Militaire – Informatique – Chapitre 1 33/110 A.U. 2019/2020 Informatique – Chapitre 1 34/110
Exemple1 (1/2) Exemple1 (2/2): Détaillant

ALGORITHME CalculSomInverseXY
d’avantage l’affichage
VARIABLE X,Y: entier SomI : réel 1. ALGORITHME CalculSomInverseXY
DEBUT 2. VARIABLE X,Y: entier SomI : réel
Ecrire("donner deux entiers ") 3. DEBUT
Lire(X,Y) 4. Ecrire("donner deux entiers") Lire(X) Lire(Y)
5. SI X≠0 ET Y≠0 ALORS SomI ← 1/X + 1/Y FINSI
SI X≠0 ALORS 6.
7. SI X≠0 ET Y≠0 ALORS
SI Y≠0 ALORS SomI ← 1/X + 1/Y FINSI
8. Ecrire("la somme des inverses de", X, "et", Y,
FINSI 9. "est égale à ",
" SomI)
10. SINON {plus de précision sur l’origine du problème}
Si X≠ 0 et Y≠ 0 ALORS 11. SI X≠ 0 Alors Ecrire("Calcul impossible car Y est nul")
Ecrire("la somme des inverses de ", X, 12. SINON
"et", Y, "est égale à ", SomI) 13. SI Y ≠ 0 ALORS Ecrire("Calcul impossible X =0")
SINON 14. Sinon Ecrire("Calcul impossible car X et
Ecrire("impossible de calculer la somme des Y égaux à 0")
15. FINSI
inverses de ", X, " et ", Y)
16. FINSI
FINSI 17. FINSI
FIN 18.FIN
Structure conditionnelle en
Exemple 2 : Résolution de Ax+B=0
1. ALGORITHME sol_prem_degre
Python (1/2)
2. VARIABLE A,B,x : réel Drapeau : entier
1. if condition:
3. DEBUT
4. Ecrire("Donner les coefficients de l’équation: ") 2. bloc_instruction1
5. Lire(A,B) 3. else:
6. SI A=0 ALORS 4. bloc_instruction2
7. SI B=0 ALORS drapeau ← 0
8. SINON drapeau ← -1 FINSI
9. SINON DEBUT x ← -B/A La condition est une expression booléenne composée d'opérateurs
10. drapeau ← 1 relationnels, d'opérateurs logiques et des verbes logiques ((True,
11. FIN False).
12. FINSI
13. SI drapeau = 1 ALORS L'évaluation de la condition doit donner True ou False, autrement une
14. Ecrire("la solution de l’équation", A,"* x +", B,
15. "=0 est x=", x) erreur se produit.
16. SINON
17. SI drapeau = -1 ALORS Ecrire("pas de solution") La clause else s'exécute lorsque l'évaluation de toutes les
18. SINON Ecrire("infinité des solutions") conditions précédentes donne False. Cette clause est optionnelle.
19. FINSI
20.
21.FIN
FINSI
ATTENTION : Python est sensible à la casse.
Structure conditionnelle en Python (2/2) Indentation signifiante (1/2)

Si l’instruction1 et (ou) l’instruction2 est à son tour une
structure conditionnelle, la structure s’écrit alors : Un bloc est une suite d’instructions qui s’exécutent les unes
après les autres.
1. if condition_1:
2. bloc_instruction_1 Pour identifier sans ambiguïté les instructions appartenant
3. else: au bloc du if, il est nécessaire de les indenter.
4. if condition_2:
5. bloc_instruction_2 Indenter signifie ajouter un même nombre d’espaces devant
6. else: chacune des lignes définissant les instructions.
7. bloc_instruction_3
Alors que dans certains langages cette pratique n’est qu’une
La structure peut s’écrire encore en remplaçant else if par elif : recommandation,
Elle est une obligation dans Python!
1. if condition_1:
2. bloc_instruction_1 On peut se fixer par convention qu’une indentation est
3. elif condition_2: constituée de quatre espaces (ou un simple appuis sur la
4. bloc_instruction_2 touche Tabulation).
5. else:
6. bloc_instruction_3
Indentation signifiante (2/2) Exemple (1/3)
1. #cette ligne a un niveau d'indentation de 0 Le programme suivant exécute trois instructions différentes
suivant la valeur de x % 3:
2. #cette ligne a un niveau d'indentation de 1
3. #cette ligne a un niveau d'indentation de 2 1. #ici, les trois instructions
1. if x % 3 == 0 :
2. #sont au même niveau.
2. x = x + 1
Au sein d’un bloc, le niveau d’indentation doit être le même. 3. else: 3. if x % 3 == 0 :
Le code suivant est valide et la ligne y = y // x ne s’exécute que si x 4. if x % 3 == 1 : 4. x = x + 1
est non nul : 5. elif x % 3 == 1 :
5. x = x – 1
1. if x != 0: 6. else: 6. x = x – 1
2. y = 3 7. x = 2 * x 7. else:
3. y = y // x # division entière
8. x = 2 * x

Exemple (2/3) Exemple (3/3)

1. #programme pour la résolution de l’équation Ax+B=0
1. X = int(input("Donner entier X: ")) 2. A = float(input("Donner le coefficient A: "))
2. Y = int(input("Donner entier Y: ")) 3. B = float(input("Donner le coefficient B: "))
3. if X != 0 and Y != 0:
4. if A == 0:
4. SomI = 1/X + 1/Y 5. if B == 0: drapeau = 0
5. print("la somme des inverses de", X, "et", 6. else: drapeau = -1
7. else:
6. Y, "est égale à ", SomI) 8. x = -B/A
B/A
7. elif X != 0: 9. drapeau = 1
8. print("Calcul impossible car Y est nul") 10.#affichage en fonction de la valeur de « drapeau »
11.if drapeau == 1:
9. elif Y != 0: 12. print("Sol. de l’équation",A,"*x+",B,"=0 est x=",x)
10. print("Calcul impossible car X = 0 ") 13.elif drapeau == -1:
14. print("pas de solution")
11.else:
15.else:
12. print("Calcul impossible car X et Y égaux à 0") 16. print("infinité de solution")
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:
4ème Partie : L’utilisateur doit répondre par ‘S’ ou ‘C’. Mais il risque fort, tôt
ou tard, de taper autre chose que cela!
STRUCTURES ITÉRATIVES Si on veut se protéger en cas d’erreur, il faudrait
ET RÉPÉTITIVES conditionner la saisie à l’aide de structures conditionnelles.
Problématique : Exemple1 (suite) Problématique : Exemple2

...
Ecrire ("Donner votre choix: S pour surface et C On veut calculer la somme de N entiers.
pour circonférence") X←1
Lire (choix)
S←0 S←0
Si choix <> ‘S’ ET choix <> ’C’ Alors
Début
S ← S+x x←1
Ecrire ("Saisie erronée à refaire") x ← x+1 (x=2)
Lire (choix ) S ← S+x S ← S+x
Si choix <> ‘S’ ET choix <> ’C’ Alors x ← x+1 (x=3) x ← x+1
Début …
Ecrire ("Saisie erronée. Recommencez") Arrêter la boucle
boucler
Lire (choix ) x ← x+1 (x=N) quand x > N

. . . S ← S+x
Fin
FinSi On remarque que le même traitement se répète un certains nombre de
Fin fois.
FinSi … Problème : combien d’instructions séquentielles va-t-on écrire ?
MAIS !!! Combien de structures conditionnelles (Si … FinSi)? 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
D’où le besoin d’utiliser des structures répétitives. besoin d’utiliser des structures itératives.
Définitions (1/3) Définitions (2/3)
En général, lorsque plusieurs opérations se répètent: Les boucles permettent ainsi d’exécuter une séquence
nous représentons celles-ci par une même séquence d’instructions soit un certains nombre de fois :
d’instructions Connu d’avance. Exemple : calcul du Nème terme d’une suite.
et nous répétons l'exécution de la séquence plusieurs fois. Non connu d’avance. Exemple : le contrôle de saisie de données
L’exécution de toute séquence d’instructions répétitive ou itérative qui consiste à vérifier que les valeurs des données entrées au
est une boucle. clavier correspondent bien à celles attendues par l’algorithme.
Un traitement répétitif ou itératif peut être vu comme un traitement La séquence d’instructions peut être :
conditionnel: Une répétition : Le passage courant dans la boucle est
qu’on exécute un certains nombre de fois connu, indépendant du passage précèdent.
ou non connu d’avance (y compris zéro fois) selon la valeur de Exemple : calcul des moyennes des étudiants (la même
la condition. 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).
Les Différentes Structures

Définitions (3/3) Répétitives/Itératives (1/2)
Une itération : chaque passage dans la boucle est dépendant
Trois formes existent :
du passage précèdent.
Ainsi, une itération permet de calculer une valeur par étapes La structure TANTQUE … FIN_TANTQUE
successives (la valeur calculée à une étape est dépendante S’exécute un certain nombre de fois (ou zéro fois), connu ou
de la valeur déterminée aux étapes précédentes).
non, d’avance.
Exemples :
La structure REPETER … JUSQU’À
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 S’exécute un certain nombre de fois (au moins une), connu ou
initial. non, d’avance.
Un passage dans la boucle est une exécution une fois de
La structure POUR … FIN_POUR
l’ensemble des opérations se trouvant dans la boucle (qu’il
s’agisse d’une itération ou d’une répétition). 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 Boucle conditionnelle
Répétitives/Itératives (2/2) TANTQUE … FIN_TANTQUE
Cette structure s’applique aussi bien dans le cas où le nombre de
TRES IMPORTANT : passages dans la boucle (c.à.d. itération ou répétition) est connu ou
inconnu d’avance:
Chaque structure répétitive/itérative se caractérise par :
une initialisation,
…
une condition, Initialisation
TANTQUE (condition d’EXECUTION est vraie) FAIRE
une séquence logique d’instructions.
oui
Instructions (incluent au moins une instruction
qui change la valeur de la condition)
Toute modification de l’une des trois caractéristiques
nécessite une vérification des deux autres. FIN_TANTQUE
… non
Exemple de Calcul du produit des N premiers Exemple de Calcul du produit des N premiers
entiers positifs avec TANTQUE (1/2) entiers positifs avec TANTQUE (2/2)
ALGORITHME Produit
VARIABLE P, N, x : entier ALGORITHME Produit_2 ALGORITHME Produit_3
VARIABLE P, N, x : entier VARIABLE P, N, x : entier
DEBUT
DEBUT DEBUT
ECRIRE(" Donner N > 0: ") ECRIRE("Donner N > 0") ECRIRE("Donner N > 0")
LIRE(N) LIRE(N) LIRE(N)
TANTQUE (N<=0) FAIRE TANTQUE (N <= 0) FAIRE TANTQUE (N <= 0) FAIRE
ECRIRE(" Donner N > 0: ") ECRIRE("Donner N > 0") ECRIRE("Donner N > 0")
LIRE(N) LIRE(N) LIRE(N)
FIN_TANTQUE FIN_TANTQUE FIN_TANTQUE
x ← 1 x ← N x ← 0
P ← 1 P ← 1
P ← 1
TANTQUE (x > 0) FAIRE TANTQUE (x < N) FAIRE
TANTQUE (x <= N) FAIRE P ← P * x x ← x + 1
P ← P * x x ← x - 1 P ← P * x
x ← x + 1 FIN_TANTQUE FIN_TANTQUE
FIN_TANTQUE ECRIRE("Le produit des", ECRIRE("Le produit des",
ECRIRE(" Le produit des ",N, " entiers est ", P) N, "entiers est P=", P) N, "entiers est P=", P)
FIN FIN FIN

Caractéristiques de la Structure
TANTQUE Remarques importantes
ALGORITHME Somme_Pairs L’exécution pour N=10 est :
La condition peut être simple ou complexe. VARIABLE S, N, i: entier S=0+2+4+6+8+10
DEBUT => arrêt de la boucle pour la
Les instructions sont exécutées tant que la condition est toujours ECRIRE(" Donner N > 0 ")
Vraie. valeur de i=10
LIRE(N)
TANTQUE N<=0 FAIRE L’exécution pour N=9 est :
Si dès le départ la condition n’est pas vérifiée alors la structure ECRIRE(" Donner N > 0 ") S=0+2+4+6+8+10+12+…
répétitive (ou itérative) n’est jamais exécutée (exécutée 0 fois). LIRE(N) => boucle infini car le « i » n’est
FIN_TANTQUE
L’exécution de la structure répétitive (ou itérative) s’arrête dès que jamais égal à N=9
i ← 0
la condition cesse d’être vérifiée. S ← 0 En conclusion il faut que la
Lorsque la condition cesse d’être vraie, l’algorithme exécute TANTQUE i <> N FAIRE condition perche par excès et
i ← i + 2 utiliser :
l’instruction qui suit la structure répétitive ou itérative (si elle existe) S ← S + i
ou arrêt de l’exécution. 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 Terminaison d’une boucle

Syntaxe d’une boucle while: Dans l’exemple précédent:
while condition:
La variable « C » joue le rôle d’un compteur
bloc_instructions
Au départ « C » contient le nombre des itérations à faire
Exemple: Calcul factoriel de N
La condition d’arrêt test si le « N » itération ont été faites
1. N = int(input("Donner N > 0: "))
2. while N<=0: Mathématiquement, la fin de la boucle est garantie:
3. N=int(input("Donner N > 0: "))
La valeur de « C » est un entier strictement positif;
4. C = N
5. P = 1 Elle décroît strictement après chaque itération.
6. while C > 0:
Et comme il n’existe pas de suite infinie strictement
7. P = P * C
décroissante d’entier naturels,
8. C = C - 1
9. print(" Le factoriel de ",N, “ est ", P) Il ne peut y avoir qu’un nombre fini d’itérations.
Invariant de boucle (1/2) Invariant de boucle (2/2)
Il s’agit de démontrer qu’une boucle produit l’effet attendu au c = n pour toute « i » on a pi=2n-ci et ci≥0
moyen d’un invariant, c’est-à-dire une propriété:
p = 1
Pour i=0: p0=1=20=2n-c0 et
Qui est vérifiée avant d’entrer dans la boucle, while c > 0 : c0=n ≥0
Si elle est vérifiée avant une itération, est vérifiée après p = p * 2
celle-ci, pi+1=2pi=2n-ci+1=2n-ci+1 et
c = c – 1 ci+1=ci-1 => pi=2n-ci
Lorsqu’elle est vérifiée en sortie de boucle permet d’en
Soit ci et pi à l’itération « i » Or ci>0 => ci+1 ≥0
déduire que le programme est correct.
Exemple: 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,
Démontrer que le programme de calcul de « 2n » suivant est donc pi=2n-ci => pi=2n
correct, c.-à-d. lorsque l’exécution se termine, la variable « p » = ci - 1 et pi+1 = 2Pi
contient bien la valeur « 2n » où « n >0 » est la valeur initiale de Et on remarque que la => La subtilité de ce
la variable « c ». propriété suivante est raisonnement tient dans le
toujours vérifiée, choix de bon invariant!

Boucle conditionnelle Exemple de Calcul du produit des N

REPETER … JUSQU’A premiers entiers positifs avec REPETER
La structure REPETER … JUSQU’A s’applique aussi bien dans 1. ALGORITHME Produit
le cas où le nombre de passages dans la boucle est connu ou 2. VARIABLE P, N, x : entier
inconnu d’avance : 3. DEBUT
4. REPETER
5. ECRIRE("Donner N:")
… 6. LIRE(N)
Initialisation non 7. JUSQU'A (N > 0)
REPETER 8. x ← 1
9. P ← 1
Instructions (incluent au moins une instruction 10. REPETER
qui change la valeur de la condition) 11. P ← P * x
12. x ← x + 1
JUSQU’A (condition d’ARRET est Vraie) 13. JUSQU'A (x > N)
… 14. ECRIRE("Le produit des",N, "entiers est =", P)
oui 15. FIN
Caractéristiques de la structure REMARQUES IMPORTANTES
…
REPETER ALGORITHME Somme_Pairs i ← 2
La condition peut être simple ou complexe. VARIABLE S, N, i: entier S ← 0
DEBUT REPETER
Les instructions sont exécutées jusqu’à ce que la condition REPETER S ← S + i
d’arrêt devienne vraie. ECRIRE("Donner N") i ← i + 2
LIRE(N) JUSQU’À i > N
On exécute au moins une fois l’itération (ou la répétition) avant …
JUSQU'À (N > 0)
de vérifier la condition d’arrêt. PROBLEME : Si N=1 Alors S = 2.
i ← 2
S ← 0 Solution :
Les instructions sont exécutées tant que la condition est toujours
TANTQUE (i<=N) FAIRE …
à la valeur Faux. S ←0
S ← S + i
REMARQUE IMPORTANTE : i ← i + 2 Si N>1 Alors
FIN_TANTQUE Début i ← 2 , S ← 0
Un traitement exprimé avec TANTQUE ne peut pas être exprimé ECRIRE("La somme des REPETER
avec REPETER en inversant juste la condition (la négation). entiers pairs < à", N, S ← S + i
"est= ", S) i ← i + 2
Ceci n’est vrai que pour un traitement dont le nombre de JUSQU’À i > N
FIN
passages dans la boucle TANTQUE est au moins égal à une Fin
Remarque : Si N=1 Alors S=0.
fois. Finsi
… Militaire –
1ère Année Académie
Boucle répéter en Python Boucle inconditionnelle

POUR … FIN_POUR
Boucle croissante :
Ce type de boucle n’existe ...
pas en Python, mais on Exemple: Calcul factoriel de N Initialisation partielle
peut, facilement, là simulée while True:
POUR var de V_I à V_F FAIRE
par la technique suivante: N = int(input("Donner
N > 0: ")) (POUR var = V_I à V_F FAIRE)
Syntaxe d’une boucle répéter: if N > 0: Instructions
break FIN_POUR
1. while True: C = N ...
P = 1 Boucle décroissante :
2. bloc_instructions while True:
3. if condition: P = P * C ...
C = C - 1 Initialisation partielle
4. break if C <= 0: POUR var = V_I à V_F avec pas=-1 FAIRE
break
Instructions
print("Le factoriel de ",
N, " est ", P) FIN_POUR
...
A.U. 2019/2020 Informatique – Chapitre 1 67/110 A.U. 2019/2020 1ère Année Académie Militaire – Informatique – Chapitre 1 68/110
Caractéristiques de la structure POUR Exemple de Calcul du produit des N premiers
entiers positifs avec POUR croissante
La structure POUR…FIN_POUR (boucles à index numérique) 1. ALGORITHME Produit
ne s’applique que dans le cas où le nombre de passages dans 2. VARIABLE P, N, x : entier
la boucle est connu d’avance. 3. DEBUT
Les instructions encadrées par POUR et FIN_POUR sont 4. REPETER
exécutées : 5. ECRIRE("Donner N:")
6. LIRE(N)
(V_F – V_I + 1) fois, dans le cas d’une boucle croissante à 7. JUSQU'A N>0
condition que V_I <= V_F, autrement la boucle s’exécute 0 8. P ← 1
fois. 9. x ← 1 {pas d’initialisation manuelle de x}
(V_I – V_F + 1) fois, dans le cas d’une boucle décroissante 10. POUR x = 1 à N FAIRE
à condition que V_I >= V_F, autrement la boucle s’exécute 11. P ← P * x
0 fois. 12. x ← x + 1 {pas d’incrémentation manuelle de x}
13. FIN_POUR
Le pas est par défaut égal à 1 pour une boucle croissante et
14. ECRIRE("Le produit des",N, "entiers est =", P)
égal à -1 pour une boucle décroissante.
15.FIN
Exemple de Calcul du produit des N premiers Applications (1/3)

entiers positifs avec POUR décroissante
Exemple 1 : ALGORITHME AfoisB
VARIABLE P,A,B,i : entier
Ecrire un algorithme qui calcule DEBUT
1. ALGORITHME Produit le produit de deux nombres REPETER
2. VARIABLE P, N, x : entier entiers positifs par additions ECRIRE("Donner le
3. DEBUT successives du multiplicande multiplicande:")
LIRE(A)
4. REPETER autant de fois que nécessaire: JUSQU'A A>0
5. ECRIRE(" Donner N") A*B = A + A + … + A REPETER
6. LIRE(N) ECRIRE("Donner le
7. JUSQU'A N > 0 B fois multiplicateur:")
LIRE(B)
8. P ← 1 Exemple2 : JUSQU'A B>0
9. POUR x = N à 1 avec pas = -1 FAIRE Soit N couples de nombres P ← 0
10. P ← P * x entiers positifs, modifier POUR i=1 à B FAIRE
11. FIN_POUR l’algorithme pour qu’il calcule et P ← P + A
FIN_POUR
12. ECRIRE("Le produit des",N, "entiers est ", P) affiche au fur et à mesure le ECRIRE("Le produit de", A,"*",B,
13.FIN produit des 2 termes de chaque "par additions successives est =
couple selon le même principe. ",P)
FIN
Applications (2/3) Applications (3/3)
Exemple3 : Calcul de A fois B avec N couples en calculant la
ALGORITHME N_AfoisB somme des produits des différents couples.
REPETER
VARIABLE N,P,A,B,i,j: entier ECRIRE("Donner le ALGORITHME N_AfoisB REPETER
DEBUT multiplicateur") VARIABLE N,P,A,B,i,j,S_C : ECRIRE("Donner le
REPETER LIRE(B) entier multiplicateur:")
ECRIRE("Nombre de JUSQU'A B> 0 DEBUT LIRE(B)
couples?") P ← 0 REPETER JUSQU'A B>0
LIRE(N) POUR i=B à 1 avec pas =-1 ECRIRE("Le nombre P ←0
JUSQU'À N>0 FAIRE couples?") POUR i=1 à B FAIRE
j ← N P ← P + A LIRE(N) P ← P + A
TANTQUE j>0 FAIRE FIN_POUR JUSQU'A N>0 FIN_TANTQUE
REPETER ECRIRE("Le produit de", S_C ← 0 ECRIRE("Le produit de",
ECRIRE("Donner le A, "*", B, "par additions POUR j=1 à N FAIRE A, "*", B, "par additions
multiplicande") successives est = ",P) REPETER successives est =", P)
LIRE(A) j ← j - 1 ECRIRE("Donner le S_C ← S_C + P
JUSQU'A A>0 FIN_TANTQUE multiplicande:") FIN_POUR
FIN LIRE(A) FIN
JUSQU'A A>0
1ère Année Académie Militaire – 1ère Année Académie Militaire –
A.U. 2019/2020 Informatique – Chapitre 1 73/110 A.U. 2019/2020 Informatique – Chapitre 1 74/110
Structures Répétitives/Itératives en Structures Répétitives/Itératives en

Python (1/4) Python (2/4)
2- Exemple:
1- Syntaxe d’une boucle conditionnelle:
Le programme calculant 2n deviendra alors :
En Python, on écrit une boucle conditionnelle ainsi :
1. c = n
1. while condition:
2. p = 1
2. bloc_d_instructions #Corps de boucle
3. while c > 0:
4. p = p * 2
Les contraintes d’indentation pour le bloc d’instructions sont les
mêmes que pour une instruction conditionnelle, 5. c = c - 1
et la fin du bloc est marquée par le retour au niveau On va détailler l’exécution de ce programme à partir de l’état c = 3
d’indentation du while.
Après Après Après
itération Initial
Ce bloc d’instructions est appelé le corps de boucle et chaque itér.1 itér.2 itér.3
passage dans ce bloc est appelé une itération. p 1 2 4 8
c 3 2 1 0
Structures Répétitives/Itératives en Structures Répétitives/Itératives en
Python (3/4) Python (4/4)
4- Exemple:
3- Syntaxe d’une boucle inconditionnelle: Si on reprend le programme de calcul de 2n, on aura juste à écrire :
Les boucles conditionnelles sont nécessaires pour effectuer des 1. p = 1
calculs lorsqu’il n’est pas possible de borner le nombre d’étapes 2. for c in range(n):
nécessaires. 3. p = 2 * p # p *= 2
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 Le compteur de boucle est ici entièrement géré par la boucle for.
boucle conditionnelle. 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
En Python, on écrit une boucle inconditionnelle « for » ainsi : boucle.
Dans la boucle for c in range(n), la variable « c » parcourt les
1. for i in range(x):
entiers de 0 à n − 1.
2. bloc_d_instructions 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 Exemple en Python

Répétitives/Itératives en Algorithmique et Programme utilisant “while …” Programme utilisant “for …”
N = int(input(“Entrer N>0: ”)) #boucle répeter
Python 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 :
Algorithmique Python P=1 break
Pour var de v_i à v_f faire for var in range(v_i, v_f): while i<=N : P=1
instructions instructions P =P*i #boucle pour
i=i+1 for i in range(N) :
Fin_Pour
print("Le produit des ", N, "premiers P = P * (i + 1)
Tantque condition faire while condition: entiers positifs est P=", P) print("Le produit des ", N, "premiers
instructions instructions entiers positifs est P=", P)
Fin_Tantque Résultat de l’exécution
Répeter while True : Entrer N>0 : 0 Résultat de l’exécution
instructions instructions entrer de nouv. N>0 : 0 Entrer N>0: -6
entrer de nouv. N>0 : -5 Entrer N>0: 0
Jusqu'à condition if condition:
entrer de nouv. N>0 : 5 Entrer N>0: 4
break Le produit des 5 premiers entiers Le produit des 4 premiers entiers positifs
positifs est P= 120 est P= 24

A.U. 2019/2020 Informatique – Chapitre 1 79/110 A.U. 2019/2020 1ère Année Académie Militaire – Informatique – Chapitre 1 80/110
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,
5ème Partie : - 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
CRÉATION ET tels que les tableaux.
MANIPULATION DES Exemple : Pour ranger les longueurs des mois d’une année non
bissextile, on utilise le tableau suivant :
TABLEAUX 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éfinition d’un tableau à une

Définitions dimension (1/2)
Chacune des valeurs (des cases) est repérée par son rang ou Un tableau de nom « T » et de longueur « N » est une suite de
sa position appelé encore indice. « 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
Exemple : pour accéder à la valeur 28 on donne l’indice 2. supérieure (à définir).
« [ ] » représente l’opérateur de sélection d’éléments.
Dans le cas où l’indice est unique, on parle de tableau à une La variable « T[i] » s’appelle l’élément d’indice « i » ou encore le
dimension (monodimensionnel) ou vecteur.
vecteur ième élément du tableau « T ».
Dans le cas où un élément est repéré par 2 indices, le tableau Tous les éléments « T[i] » sont de même type.
est dit à deux dimensions (bidimensionnel) ou encore
Un tableau à une dimension où l’indice inférieur vaut « 1 » et
matrice. l’indice supérieur vaut « N » se présente comme suit :
Lorsqu’un élément est repéré par N indices, le tableau est dit à T[1] T[2] … T[i] … T[N-1] T[N]
T
N dimensions (ce cas dépasse le cadre de ce cours).
indices 1 2 i N-1 N
Définition d’un tableau à 1D (2/2) Déclaration d’un tableau à 1D (1/3)
Jusque-là, nous avons considéré qu’un tableau commence
Un tableau est une variable qui doit avoir un nom, un nombre
forcément par l’indice « 1 » jusqu’à l’indice « N » pour simplifier le
d’éléments (borne_sup - borne_inf + 1) et un type qui représente
discours mais ceci n’a rien d’obligatoire algorithmiquement.
le type de ses éléments.
En effet, la borne inférieure d’un tableau (éventuellement la
Il est nécessaire de déclarer un tableau avant sa première
borne supérieure) peut être négative mais forcément inférieure à
utilisation.
la borne supérieure.
Cette déclaration peut se faire directement dans la partie
De manière générale, un tableau à une dimension ayant (bsup –
variable,
binf + 1) éléments se présente comme suit :
Ou en définissant un type tableau dans la partie type et
T[binf] T[binf+1] … T[i] … T[bsup-1] T[bsup] déclarer ensuite la variable de ce type défini comme suit:
Exemples: Type NomType = tableau [borne_inf .. borne_sup]
[binf .. bsup] = [-10 ..-1] [binf .. bsup] = [-10 ..10] de type des éléments
[binf .. bsup] = [-10 .. 0] [binf .. bsup] = [ 0 ..10]
[binf .. bsup] = [1 ..10] etc.
Déclaration d’un tableau à 1D (2/3) Déclaration d’un Tableau à 1D (3/3)

Il est préférable d’utiliser la deuxième déclaration surtout avec la
Si « Tab » est une variable « tableau » pouvant contenir programmation modulaire (utilisation des types définis dans les
« N » entiers (avec borne_inf = 1 et borne_sup = N) alors la entêtes des procédures et fonctions).
déclaration de Tab peut se faire: Possibilité 1:
soit : 1. Constante N = 30 C = 6
1.Constante N = valeur 2. Variable Tab_note, Tab_moy: tableau [1..N] de réel

3. Tab_coeff: tableau [1..C] d’entier
2.Variable Tab : tableau [1 .. N] d’entiers
Soit encore : Possibilité 2:
1.Constante N = valeur 1. Constante N = 30 C = 6
2. Type TNote = tableau [1..N] de réel
2.Type TABENT = tableau [1..N] d’entiers
3. TCoeff = tableau [1..C] d’entier
3.Variable Tab : TABENT 4. Variable Tab_note, Tab_moy : TNote
5. Tab_coeff : TCoeff
Manipulation d’un tableau à 1D Remplissage d’un tableau à 1D
Si T est un tableau à « N » entiers, défini comme un tableau Dans la suite, on suppose avoir effectué les déclarations suivantes :
[1..N] d’entier avec « N » constante déjà défini.
une constante Nmin=1 Nmax=10
L’accès à la case d’indice « i » se fait par T[i].
un type Tab1 = tableau [Nmin..Nmax] de entier
Lorsque l’indice « i » est inférieur à « 1 » ou supérieur à « N
« x » et « y » représentent respectivement la borne « inf » et la
», T[i] génère une erreur.
borne « sup » de début et de fin de remplissage.
La variable « T[i] » peut être manipulée comme n’importe
Procédure Remplir_Tab Remplissage complet
quelle variable scalaire : (S T: Tab1,
Tab1 Algorithme Remplir_Complet
Lire(T[i]) Ecrire(T[i]) E x, y: entier) Constante Nmin=1 Nmax=10
Variable i : entier Type Tab1=tableau[Nmin..Nmax]
T[i] ← valeur T[i] ← T[i]+T[i-1] Début d’entier
Pour i = x à y Faire Variable V:Tab1 …
Si T[i] > T[i-1] Alors …. Ecrire (‘donner
Remarque importante : Attention, les instructions de lecture, T[‘,i,’]=’) Début …
d’écriture et d’affectation ne sont pas applicables au tableau T. Lire(T[i]) Remplir_Tab(V, Nmin, Nmax)
FinPour …
Lire(T) Ecrire(T) T ← valeur Fin Fin
Affichage d’un tableau à 1D Définition d’un Tableau à deux

Affichage du contenu d’un tableau: dimensions – 2D (1/2)
Procédure Affich_Tab (E T: Tab1, E x, y: entier) Hypothèse : On suppose que la borne inférieure des lignes et celle
des colonnes vaut 1.
Variable i: entier
Un tableau à deux dimensions de nom « T » a « L » lignes et « C »
Début
colonnes est une suite de L*C variables T[i,j] où l’entier « i » varie
Pour i = x à y Faire entre « 1 » et « L » et l’entier « j » varie entre « 1 » et « C ».
Ecrire (‘T[‘,i,’]=’, T[i]) Lorsque L=C le tableau est dit carré. On appelle ordre le nombre
FinPour des éléments des lignes ou des colonnes.
Fin La variable « T[i,j] » s’appelle l’élément d’indice « i » et « j » du
Appels : tableau « T ».
Affichage complet : Le premier indice est l’indice des lignes et le deuxième est celui
des colonnes.
Affich_Tab(T,1,Nmax)
Tous les éléments « T[i,j] » sont de même type.
Affichage partiel :
De manière générale un tableau à deux dimensions « 2D » se
Affich_Tab(T,1,p) avec p < Nmax
présente comme suit :
Définition d’un Tableau à 2D (2/2) Déclaration d’un Tableau à 2D
jème Un tableau à deux dimensions (matrice) doit être déclaré en
colonne précisant son nom, le type de ses éléments, le nombre de ses
lignes (L) et celui de ses colonnes (C).
T[1,1] T[1,2] … T[1, j] … T[1, C]
Cette déclaration se présente comme suit :
T[2,1] T[2,2] … T[2, j] … T[2, C] 1. Constante L=valeur1 C=valeur2
… … … … 2. Type nomtype = tableau[1..L,1..C] type
3. des éléments
ième T[i,1] T[i,2] … T[i, j] … T[i, C] 4. Variable T : nomtype ...
ligne
Exemple :
… … … …
1. Constante L=5 C=5
T[L,1] T[L,2] … T[L, j] … T[L, C] 2. Type Tab2d = tableau [1..L, 1..C] d’entier
3. Variable T : Tab2d ...
Remplissage d’un tableau à 2D ligne

Manipulation d’un tableau à 2D
par ligne
Si T est un tableau à L*C éléments, défini par exemple comme
un tableau [1..L,1..C] de réel, alors : Dans la suite, on suppose que les déclarations suivantes sont déjà définies :
constante L=10 C=7
L’accès à la case d’indice « i » et « j » se fait par T[i,j] ; type Tab2 = tableau [1..L, 1..C] de réel
Si « i » ou « j » est à l’extérieur des bornes, T[i,j] génère une
1. Procédure Remplir_Tab_L (S T: Tab2, E x, y: entier)
erreur ; 2. Variable i, j: entier
La variable T[i,j] peut être manipulée comme n’importe 3. Début
quelle variable scalaire, 4. Pour i = 1 à x Faire
5. Pour j = 1 à y Faire
c.à.d. que les instructions de lecture, d’écriture et 6. Ecrire (‘donner T[‘,i,’,’,j,’]=’)
d’affectation sont applicables aux différentes cases du 7. Lire(T[i,j])
tableau et non pas au tableau « T » lui-même : 8. FinPour
9. FinPour
Lire(T[i,j]) Lire(T)
10.Fin
Ecrire(T[i,j]) Ecrire(T) Appels :
remplissage complet : Remplir_Tab_L(M, L, C)
T[i,j] ← valeur 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 6ème Partie :
3. Début
4. Pour i = 1 à x Faire
5. Pour j = 1 à y Faire NOTION DE COÛT D'UN
6.
7.
Ecrire (‘T[‘,i,’ ,’,j,’]=’, T[i,j])
FinPour
ALGORITHME ET CLASSES
8. FinPour DE COMPLEXITÉ
9. Fin
Coût d’algorithme (1/2)

Coût d’algorithme et complexité Coût d’algorithme = ∑ coûts d’opérations élémentaires
+ ∑ coûts d’opérations complexes
Coût des opérations élémentaires:
Evaluer un algorithme revient à mesurer sa complexité.
Opérations élémentaires: affectation, lecture/écriture,
La complexité d’un algorithme dépend: opérations arithmétiques, test de comparaison…
Coût d’exécution =1
de la complexité temporelle (temps d’exécution)
Exemple Algorithme A:
et de la complexité spatiale (taille des données).
1. Somme n + 1
Temps de calcul ou d’exécution est noté: 2. Somme somme ∗ n
O de f(n): fonction asymptotique. 3. Somme somme/2

=> coût(A) = 3 (3 affectations)
Il dépend du nombre d’opérations.
ou = 6 si le calcul détaillé (3 affectations + une addition +
multiplication + division)
Coût d’algorithme (2/2) Complexité temporelle vs
spatiale (1/2)
Coût d’opérations complexes:
Exemple : échange de deux valeurs entières
Opération complexe: instruction conditionnelle ou boucle ou
appel de module. // (1) échange des valeurs // (2) échange des
de deux variables entier x, valeurs de deux variables
coût (inst_cond) = coût (test) + max (coût(T1),coût(T2)) entier x, y;
y à travers tmp;
coût (boucle Pour) = n * ∑ coût(inst(i)) ... // initialisation de x ... // initialisation de
coût (boucle TantQue) = n*∑ coût(inst(i))+coût(comparaison) et y x et y
coût(module) = ∑ coûts (opérations élémentaires internes)
Exemple Algorithme B: tmp <- x; x <
<- y-x;
1. TantQue i <= n faire x <- y; y <- y-x;
2. Somme Somme + i y <- tmp; x <- y+x;
3. i i + 1 La première méthode utilise une variable supplémentaire « tmp » et
4. FinTantQue réalise 3 affectations
⇒ coût (B) = 3n (n comparaisons + 2n affectations) La deuxième méthode n'utilise que les deux variables dont on veut
ou = 5n si calcul détaillé (n comparaisons + 2n affectations échanger les valeurs, mais réalise 3 affectations et 3 opérations
+ 2n additions)
Complexité temporelle vs spatiale

Complexité asymptotique
(2/2)
Calculer la complexité de façon exacte n'est pas raisonnable vu
L'efficacité d'un algorithme peut être évalué en temps et en la quantité d'instructions de la plupart des programmes
espace :
et n'est pas utile pour pouvoir comparer deux algorithmes.
Complexité en temps : évaluation du temps d'exécution de
l'algorithme,
Complexité en espace : évaluation de l'espace mémoire
Première approximation : on ne considère souvent que la
occupé par l'exécution de l'algorithme.
complexité au pire,
Espace-temps : en général pour gagner du temps de calcul, on
doit utiliser davantage d'espace mémoire. Deuxième approximation : on ne calcule que la forme
générale de la complexité,
On s'intéresse essentiellement à la complexité en temps (ce qui
n'était pas forcément le cas quand les mémoires coutaient cher) Troisième approximation : on ne regarde que le
comportement asymptotique de la complexité.
Domination asymptotique (1/2) Domination asymptotique (2/2)
Soitent « f » et « g » étant deux fonctions,
La notation O, dite notation de Landau, vérifie les propriétés
« f = O(g) » s'il existe des constantes c>0 et n0 suivantes :
telles que f(x) < c*g(x) pour tout x > n0 : 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
f = O(g) signifie que « f » est dominée
ln(x) = O(x) car pour x>0, ln(x)<x
asymptotiquement par « g ».
Classes de complexité (1/3) Classes de complexité (2/3)
O(1) : complexité constante, pas d'augmentation du temps O(n log(n)) : complexité quasi-linéaire, augmentation un peu
d'exécution quand le paramètre croit, supérieure à O(n).
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
Exemple : algorithmes qui décomposent un problème en d'autres plus simples, traités indépendamment et qui
un ensemble de problèmes plus petits (dichotomie). combinent les solutions partielles pour calculer la solution
O(n) : complexité linéaire, augmentation linéaire du temps générale.
d'exécution quand le paramètre croit (si le paramètre double,
le temps double). O(n2) : complexité quadratique, quand le paramètre double,
Exemple : algorithmes qui parcourent séquentiellement le temps d'exécution est multiplié par 4.
des structures linéaires.
Exemple : algorithmes avec deux boucles imbriquées.
Classes de complexité (3/3) Exemples
O(ni) : complexité polynomiale, quand le paramètre double, Exemple 1: Exemple 2:
le temps d'exécution est multiplié par 2i . n=int(input("Donner n:") n=int(input("Donner n:")
for i in range(15): for i in range(n):
Exemple : algorithme utilisant « i » boucles imbriquées. print(2*i) print(i)
O(in) : complexité exponentielle, quand le paramètre 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
double, le temps d'exécution est élevé à la puissance 2.
et elle ne comporte que 2 qu’une opérations élémentaires
opérations élémentaires (affichage)
O(n!) : complexité factorielle, asymptotiquement
(multiplication + affichage)
équivalente à nn 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)

Chapitre 1 - Rappel Algo - Imprimable - 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

Chapitre 1 - Rappel Algo - Imprimable - v1.7

Transféré par

Droits d'auteur :

Formats disponibles

Académie militaire - Fondouk Jedid Plan

Cycle préparatoire - Bouficha

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

Définition et Propriétés d’un

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

NOTION 2. les données en entrée et

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

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

Déclaration des objets/actions définies

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

Structure d’un Algorithme (2/2) Algorithme : Les déclarations

parties dont l'ordre doit être respecté :

Structures répétitives/itératives 2. La déclaration des actions définies par l’utilisateur

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

le type entier (entiers relatifs), le type réel, le type 2ème Partie:

La valeur est une instance quelconque de l’ensemble de

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

Opérations Elémentaires: Opérations Elémentaires:

des données dont le format est :

Traduction en Python Exemple1 en Python

Définition et Structure (2/2) Exemple : Calcul de surface OU de circonférence d’un

La condition (1/2) La condition (2/2)

• Si (condition1 ET condition2) => vraie lorsque les deux Exemples :

L’Instruction (cas2 et cas3)

Exemple1 (1/2) Exemple1 (2/2): Détaillant

Structure conditionnelle en Python (2/2) Indentation signifiante (1/2)

1ère Année Académie Militaire –

Exemple (2/3) Exemple (3/3)

Reprenons l’exemple du calcul de la surface ou de la

STRUCTURES ITÉRATIVES Si on veut se protéger en cas d’erreur, il faudrait

ET RÉPÉTITIVES conditionner la saisie à l’aide de structures conditionnelles.

Problématique : Exemple1 (suite) Problématique : Exemple2

Lire (choix ) x ← x+1 (x=N) quand x > N

Les Différentes Structures

1ère Année Académie Militaire –

1ère Année Académie Militaire –

Boucle while en Python Terminaison d’une boucle

1ère Année Académie Militaire –

Boucle conditionnelle Exemple de Calcul du produit des N

Boucle répéter en Python Boucle inconditionnelle

Exemple de Calcul du produit des N premiers Applications (1/3)

Structures Répétitives/Itératives en Structures Répétitives/Itératives en

Correspondance entre les Structures Exemple en Python

1ère Année Académie Militaire –

Définition d’un tableau à une

Déclaration d’un tableau à 1D (2/3) Déclaration d’un Tableau à 1D (3/3)

1.Constante N = valeur 2. Variable Tab_note, Tab_moy: tableau [1..N] de réel

Affichage d’un tableau à 1D Définition d’un Tableau à deux

Remplissage d’un tableau à 2D ligne

1. Procédure Affich_Tab (E T: Tab2, E x, y: entier)

Coût d’algorithme (1/2)

O de f(n): fonction asymptotique. 3. Somme somme/2

Complexité temporelle vs spatiale

Classes de complexité (1/3) Classes de complexité (2/3)

Donc la complexité est O(1)

Vous aimerez peut-être aussi