Cours Algorithme On Structur Ée

Office de la formation Professionnelle et de la promotion du travail
DRPS/ISGI LAAYOUNE
Le 12/10/2020
Filière : Techniques de Développement Informatique
Module : Programmation structurée
Proposé par :Abdelmounaim BENDAOUD
Programmation structurée Page 1 sur 109

Table des matières
Rôle des algorithmes en Informatique. ..................................................................6
ALGORITHMES :..................................................................................................6
La structure générale d’un algorithme: .................................................................7
L’entête de l’algorithme : .......................................................................................8
Les données de l'algorithme :.................................................................................8
I. Le concept de variable : ................................................................................8
1. Type d’une variable: .....................................................................................9
2. La valeur d’une variable ...............................................................................9
Les types primitifs de DONNEES : ....................................................................10
1. Les types numériques .................................................................................. 10
Opérations définies sur les entiers : ......................................................................10
les opérateurs de comparaison : ............................................................................ 10
Opérations définies sur les types Réel : ................................................................11
Déclaration d’une variable : .................................................................................14
Les expressions : ..................................................................................................15
Expressions arithmétiques : ..................................................................................15
Instructions de base :............................................................................................18
L’affectation .........................................................................................................18
Les instructions d’entree /sortie ...........................................................................18
Activité :...............................................................................................................22
Module : Techniques de Programmation Structurée. ..........................................25
LES STRUCTURES DE CONTROLES .............................................................30
1. Structures de contrôle conditionnelles :.....................................................30
a- L’instruction Si :......................................................................................... 30

b- L’instruction Si…..Sinon ........................................................................... 31
c- Si ….SinonSi…..Sinon................................................................................ 33
La structure de branchement Selon…Cas : ..........................................................34
DESCRIPTION DE L’ACTIVITÉ ......................................................................38
LES STRUCTURES DE CONTROLE REPETITIVES (BOUCLES) : .............41
LA BOUCLE Faire….TantQue:..........................................................................41
La boucle TantQue….Faire (while).....................................................................45
La boucle JUSQU’À .............................................................................................48
La boucle Pour ......................................................................................................49
Les instructions de rupture de séquences : sortir (break) et continue . .................51
CHAPITRE 6 LES STRUCTURES DE DONNEES ..........................................57
Les tableaux : .......................................................................................................57
i. Tableau à une dimension : ........................................................................57
1. Concepts de base : ......................................................................................57
a. Syntaxe de déclaration : ............................................................................57
b. Accès à un élément : ..................................................................................57
2. Algorithmes de base : ...............................................................................59
2.1 Lecture au clavier d’un tableau (tous les éléments) ..............................59
2.2 Lecture au clavier d’un tableau (selon le besoin de l’utilisateur) ........59
2.3 Affichage des éléments ..............................................................................60
2.4 La somme des éléments d’un vecteur : ...................................................61
2.5 La somme de deux vecteurs :.....................................................................61
2.6 Multiplication par un scalaire ...................................................................61
2.7 Produit scalaire de deux vecteurs : ...........................................................62
2.8 Recherche de l’indice de la première occurrence d’une valeur v : .........62

2.10 Algorithme de la rechercher du maximum : .........................................64
2.11 Algorithme de suppression d’un élément ..............................................64
2.12 Algorithme d’insertion d’une valeur à une position : ..........................65
2.13 Algorithme qui inverse l’ordre des éléments :.......................................66
2.14 Algorithme d’éclatement en deux selon une condition : ......................66
Algorithmes de tri ................................................................................................68
Tri par échange : ...................................................................................................68
Tri à bulles ............................................................................................................69
Tri par insertion : ..................................................................................................70
Tri par sélection des minimums successifs :.........................................................71
Tri par comptage :.................................................................................................71
Tableaux à deux dimensions (matrices) :.............................................................73
1. Notations de base: ......................................................................................73
a. Syntaxe de déclaration ............................................................................... 73
b. Exemple : .................................................................................................... 73
c. Accès à un élément :................................................................................... 73
d. Exemples ..................................................................................................... 74
e. Parcourir une matrice : ................................................................................ 74
2. Algorithmes de base : ...............................................................................75
2.1 Lecture au clavier : ..................................................................................... 75
2.2 Affichage à l’écran : ................................................................................... 76
2.3 Somme des éléments d’une matrice ........................................................... 76
2.4 Trace d’une matrice (somme des éléments de la diagonale principale) : 77
2.5 Somme de deux matrices ............................................................................ 77
2.6 Construction de la matrice unitaire ........................................................... 78

I. Les structures (Enregistrements) : ..........................................................84
1. Définition : .................................................................................................84
2. Syntaxe de déclaration : ............................................................................85
3. Variables structure: ...................................................................................85
4. Accès aux champs : ...................................................................................86
5. Structures imbriquées :..............................................................................87
6. Champ de type tableau : ............................................................................88
7. Tableaux de type structure (Table) : .........................................................88
I. Fonction : ...................................................................................................94
1. Déclaration d’une fonction : .....................................................................94
a. Syntaxe : ..................................................................................................... 94
b. Exemple :.................................................................................................... 95
c. Les paramètres : ......................................................................................... 95
d. La valeur de retour :................................................................................... 95
2. L’appel d’une fonction : ............................................................................95
3. Exécution d’une fonction : ........................................................................95
II. Les procédures : ........................................................................................97
1. Définition : .................................................................................................97
2. Syntaxe : .....................................................................................................97
3.1 Passage de paramètres par valeur : ...........................................................98
3.2 Passage de paramètre par adresse ou référence : ..................................100

Rôle des algorithmes en Informatique.
Qu’est-ce qu’un algorithme ? En quoi l’étude des algorithmes est-elle utile ? Quel est le rôle des
algorithmes par rapport aux autres technologies informatiques ? Ce chapitre a pour objectif de répondre
à ces questions.
ALGORITHMES :
Voici une définition informelle du terme algorithme : procédure de calcul bien définie qui prend en entrée
une valeur, ou un ensemble de valeurs, et qui donne en sortie une valeur, ou un ensemble de valeurs. Un
algorithme est donc une séquence d’étapes de calcul qui transforment l’entrée en sortie. L’on peut aussi
considérer un algorithme comme un outil permettant de résoudre un problème de calcul bien spécifié.
L’énoncé du problème spécifie, en termes généraux, la relation désirée entre l’entrée et la sortie.
L’algorithme décrit une procédure de calcul spécifique permettant d’obtenir cette relation entrée/sortie.
Supposons, par exemple, qu’il faille trier une suite de nombres dans l’ordre croissant. Ce problème, qui
revient fréquemment dans la pratique, offre une base fertile pour l’introduction de nombre de techniques
de conception et d’outils d’analyse standard. Voici comment nous définissons formellement le problème
de tri : Entrée : suite de n nombres (a1, a2, ..., an). Sortie : permutation (réorganisation) (a1’, a2’, ..., an’)
de la suite donnée en entrée, de façon que a1’<= a2’ <= ··· <=an’ .
Ainsi, à partir de la suite (25, 45, 59, 62, 41, 28), un algorithme de tri produit en sortie la suite (25, 28, 41,
45, 59, 62). À propos de la suite donnée en entrée, on parle d’instance du problème de tri. En général, une
instance d’un problème consiste en l’entrée (satisfaisant aux contraintes, quelles qu’elles soient,
imposées dans l’énoncé du problème) requise par le calcul d’une solution au problème.
➢ Le mot algorithme provient de la forme latine algorismus du nom du mathématicien

arabe Alkhawarizmi. Ce dernier a formulé une première définition :’’un algorithme est
une séquence d’actions visant à la résolution d’un problème en un temps fini’’.
Nous pouvant adopter la définition suivante :un algorithme est une suite finie
d'instructions (opération, action) élémentaires, ordonnées permettant la résolution
d’un problème bien défini.

➢ Une instruction est une opération élémentaire qu’un ordinateur peut exécuter (exemples :
Affichage d’un message, addition de deux nombres, évaluation d’une condition…).
➢ Un programme : Traduction d’un algorithme dans un langage de programmation

particulier.
➢ Le développeur ou programmeur : c’est la personne qui conçois l’algorithme et écrit le

programme.
➢ L’utilisateur ou client : c’est le destinataire du programme, c'est lui qui exprime un besoin
d’informatisation d’un processus. Pour simplifier c’est lui qui va utiliser le programme (fournir les
données d’entrées pour avoir des sorties).
➢ Les données d’entrées d’un algorithme sont les données que l’utilisateur doit fournir (saisir au
clavier) à l’algorithme pour que ce dernier produise les résultats souhaités (les sorties de
l’algorithme).
La structure générale d’un algorithme:

Un algorithme comporte toujours deux parties. L’entête et lecorps :
Algorithme Nom
Partie déclaration des données Entête
Début
Instructon1
Instructon2
… Corps
….
InstructonN
Fin

L’entête de l’algorithme :
C’est une partie déclarative où on précise le nom de l’algorithme, ce nom est
précédé par le mot clés Algorithme.
Pour garantir une meilleure lisibilité, il est préférable que le nom de l’algorithme reflète l’objectif de
l’algorithme. Par exemple un algorithme de résolution d’une équation de second degré est intitulé :
Algorithme Equation De second degré.
On trouve en suite la déclaration des données de l’algorithme, précédée du mot Variables ou constantes si il
s’agit d’une donnée constante.
 L’ajout des commentaires à un programme est une bonne pratique, elle a pour
objectif de donner des explications qui facilitent la compréhension de
l’algorithme.
Un commentaire doit être mis entre /* commentaire */ si il est formé de plusieurs lignes, et après // si
il s’agit d’une seule ligne de commentaire.
Une instruction mise en commentaire est ignorée (ne sera pas exécutée)
Les données de l'algorithme :

La plupart des problèmes nécessitent le traitement de valeurs : certaines sont données dans l’énoncé,
d’autres sont le résultat des calculs issus de l’exécution de l’algorithme. Une troisième catégorie de valeurs
intermédiaires nous servira pour calculer les résultats intermédiaires.
Les valeurs (informations) pour pouvoir être manipulées, sont stockées dans des variables.
I. Le concept de variable :
Une variable, en informatique, est un emplacement dans la mémoire centrale
(RAM), réservé avec une déclaration, pour stocker une valeur utilisée par les instructions
du programme (donnée d’entrée, de sortie ou intermédiaire).
La RAM
RAM
variable valeur
Une variable est définie par trois caractéristiques : identificateur, type, et valeur à
un instant donné.
1. L’identificateur d’une variable :

C’est le nom que le programmeur attribue à la variable. Il permet d’identifier la
variable dans l’algorithme.
Pour faciliter la lecture de l’algorithme, l’identificateur doit être représentatif de ce que la

variable va contenir. En revanche, il ne doit pas non plus être trop long pour ne pas nuire à la
lisibilité de l'ensemble.
Un identificateur doit respecter les règles suivantes :
-il ne doit pas être un mot clés (réservé au langage utilisé)
-Il doit commencer obligatoirement par une lettre (_est considéré comme une lettre)
-Il est composéuniquement de lettres (non accentués) et de chiffres (A…Z
,_,a….z,0…9).
Exemple :
Je veux mémoriser l'âge d'une personne dans une variable, j'ai le choix de l'appeler la variable
utilisée :
a , âge, age, ageDeLaPersonneDontJeSuisEntrainDeParler
Remarque:
Le premier nom est trop court, si je n'ai pas lu la description plus haut, je suis totalement
perdu. Le deuxième cas ne convient pas non plus car on évitera tout caractère accentué dans
les noms de variable. Le dernier cas est certes très précis, mais tellement long qu'il en devient
illisible. Bref, le troisième cas semble le plus approprié
Exercice :
Classer ces mots en identificateurs valides et non valides.
MoY,cmp1,3note,nbr
stag,prix_unitaire,quantité,id.client,adr/mail,mc<L,mAx,Min(math).
1. Type d’une variable:

Le type (appelé aussi domaine de définition) de la variable indique l’ensemble des
valeurs que la variable peut prendre.
Le type de la variable définit :

• La nature des informations qui seront stockées dans la variable
• La taille en mémoire
• Les opérations réalisables avec les variables correspondantes.
2. La valeur d’une variable :
C’est le contenu de la variable dans un instant donné. Cette valeur change au cours de l’exécution des
instructions d’où le nom variable.
Si elle ne change pas, même d’une exécution à une autre, en parle de constante.

Remarque importante :
La durée de vie (porté) d’une variable est la durée de l’exécution du bloc d’instruction où elle est déclarée.
Les types primitifs de DONNEES :

Nous pouvons classer les données selon 3 grandes classes en fonction de la nature des valeurs qu'elles
peuvent prendre :
• les données numériques

• les données alphanumériques
• les données logiques.
1. Les types numériques
Le type numérique caractérise les valeurs entières ou réelles.
a) Entier :
Une variable est dite entière si elle prend ses valeurs dans Z (ensembles des nombres entiers
relatifs).
Opérations définies sur les entiers :
symbole description
Operation
addition
+
- soustraction
multiplication
*
Division n div p : la division entière de n par p donne la partie
Div
entière du quotient.
entière
ou
//
Division n mod p : la division modulo de n par p donne le reste de
mod la division entière.
modulo
les opérateurs de comparaison :
opération symbole

Strictement supérieur >
strictement inférieur <
inférieur ou égale <=
supérieur ou égale >=
égale =
différent <>
Exemples:
12 div 3 = 4
13 div 3 = 4
12 mod 3 = 0
13 mod 3 = 1
b)Réel: représente l’ de valeurs prises dans R (ensembles des nombres réels).
Exemple :
247 = 2.47
Opérations définies sur les types Réel :

o Opérateurs arithmétiques :
Opération Symbole Description
addition
+
soustraction
-
* multiplication
division
/
o les opérateurs de comparaison (relationnels) :

Operation symbole
=
égal
<> ou ≠
Différent

>=
Supérieur ou égal
>
Supérieur
<
Inferieur
<=
Inferieur ou égal
Les types alphanumériques

Le type alphanumérique caractérise les valeurs caractère (notées Caractère) ou chaîne de caractères
(notées Chaîne)
a)Caractère : sa valeur est un caractère quelconque. Un caractère peut appartenir au domaine des chiffres
de ‘0’ à ‘9’, des lettres de ‘A’ à ‘Z’ (majuscules ou minuscules) et des caractères spéciaux (‘+’ ‘-‘ ’,‘ ’;’ ‘.’
‘(‘ ‘{‘ ‘[‘ ‘]’ ‘}’ ‘)’ ‘$’ ‘%’...). Un caractère sera toujours noté entre des apostrophes. Le caractère blanc
(espace) s’écrit ‘ ‘, le caractère apostrophe ‘’’.
Les opérations qu’on définit sur les données de type caractère sont :
Operation symbole
Égal =
Different <> ou ≠
supérieur ou égal >=
supérieur >
inférieur ou égal <=
inférieur <
Les quatre dernières représentent un ordre entre les caractères qui est le suivant :
‘ ‘< ‘0’ < ‘1’ < ... < ‘9’ < ‘A’ < ‘B’ < ... < ‘Z’ < ‘a’ < ‘b’ < ... < ‘z’
Cet ordre est déterminé par la codification ASCII.
Remarque :
Les minuscules et les majuscules sont considérées comme des caractères différents.
b) Chaîne :
Une chaine est une suite finie de caractères quelconques.
Une variable chaîne peut être vide, si elle est de longueur nulle, et sera notée : '’'’ . Si cette dernière est
égale à 1, la variable est considérée aussi comme Car.
Exemples :
‘'BONJOUR’' '’CECI EST UN EXEMPLE'’ ‘’A’’ ‘’9’’.

❖ Les opérations définies sur les variables de type Chaîne sont celles des variables de
type Car.
ChaîneA<ChaîneB: si le mot contenu dans ChaîneAest 'inférieur' à celui de ChaîneB dans le sens du
dictionnaire; (inférieur : avant ; supérieur : après).
Exemples:
‘'BAL'’< '’BALLES’' < '’BALLON'’< '’BA' ‘< '’Ba' <‘'ba' ‘
❖ De plus, il existe une autre opération définie sur les variables chaîne, la
concaténation (notée & ou +). Elle crée une nouvelle chaine en juxtaposant deux
ou plusieurs chaines.
Exemple :
‘‘TELE'’&'’VISION'’ = '’TELEVISION’'
Le type logique(booleen)
En programmation informatique, un booléen est un type de variable à deux états (généralement
notés vrai et faux), destiné à représenter les valeurs de vérité de la logique et l'algèbre
booléenne. Il est nommé ainsi d'après George Boole, fondateur dans le milieu du XIXe siècle de
l'algèbre portant son nom. Le type de données booléen est principalement associé à des
états conditionnels.
Une variable logique (ou booléenne) peut prendre l’une des deux valeurs vrai ou faux (true or false). Elle
intervient dans l'évaluation d'une condition.
Les opérations définies sur les variables de type logique sont la négation, l'intersection et l'union.
a) La négation (notée :non)
Soit A une variable booléenne :
b) L'intersection (conjonction) (notée : et)(and,&,*)
Soient A et B : deux variables booléennes :

c)L'union disjonction (notée :ou) (Or,||,+)
Soient A et B : deux variables booléennes :
Exercice :
Proposer un type pour ces variables :
nombreGroupes,Age,PrixUnitaire,Quantité,TVA,nom,adresse,moyenne,classement,clientEnregistrer,salai
re,Absent,Télé,CIN,sexe, est_Adulte
Déclaration d’une variable :

Une variable doit être déclarée dans l’entête de l’algorithme avant son utilisation.
Pour déclarer une variable on utilise la syntaxe suivante :
Variables identificateur : type
Cette déclaration a pour conséquence de réserver un emplacement dans la mémoire portant le nom :
identificateur, dont la taille dépend du type de la variable.
Exemple :
Variables
Reponse : booléen
Chain1 : Chaîne[30] //Chain1 est une chaîne de 30 caractères
Rep : Car

i, j : entier
etat : booléenne
a, b, c : réel
Remarque 1 : lorsque il s’agit de plusieurs variables ayant le même type on peut les déclarées toutes dans
une seule instruction.
Remarque 2 : Si il s’agit d’une constante dont le contenu est fixé et ne sera pas changé par aucune
instruction de l’algorithme en parle d’une constante, la syntaxe de déclaration est la suivante :
Constante identificateur valeur
Exemple :
Constante pi3.14
Les expressions :
Ceux sont des combinaisons entre des variables et des constantes à l'aide d'opérateurs. Elles expriment un
calcul ou une relation, selon qu'elles sont arithmétiques (algébriques) ou logiques.
Expressions arithmétiques :
Une expression est dite arithmétique si elle présente une opération arithmétique telle que la somme, la
multiplication, la division…
Exemple :
Var1 * 54.5 /(2+pi)
L’ordre selon lequel se déroule chaque opération du calcul est important. Afin d'éviter les ambiguïtés dans
l'écriture, on se sert des parenthèses et d’une hiérarchie entre les différents opérateurs arithmétiques.
Ordre de priorité des opérateurs arithmétiques :
En mathématiques, la priorité des opérations ou ordre des opérations précise l'ordre dans
lequel les calculs doivent être effectués dans une expression complexe.
Les règles de priorité sont :
1. les calculs entre parenthèses ou crochets sont prioritaires sur les calculs situés en
dehors. La barre horizontale de fraction ou de racine joue le rôle d'une parenthèse ;
2. L’exponentiation est prioritaire sur la multiplication, la division, l'addition et la
soustraction ;
3. la multiplication et la division sont prioritaires sur l'addition et la soustraction ;
4. dans les parenthèses, on effectue multiplications et divisions de gauche à droite. Même
chose ensuite pour additions et soustractions.
➢ ( ) parenthèses
➢ * / multiplication ou division
➢ + - addition ou soustraction

Remarque :
En cas de conflit entre deux opérateurs de même priorité, on commence par celui situé le plus à gauche.
Exemples :
a+b-c : on fait d'abord a + b, ensuite - c
a/b*c : on fait d'abord a / b, ensuite * c
- Soit l'expression algébrique suivante :
Sa forme algorithmique est la suivante :
(Power(( 3 - y * x ) , 2) - 4 * a * c ) / ( 2 * x - z )
Avec Power() la fonction puissance.
1. Expressions logiques
Ceux sont des combinaisons entre des variables et des constantes à l'aide d'opérateurs relationnels (=, <, =<,
>, >=, <>) et/ou des combinaisons entre des variables et des constantes logiques à l'aide d'opérateurs
logiques (Non ,et, ou).
Exemples :
Entier : A,B ,C
(A>B)
(B<=C+A)
Non(A>B)Et(A<>C)

Instructions de base :
L’affectation
C’est une instruction qui permet de copier (affecter) une valeur à une variable.
Syntaxe :
où :
ident: est l’identificateur d’une variable;
expression: valeur ou variable ou calcul ou appel d’une fonction.
Les deux parties de l’affectation doivent être de même type. (Ou de types adéquats)
Affectation Description
A 10 ; la valeur 10 à la variable A :
B A; Le contenu d’une variable A à une autre variable B
SN1+N2 La valeur de l’expression arithmétique à la variable S
TotN*2+100 Le résultat de l’expression arithmétique à la variable Tot
B(A<=C)Et(D>C) Le résultat de l’expression logique à la variable booléenne B
Les instructions d’entree /sortie

1. Instruction de sortie Ecrire() :
C’est l’instruction qui permet d’afficher un message à la sortie standard (l’écran) :
Syntaxe :
Ecrire(Message)
Où Message est soit :
➢ du texte :

Ecrire(‘’Salut tout le monde ‘’) afficher le message Salut tout le monde à
l’écran.
➢ une variable :
Ecrire(A) afficher la valeur de la variable A à l’écran.Si A contient la valeur
12
➢ Une expression arithmétique :
Ecrire(A+B) afficher le résultat de l’expression A+B
➢ Un combinaison des deux premiers cas :
Ecrire(‘’l’âge du client est ‘’,Age) où Age est une variable(la virgule joue le
role du caractère de concaténation, vous pouvez utilisez aussi +).
➢ Texte et expression :
Ecrire(‘’la somme est : ‘’,n1+n2)
Remarque :pour retourner à la ligne utiliser le caractère spéciale ‘\n’.
Exemple 1 :
Algorithme Etoiles
Var
Début
Ecrire(‘’*********************************Salut************************\n‘’)
Ecrire(‘’**** **** \n ‘’)
Ecrire(‘’$$$$$$$\n******************\n$$$$$$$$$\n’’)
Fin
Résultat de l’exécution :

Exemple 2 :
Algorithme Opérations
Var N1,N2,S :Réel
Début
Ecrire(‘’*********************************Salut************************\n‘’)
Ecrire(‘’C’est notre premier algorithme \n‘’)
N1123
N210
SN1*N2
Ecrire(‘’s= “,S,”\n”)
Ecrire(“La somme de “,N1,” + “, N2 ,” est : “,S,”\n”)
Ecrire (‘’ le somme est \n ‘’,S) ;
Fin
Le résultat de l’exécution sera :
Remarque : Il y a des auteurs qui utilise Afficher() comme instruction d’affichage.
L’instruction d’entrée Lire() :

C’est l’instruction qui bloque le programme en attendant que l’utilisateur saisie une valeur au clavier, cette
dernière sera enregistrer dans la variable passée en paramètre à Lire()après validation par la touche entrée
.
Syntaxe :
Lire(identificateur)
Où identificateur est le nom d’une variable déclarée.

Remarque :
On peut lire plusieurs valeur avec la même instruction lire( )
Lire(nom,age,groupe)
Exemple 1 :
Variable A :Entier
Lire(A) permet de récupérer l’entier saisi par l’utilisateur est le mettre dans la variable A
Cette instruction s’exécute comme suit :
-affichage d’un tiret qui invite l’utilisateur à saisir une valeur
-l’utilisateur saisie la valeur 12 par exemple
-l’utilisateur tape entrée, la valeur 12 sera stoker dans la variable A et l’ordinateur passe à l’exécution de
l’instruction juste après.
Exemple 2 :
Algorithme Soustraction
/* Cet algorithme montre qu’on peut lire les valeur de deux variable
Avec une seule instruction lire */
Var N1,N2 :réel
Début
Ecrire (‘’donner deux nombres ‘’) //demande des entrées
Lire(N1,N2) //lecture des entrées
DN1-N2 //Calcul
Ecrire(N1 , ‘’ – ‘’ ,N2 ,” = “,D) //affichage de la sortie.
Fin

Activité :
Détails sur les objectifs visés par l’activité
Cette activité d’apprentissage doit vous permettre de :
▪ Analyser les besoins et préciser l’objectif attendu du programme.
▪ Méthodologie pour concevoir un algorithme simple.
▪ Ecrire l’algorithme en pseudo-langage
DESCRIPTION DE L’ACTIVITÉ
Exercice 1 :
On vous demande d’écrire un algorithme qui permet de calculer le cube d’un entier.
Proposition d’une démarche :
1-Analyse de donnée
La démarche est la suivante :
Répondre aux questions suivantes :
Q1.quels sont les résultats attendus de cet algorithme ? (données de sortie)
R : un seul résultat : le cube d’un entier
Q2 .Quel est son type ? (typage des données de sortie)
R : C’est un entier
Q3.Quelles sont les données que l’utilisateur doit saisir pour pouvoir faire ce traitement? (entrées)
R : un nombre entier
Le schéma suivant illustre cette analyse:
2-Analyse de traitements :

Q-Quelles sont les traitements de base que cet algorithme doit réaliser pour répondre à son objectif ?
Réponse :
a. Réserver un espace mémoire pour chaque donnée.

b. Demander et lire les données d’entrée
c. Calculer le résultat
d. Afficher le résultat
3-Réalisation :
Il vous reste de décrire votre solution en langage algorithmique :
Algorithme Calcul cube
Variables N,Cube :Entier
Début
Ecrire(‘’cette algorithme calcule le cube d’un entier saisi par l’utilisateur \n’’)
//La demande et la lecture de l’entrée
Ecire(‘’Donner un nombre entier \n’’)
Lire(N)
//le calcul
CubeN*N*N
//Affichage du résultat
Ecrire (‘’le cube de ‘’, N , ’’ est : ‘’ ,Cube) ;
Fin
Exercice 2
On appliquant la même démarche, écrire un algorithme qui calcule la surface et le volume d’une boule.

Module : Techniques de Programmation Structurée .
Activité d’apprentissage 1:
▪ Déterminer le type d’une valeur donnée.
▪ Déclarer correctement une variable

▪ Initialiser une variable par une valeur
▪ Exécuter correctement un algorithme.
Exercice 1 :
Ecrire un algorithme qui permet d’affecter les valeurs suivantes à des variables(déclarations+Affectations) :
‘’TS’’,’’T’’,Vrai,’’Faux’’,12,’’123’’,’9’,Vrai,20 Mod 2, ‘’S2’’|| ‘’S’’,(A<=B)ET(C<>D),13.345, 12*2300
nom&’’ ‘’&’’ ‘’&prenom,124mod2,12div11
Exercice 2 :
Donnez la valeur de chaque variable après l’exécution de chaque instruction de l’algorithme ( au niveau de
la RAM) !
Algorithme Exécution séquentielle
Variable a,b,c :entier
C :charactère
ch,ch1 :chaine de caractères
con :booleen
Début
a10
b2
ch ‘’erreur’’

ch2ch& ‘’code 123’’
c (a+b)Mod 5
ab*c
b2*a+c
aa+1
ch2ch2&ch
C’C’
bb+2
Fin

Module : Techniques de Programmation Structurée.
▪ Analyser les besoins et préciser l’objectif attendu du programme.
▪ Déterminer les données en entrée, en sortie et les traitements nécessaires :
✓ Lecture
✓ Ecriture
✓ Affectation
▪ Réaliser un jeux d’essaie
Exercice 1 :
Écrire un algorithme qui permet de faire la somme, la soustraction, la multiplication et enfin la

division de deux nombres réels X et Y. Afficher tous les résultats.
Exercice 2 :
Algorithme qui demande le prix unitaire d’un produit, la quantité demandée, et
par la suite calcule et affiche le total à payer .sachant qu’on offre une remise de 3% sur
toutes les achats.

Exercice 3:
Algorithme qui affiche la résistance équivalente à trois résistances R1, R2, R3

(type réel),
- les résistances sont branchées en série:
Rsér = R1+R2+R3
-les résistances sont branchées en parallèle:
Exercice 4:
Ecrire une fonction qui convertit une température de degrés Celsius en degrés
Fahrenheit. Utiliser la formule de conversion suivante : °F = (( 9 x °C ) / 5 ) + 32
Exemple : 20° C = 68° F
Exercice 5:
Ecrire un algorithme qui permute (échange) les contenus de deux variables
Exemple
Avant permutation :
Après permutation :
Exercice 6 :
Quel est le résultat d’exécution de cet algorithme (Au niveau de l’écran) :
Algorithme Affichages

Variable i ,j:Entier
Début
i9 ;
Ecrire(i,’’\n’’) ;
Ecrire(‘’La valeur après incrémentation i=’’,i+1) ;
Ecrire(‘’\n*****\n’’) ;
ii-3 ;
j11 ;
Ecrire(i) ;
Ecrire(’’-’’) ;
ii*2+4-8/2 ;
Ecrire(i+j, ‘’\n’’) ;
Ecrire(i,’’+’’,j,’’=’’,i+j, ‘’\n’’) ;
ij
Ecrire(‘’********’’) ;
Fin

LES STRUCTURES DE CONTROLES
Nous allons introduire deux types d’instructions extrêmement utilisées qui permettent de
construire un algorithme au déroulement non linéaire. L’instruction conditionnelle permet
d’exécuter ou non un bloc d’instructions. Une boucle permet de revenir en arrière pour
réitérer l’exécution d’un bloc d’instructions un nombre de fois précis.
1. Structures de contrôle conditionnelles :

a- L’instruction Si :
L’instruction conditionnelle détermine si le bloc d’instructions suivant sera exécuter ou non selon la valeur
logique d’une condition.L’alternative n’a pas lieu.
Syntaxe :
Si (condition) Alors
Bloc d’instructions
FinSi
Principe de fonctionnement :
L’exécution du bloc d’instruction dépend de la valeur booléenne de la condition. Si la condition vaut
Vrai, le bloc d’instructions est exécuté, si la condition vaut Faux le bloc d’instructions est ignoré.
Il faut respecter l’indentation

Exemple :
Algorithme valeurAbsolue
Variables v ,a:Entier
Début
Ecrire(‘’Donnez un nombre SVP !’’) ;
Lire(v) ;
av
Si (a<0)Alors
a-1*a ;
FinSi
Ecrire(‘’la valeur absolue de ‘’,v,’’ est ‘’,a) ;
Fin
Test 1 :
Test 2 :
b- L’instruction Si…..Sinon
L’exécution d’une telle instruction consiste à évaluer l’expression (condition),si l’évaluation fournit Vrai
exécuter le bloc 1, sinon exécuter le bloc 2.Cette instruction est utilisée lorsqu’ il ya deux alternatives (un
choix à faire parmi deux blocs) et si seulement l’un d’eux qui sera exécuter.
Syntaxe :
Si (condition) Alors
Bloc d’instructions 1
Sinon
Bloc d’instructions 2
FinSi

Autrement:
Principe de fonctionnement :
Le bloc d’instruction exécuté dépend de la valeur booléenne de la condition. Si la condition vaut
Vrai, seul le bloc numéro 1 est exécuté et le bloc numéro 2 est ignoré. Si la condition vaut Faux, seul
le bloc d’instruction numéro 2 est exécuté.

Exemple :
c- Si ….SinonSi…..Sinon
Cette variante de la structure Si est utilisée lorsque le choix doit être fait entre trois blocs ou plus.
Syntaxe :
Si (condition1) Alors
Bloc 1
SinonSi(condition2) Alors
Bloc2
Sinon
Bloc3
FinSi
Exemple :

Exercice d’application :
Quel est l’objectif de l’algorithme suivant?
Algorithme Ex0
Variable A,B,AIDE :Réel
Début
Lire(A,B,C) ;
Si (A > B) alors
AIDE  A;
A  B;
B AIDE;
FinSi
Fin
La structure de branchement Selon…Cas :

La condition si….sinon que l'on vient de voir est le type de condition le plus souvent utilisé. Toutefois, le
si….sinon peut s'avérer quelque peu. . . répétitif. Prenons cet exemple :
Algorithme NomJour
Variable num :Entier
Début
Ecrire(‘’cet algorithme affiche le nom du jour dont le numéro est saisi au

clavier’’) ;
Ecrire(‘’donnez un numéro compris entrer 1 et 7 SVP !’’) ;
Lire(num) ;
Si(num=1) Alors
Ecrire(‘’Lundi’’) ;
SinonSi(num=2)Alors
Ecrire(‘’Mardi’’) ;
SinonSi(num=3)Alors
Ecrire(‘’Mercredi’’) ;
SinonSi(num=4)Alors
Ecrire(‘’Jeudi’’) ;
SinonSi(num=5)Alors
Ecrire(‘’Vendredi’’) ;
SinonSi(num=6)Alors
Ecrire(‘’Samedi’’) ;
SinonSi(num=7)Alors
Ecrire(‘’Dimanche’’) ;
Sinon
Ecrire(‘’numéro de jour non valide’’) ;
FinSi
Fin
Pour éviter d'avoir à faire des répétitions quand on teste la valeur d'une seule et même variable (sélecteur),
ils ont inventé une autre structure que le Si….Sinon.
Cette structure particulière s'appelle Selon…cas. Voici un Selon…cas basé sur l'exemple qu'on vient de
voir :
Algorithme NomJour_AvecSelonCas

Variable num :Entier
Début
Ecrire(‘’cet algorithme affiche le nom du jour dont le numéro est saisi au clavier’’) ;
Ecrire(‘’donnez un numéro compris entrer 1 et 7 SVP !’’) ;
Lire(num) ;
Selon(num)Faire
Cas 2 :Ecrire(‘’Mardi’’) ; sortir ;
Cas 1 : Ecrire(‘’Lundi’’) ; sortir ;
Cas 3 :Ecrire(‘’Mercredi’’) ; sortir ;
Cas 4 :Ecrire(‘’Jeudi’’) ; sortir ;
Cas 5 :Ecrire(‘’Vendredi’’) ; sortir ;
Cas 6 :Ecrire(‘’Samedi’’) ; sortir ;
Cas 7 :Ecrire(‘’Dimanche’’) ; sortir ;
defaut :Ecrire(‘’le numéro saisi n’est pas valide’’) ;
FinSelon
Syntaxe :
Selon (variableSélécteur) Fiare
Cas valeur1 :bloc d’instructions 1 ;Sortir ;
Cas valeur2 :bloc d’instructions 2 ;Sortir ;
……….
Cas valeurN :bloc d’instructions N ;Sortir ;
defaut :bloc par défaut
FinSelon
Principe :
Si variableSélécteur est égale à valeur1,le bloc d’instructions 1 est exécuté, et on passe à la suite de
l'algorithme (après finSelon),sinon on compare variableSélécteur avec la valeur suivante et ainsi de suite. Si
aucune valeur n’est égale à variableSélécteur le traitement par défaut est exécuté.
Remarques:
-La variable sélecteur doit être une variable de type : Entier ,Caractère ou chaine. Aucun autre type n’est
accepté.

-valeur 1,…valeur N sont les valeurs pour lesquelles il y a un traitement spécifique à exécuter.
-le mot clés sortir permet de quitter la structure selon..Cas, s’il est absent le bloc suivant est aussi exécuter.
-La structure Selon…Cas est très souvent utilisée pour faire des menus en console.

▪ Déterminer les instructions et la logique d’un programme

simple à l’aide d’un pseudo langage.
▪ Exprimer correctement des conditions simples
▪ Exprimer correctement des conditions complexes imbriquées
Exercice 1
La direction d’un supermarché a décidé d’accorder des réductions à ses clients selon le montant
d’achat.
La réduction est calculée selon les règles suivantes:
-20% pour un montant d’achat de plus de 5000 dhs
-15% pour un montant d’achat entre 3000 dhs<montant d’achat <= 5000 dhs
-10% pour un montant d’achat entre 1000 dhs <montant d’achat <= 3000 dhs
-Aucune réduction pour un montant d’achat inférieur à 1000 dhs.
Ecrire un algorithme qui permet de calculer et d’afficher la réduction et montant à payer
Exercice 2
Ecrivez un algorithme qui lit deux valeurs entières (A et B) au clavier et qui affiche le signe de la somme
de A et B sans faire l'addition.
Exercice 3
Ecrivez un algorithme qui calcule les solutions réelles d'une équation du premier degré ax+b=0

Exercice 4:
Il s’agit d’écrire un algorithme, qui demande le volume d’eau consommé et permettant d’afficher le prix
total à payer en dirhams .
La tarification se fait selon le tableau suivant :
Tanche Volume d’eau consommé en Prix à payer en Dirhams pour 1 m³

m³
Tanche 1 0 à6 2 .13
Tanche 2 6 à 20 7.21
Tanche 3 20 à 40 10.83
Tanche 4 Plus de 40 15.00
Remarque :la TVA du prix de l’eau potable est de 7%
(Prix_a_payer = prix_horsTax+prix_horsTax*TVA/100)
Exercice 5 :
Un entier naturel de trois chiffresest cubique s’il est égal à la somme des cubes de ses trois chiffres.
Exemple :153 est cubique car 153=1³+5³+3³
Ecrire un algorithme qui permet de décider si un entier naturel saisi au clavier est cubique ou non.
Exercice 6 :
Ecrire un algorithme qui affiche le menu suivant et exécute le traitement choisi par l’utilisateur.
Exercice 7 :
Ecrire un algorithme qui demande le poids acheté en Kg d’un produit , le prix

unitaire PU, la catégorie du produit (peut-être 1 ou 2 ou 3) et affiche le prix TTC
à payer :
le prix TTC= (PU*poids)*(1+TVA).

TVA=0,24 pour un produit de catégorie 1.

LES STRUCTURES DE CONTROLE REPETITIVES (BOUCLES) :
L’instruction de répétition, appelée boucle, permet d’exécuter plusieurs fois consécutives un même bloc
d’instructions. Le nombre de répétitions (itération) dépend d’une expression booléenne qui peut être soit
une condition d’arrêt soit une condition de continuité.
. Nous allons voir quatres types de boucles :
- Faire….TantQue
-TantQue….Faire
-Pour …..Faire
-Faire…….JUSQU A
Dans tous les cas, le schéma est le même :
LA BOUCLE Faire….TantQue:
La répétition s’effectue tant que la valeur de la condition de continuité est égale à Vrai.
Syntaxe :
Faire
Instruction1
Instruction2
…………
InstructionN
TantQue (Codition_De_Poursuite)

Exemple 1 :Demandez un nombre à l’utilisateur tant qu’il saisi zéro
Algorithme lireNombreNonNul
Variable nbr :réel
Début
Faire
Ecrire(‘’Donnez un nombre non nul SVP !’’) ; //demander le nombre
Lire(nbr) ; //lire le nombre
TantQue (nbr =0) //refaire le traitement si le nombre saisi est zéro
Ecrire(‘’Très bien ‘’,nbr,’’ est non nul’’) ; //Instruction exécuter une seule fois
Fin

Voici maintenant le test que j'ai fait. Notez que j'ai fait exprès de me tromper 3 fois avant de taper le bon
nombre.
Exemple2 :Algorithme qui affiche les chiffres de 1 à 100
Algorithme Chiffres
Variable c : Entier
Début
Ecrire(‘’Les chiffres de 1 à 10 : ‘’) ;
c 1 //initialisation du compteur c
Faire
Ecrire( c,’’-‘’) ; //afficher la valeur du compteur suivi de -
c c+1 //incrémenter le compteur (passer à la valeur suivante)
TantQue (c<=10) //Refaire le traitement si la condition est égale à Vrai
Fin
Comment ça marche exactement ?
1. Au départ, on a une variable compteur initialisée à 1. Elle vaut donc 1 avant la première itération.
2. on rentre dans la boucle (pas de condition à l’entrée).
3. On affiche la valeur du compteur suivi de -.
4. On incrémente la valeur de la variable compteur, compteur valait 1, elle vaut maintenant 2.
5. On arrive à la fin de la boucle (TanQue) . On fait le test du : Est-ce que compteur est toujours inférieure
ou égale à 10 ? .Si c’est oui, compteur vaut 2! Donc on recommence lesinstructions de la boucle.Et ainsi de
suite jusqu’à ce que la valeur du compteur soit 11 ;
Remarque :
-Dans le premier exemple le nombre d’itération n’est pas connu au démarrage de la boucle ,il dépend de
l’utilisateur ,tandis que dans le 2eme exemple le nombre d’itération est connu avant le démarrage de la

boucle c’est 10.Notez aussi l’utilisation d’un compteur (entier qui doit être initialisé avec une valeur de
départ ,incrémenté dans chaque itération).
-La boucle Faire..TantQue effectue l’évaluation de la condition après avoir effectué le premier tour de
boucle, c'est-à-dire que le bloc est exécuté au moins une fois.
-Il y a une autre variante de cette boucle qui utilise une condition d’arrêt qui est la négation de la condition
de continuité c’est la boucle Répéter….Jusque’à .
Algorithme ChiffresAvecRepeter
Variable c : Entier
Début
Répéter
Jusqu’à (c>10) // Quitter la boucle si la condition est égale à Vrai
Fin
Ecrire un algorithme qui affiche la table de multiplication d’un entier saisi au clavier.
Exemple :
Donnez un entier SVP
La table de multiplication de 4 est :
4 *1=4
4 *2=8
4 *3=12
4 *4=16
4 *5=20
4 *6=24
4 *7=28

4 *8=32
4 *9=36
4 *10=40
La boucle TantQue….Faire (while)

La répétition du bloc d’instruction est effectuée tant que la condition est. Cela vaut dire que la condition
est évaluée avant d’executer le boc d’instructions,
Répète la boucle tant que cette condition est vraie
On dit donc à l'ordinateur « Tant que la condition est vraie, répète les instructions entre
accolades »
Syntaxe :
TantQue (condition_DePoursuite) Faire
Instruction 1
Instruction 2
……
Instruction N
FinTantQue
Principe :

Tant que la condition est vraie, répète les instructions entre Faire et finTantQue.
Exemple 1 :Demandez un nombre à l’utilisateur tant qu’il saisi zéro
Algorithme lireNombreNonNul
Variable nbr :réel
Début
Ecrire(‘’Donnez un nombre non nul SVP’’) ;
Lire(nbr)
TantQue (nbr =0) Faire //Si le nombre est nul exécuter le bloc sinon quitter la boucle
Ecrire(‘’Vous avez saisi 0 .Donnez un nombre non nul SVP’’) ;
Lire(nbr) ;
FinTantQue //Evaluer à nouveau la condition
Ecrire(‘’Très bien le nombre saisi est non nul’’) ; //instruction exécutée une seule fois lorsque nbr !=0
Fin

Exemple2 :Algorithme qui affiche les chiffres de 1 à 10
Algorithme Chiffres
Variable c : Entier
Début
TantQue (c<=10) Faire //Exécuter le bloc si la condition est Vrai
FinTanQue //Evaluer la condition
Fin
Remarques :
R1-La condition d’arrêt :
Il est plus naturel de se demander ‘’quand la boucle s’arrête-t-elle ?’’ Que de déterminer la condition de
continuité ‘’tant que quoi la boucle continuera-t-elle ?’’.Pour écrire une boucle, prenez l’habitude :
1-De chercher la condition d’arrêt ;
2-D’écrire sa négation à l’aide du tableau de correspondance des conditions d’arrêt (à connaitre)

R2-Vous pouvez remarqués que la seule différence entre une boucle tantQue…Faire et Faire…Tanque est
que dans la première la condition est à l’entrée et dans la deuxième la condition est à la sortie.
c99 c99
TantQue (c<=10)Faire Faire
Ecrire( c,’’-‘’) ; Ecrire( c,’’-‘’) ;

cc+1 cc+1
FinTanQue TantQue (c<=10)
Le bloc ne sera jamais exécuté, aucun affichage à Le bloc est exécuté une seule fois, affichage de
l’écran 99-
Ecrire un algorithme qui affiche les diviseurs d’un entier saisi au clavier.
Exemple :
La boucle JUSQU’À
actions
condition
V

Avec la boucle jusqu’ a les actions correspondant sont toujours executées au moins une fois ;
la boucle jusqu a est equivalent a : repeter les actions jusqu’à la condition devient faux
La boucle Pour
C’est une boucle très utilisée en programmation pour réitérer une exécution un nombre de fois connu à
l’avance (existence d’un compteur), son avantage c’est qu’elle intègre l’initialisation et
l’incrémentation du compteur ,ce qui évite l’oubli de ces deux instructions.
Syntaxe :
Pour compteurValeurInitiale jusqu’à ValeurFinale Faire
Instruction1
Instruction2
-----------
InstructionN
FinPour
Principe :
1-Exécuter l’instruction d’initialisation:compteurValeurInitiale ;
2-Comparer la valeur du compteur avec ValeurFinale :
si compteur <= ValeurFinale :exécuterle bloc d’instructions et incrémenter le compteur

automatiquement(pas d’instruction d’incrémentation dans la boucle)
3-Comparer à nouveau la valeur du compteur avec ValeurFinale :
si compteur <= ValeurFinale le bloc d’instruction est exécuté une autre fois et le compteur est
incrémenté automatiquement, sinon (c'est-à-dire compteur =ValeurFinale+1) la boucle est quitté.
Exemple :
Algorithme Chiffres
Variable c : Entier
Début
Pour c1 jusqu à 10 Faire //initialisation du compteur c et le test
Ecrire( c,’’-‘’) ;//afficher la valeur du compteur suivi de –

FinPour //Incrémenter le compteur automatiquement et faire le comparer avec 10
Fin
Ecrire un algorithme qui affiche les entiers premiers compris entre VD et VF , avecVD et VF deux entiers
saisis au clavier.
Remarque : Les boucles imbriquées
Dans le corps d’une boucle, on peut avoir une ou plusieurs autres boucle s. L’imbrication des
boucles doit suivre les règles suivantes :
Soit l’exemple suivant qui permet d’afficher un rectangle formé d’étoiles (le nombre de lignesnbrL , et le
nombre de colonnes nbrC seront demandés à l’utilisateur)
Soit i et j deux compteurs. Pour afficher une ligne l’instruction Ecrire(‘’*’’) doit etre exécuter nbrC fois :
Pour j1 jusqu’à nbrC Faire
Ecrire(‘’*’’) ;
FinPour

Ce traitement d’affichage de ligne doit etre exécuter nbrL fois avec un retour à la ligne à la fin de chaque
itération de i :
Pour i1 jusqu’à nbrL Faire
Pour j1 jusqu’à nbrC Faire
Ecrire(‘’*’’) ;
FinPour
Ecrire(‘’\n’’) ;
FinPour
Notez l’utilisation de deux compteurs différents.
Les instructions de rupture de séquences : sortir (break) et continue .

Une boucle peut contenir une ou plusieurs instructions sortir dont le rôle est d’interrompre le déroulement
de la boucle, en passant à l’instruction qui suit cette boucle. En cas de boucles imbriquées, sortir fait sortir
de la boucle la plus interne. Si sortir apparaît dans un selon…Cas imbriqué dans une boucle, elle ne fait
sortir que du selon…Cas.
L’instruction continue s’emploie uniquement dans une boucle. Elle permet de passer prématurément à
l’itération suivante.
Une instruction de rupture de déroulement d’une boucle doit être mis à l’intérieur d’une structure
conditionnelle SI.
Exemple 1 :
Pour i1 jusqu’à 12 faire 1

Si(i=5)Alors 2
Sortir ; 3
FinSi 4
Ecrire(i,’’\n’’) ; sortir est exécuté lorsque i=5
FinPour
Ecrire(‘’sortir est exécuté lorsque i=’’,i)
Exemple2 :
Pour i1 jusqu’à 8 faire 1

Si(i=5)Alors 2
continue; 3
FinSi 4
Ecrire(i,’’\n’’) ; 6
FinPour 7
Ecrire(‘’sortir est exécuté lorsque i=’’,i) 8
sortir est exécuté lorsque i=9

Optimisation d’un algorithme :
A un même problème, différentes solutions algorithmiques peuvent être proposées. La première qualité
attendue d’un algorithme est sa terminaison c'est-à-dire qu’il n’admette une instance pour laquelle
l’exécution rentre dans une boucle infinie.
Un second critère permet de les comparer et ainsi d’en distinguer de meilleures que d’autres. Ce critère est
la faible utilisation de deux ressources :
-La mémoire : le nombre d’octets utilisé par l’exécution de l’algorithme.
-Le temps : qu’est évalué en considérant le nombre d’instruction élémentaires devant être exécutées.

▪Déterminer les instructions et la logique d’un programme simple à l’aide d’un

pseudo langage.
▪Exprimer des itérations
▪Construire des dialogues utilisateur pertinents
DESCRIPTION DE L ’ACTIVITÉ
Exercice 1 :
1-1)Écrire un algorithme qui demande un nombre de départ, et qui calcule la somme des entiers
jusqu’à ce nombre. Par exemple, si l’on entre 5, le programme doit calculer :
1 + 2 + 3 + 4 + 5 = 15
Répondre à cette question :
a)En utilisant la boucle TantQue…Faire
b)En utilisant la boucle Faire …..TantQue
c)En utilisant la boucle Répéter…Jusqu’à
d)En utilisant la boucle Pour…..
Exercice 2 :
Ecrire un algorithme qui lit les notes de N stagiaires ,et affiche la moyenne du groupe.Une note valide doit
être comprise entre 0 et 20.
Exercice 3:
3-1Un nombre parfait est un nombre entier naturel qui égale à la somme de ses diviseurs strict càd ses
diviseurs entiers positifs, autres qui lui-même.
Le premier nombre parfait est 6 , puisque la somme de ses diviseurs stricts 1,2,3 est égal à 6 (1+2+3=6)
Ecrire un algorithme qui cherche tous les nombres parfaits inférieurs à une limite donnée par l’utilisateur.

3-2Écrire un algorithme qui vérifie si un nombre entier saisi par l’utilisateur est un nombre
premier ou pas.
Un nombre premier est un nombre qui ne permet la division que sur 1 et lui-même.
Exemples de nombre premier : 2,5,7,11,13,31….
Exercice 4:
Ecrire un algorithme qui permet à l’utilisateur de saisir une suite de nombres non nuls. Indiquer le que
pour
arrêter la saisie il doit taper zero.
L’algorithme doit afficher en suite le maximum des nombres saisis, leurs moyenne ainsi que le nombre
des
positifs .
Exercice 5:
Ecrire un algorithme qui affiche la table de multiplication de 1 à 10 sous la forme suivante :
Exercice 6:
Ecrire un algorithme qui affiche les figures suivantes :
a) Combien de ligne ? 9
**
***
****
*****

****
***
**
b)
Exercice 7: Écrire un algorithme permettant d’afficher le triangle suivant : (le nombre de ligne
est saisi par l’utilisateur)
12
123
1234
12345
123456
1234567
Exercice 8 :
Deux nombres sont dits ‘’amis’’ si la somme des diviseurs stricts de l’un est égale à l’autre et inversement.
Exemple : Les deux nombre : 220 et 284 sont amis puisque :
220 à pour diviseurs :1,2,4,5,10,20,22,44,55,110(somme =284)
284 à pour diviseurs : 1,2,4,71 et 142(somme =220)
Ecrire un algorithme qui affiche les couples de nombres amis inférieurs à une limite donnée par
l’utilisateur.

Exercice 8: Écrire un algorithme qui calcule le terme UN de la suite de Fibonacci donnée par :
U1=1, U2=1, UN=UN-1 + UN-2 (pour N>2)

CHAPITRE 6 LES STRUCTURES DE DONNEES
Les tableaux :
Dans un programme informatique, nous avons souvent besoin de manipuler plusieurs données de même
type (entiers, réels, caractères, étudiants, clients,...). Nous pourrions pour ce faire déclarer autant de
variables que de données à manipuler mais cela présente au moins les inconvénients suivants :
– Lorsque le nombre de données est trop important cela devient infaisable (penser par exemple au cas ou le
nombre de données se chiffre en centaines ou en milliers).
– Cela empêche de voir ces données comme une donnée globale, ce qui est souvent nécessaire (penser par
exemple à l’ensemble des notes d’un étudiant ou de manière plus évidente aux lettres d’un mot).
Ce besoin a donné naissance aux tableaux. Un tableau est une donnée composée homogène, de taille fixe et
ordonnée. Détaillons :
– Une donnée : cela signifie que nous aurons des variables tableaux et que donc un tableau aura un nom.
– Composée : cela signifie qu’un tableau contient plusieurs données que nous appellerons ses éléments.
C’est sa raison d’être.
– Homogène : cela signifie que tous les éléments d’un tableau sont du même type. Nous dirons que ce type
est le type du tableau.
– De taille fixe : cela signifie que le nombre d’´eléments d’un tableau est fixé une fois pour toutes `a la
déclaration du tableau, qu’il ne peut changer au cours du programme. Ce nombre d’éléments est appelé la
taille du tableau.
– Ordonnée : cela signifie que chaque élément du tableau a une position dans le tableau que nous
appellerons son indice. L’indice du premier élément est 1.
L’indice peut être un entier unique (tableaux à une dimension) ,deux entiers (tableaux à deux dimensions),..
i. Tableau à une dimension :

1. Concepts de base :
Un tableau à une dimension (vecteur) est une liste de valeurs de même type (voir l’exemple ci-après).
12.4 1 0 -66 9 0
a. Syntaxe de déclaration :
Variables nomTableau[Taille] :Type ;
a. Exemple :
Variables Notes[30] :Réel ;
Jours[7] :Chaine de caractères ;
b. Accès à un élément :

Un élément d’un tableau est équivalent à une variable simple du même type que le tableau.Un élément
d’un tableau est identifié par le nom du tableau suivi de l’indice de l’élément en question :
NomTabeau[indice]
Exemples d’utilisation :
Algorithme AccèsAuxElements
Variables T[6] :Entier ;
c :Entier ;
Début
T[1]2; //affecter la valeur 2 au premier élément du tableau T
cT[1] ; //affecter la valeur de T[1] à la variable c
T[c](T[1] +2 )*3 //affecter le résultat de l’expression (T[1] +2 )*3 à T[2] (l’indice c=2)
T[2+1] c*3 ; //affecter le résultat de l’expression c*3 à l’élément d’indice 3
Lire(T[4] ) ; //lire au clavier la valeur de l’élément d’indice 4
Ecrire(T[1] ) ; //Afficher à l’écran l’élément d’indice 1
Fin
Remarques importantes :
• L’indice est un entier compris entre 1 et Taille du tableau. L’utilisation d’un indice
n’appartenant pas à cet intervalle peut engendrer des problème lors de l’exécution du
programme (débordements d’indices) , il est donc absolument nécessaire de contrôler
les indices.
• Un élément non initialisé contient une valeur indéterminée.
c. Parcourir d’un tableau :
La majorité des traitements sur les tableaux nécessitent l’utilisation d’une boucle et d’un compteur pour
parcourir tous les éléments.
Syntaxe :
Pour i1 jusqu’à Taille Faire

Traitement sur l’élément en cours (d’indice i)
FinPour

Exemple :La mise à zéro d’un tableau
Algorithme RAZTab
Variable T[100] :Entier
i:Entier
Début
Pour i1 jusqu’à 100 Faire
T[i]0
FinPour
Fin
2. Algorithmes de base :
La majorité des algorithmes suivants sont appliqués aux tableaux à une dimension de n’importe quel type.
2.1 Lecture au clavier d’un tableau (tous les éléments)
Algorithme LectureTabTous
i:Entier
Début
Ecrire(‘’Donnez l’entier d’indice ‘’,i) ;
Lire(T[i]) ;
FinPour
Fin
2.2 Lecture au clavier d’un tableau (selon le besoin de l’utilisateur)
Algorithme LectureTab
Variables T[100] :Entier
i,n:Entier
Début
Ecrire(‘’Donnez le nombre d’ éléments à saisir d’indice ,ne dépassez pas 100 ‘’) ;
Lire(n) ;
Pour i1 jusqu’à n Faire

Lire(T[i]) ;
FinPour
Fin
Lorsque l’utilisateur saisi un entier supérieur à 100 (la taille du tableau) , il y aura débordement d’indice ce
qui va générer des erreurs lors de l’exécution. Pour éviter ces problèmes contrôler toujours le nombre des
éléments à traiter.
Algorithme LectureTab_Meilleur
i,n:Entier
Début
Faire
Ecrire(‘’Donnez le nombre d’ éléments à saisir d’indice ,ne dépassez pas 100 ‘’) ;
Lire(n) ;
TantQue (n<1 OU n>100)
Lire(T[i]) ;
FinPour
Fin
2.3 Affichage des éléments
Algorithme AfficherTab
i,n:Entier
Début
//n est le nombre des éléments à afficher
Ecrire(‘’Le tableau:\n ‘’ ) ;
Ecrire(T[i] ,’’‘’) ;
FinPour
Fin

2.4 La somme des éléments d’un vecteur :
Algorithme SommeElements
i,n,S:Entier
Début
//n est le nombre des éléments stockés dans T
SS+T[i] ;
FinPour
Ecrire(‘’La somme des éléments de T est:‘’, S) ;

Fin
2.5 La somme de deux vecteurs :
Algorithme SommeVecteurs
Variable T1[100] ,T2[100],S[100]:Entier
i,n:Entier
Début
//n est le nombre des éléments stockés dans T1 et T2
S[i]T1[i]+T2[i] ;
FinPour
Ecrire(‘’Le tableau somme:\n ‘’ ) ;
Ecrire(S[i] ,’’ ‘’) ;
FinPour
Fin
2.6 Multiplication par un scalaire

Algorithme MultiplierParScalaire
VariablesT [100] :Entier
i,n,a:Entier
Début
//n est le nombre des éléments stockés dans T
Ecrire(‘’Donnez un entier SVP’’) ;
Lire(a) ;
T[i] a*T[i] ;
FinPour
Fin
2.7 Produit scalaire de deux vecteurs :
Algorithme ProduitSacalaire
Variable T1[100] ,T2[100]:Entier
i,n,P:Entier
Début
//n est le nombre des éléments stockés dans T1 et T2
PP+T1[i]*T2[i] ;
FinPour
Ecrire(‘’Le produit scalaire est :\n ‘’ ,P) ;
Fin
2.8 Recherche de l’indice de la première occurrence d’une valeur v :
Algorithme RechercheSéquentielle

i,n,v:Entier
Début
//Le tableau T est initialisé avec n valeurs
Ecrire(‘Donnez la valeur recherchée SVP !:\n ‘’ ) ;
Lire(v) ;
i1
Tanque((T[i] != v) Et ( i<n ))Faire
ii+1
FinTantQue
Si(i=n)Alors
Ecrire(’’La valeur ‘’,v,’’n’existe pas dans le tableau’’) ;
sinon
Ecrire(’’La valeur de la première occurrence de ‘’,v,’’se trouve dans la position ‘’,i) ;
FinSi
Fin
Question1 :Réaliser le même algorithme à l’aide d’une boucle Pour.
Question2 : Rechercher l’indice de la dernière occurrence.
Question3 : Afficher les indices de toutes les occurrences.
Question3 : Afficher un message qui indique si une valeur existe ou non dans un tableau.
2.9 Compter le nombre d’occurrence d’une valeur V :
Algorithme FréquenceApp
i,n,v,c:Entier
Début
Ecrire(‘Donnez la valeur SVP !:\n ‘’ ) ;
Lire(v) ;
c0

Si(T[i]=v)Alors
cc+1 ;
FinSi
FinPour
Ecrire(‘’La valeur ‘’,v,’’ est répétée ‘’,c,’’ fois dans le tableau’’) ;
Fin
2.10 Algorithme de la rechercher du maximum :
Algorithme Max
i,n,max:Entier
Début
maxT[1]
Si(T[i]>max)Alors
maxT[i] ;
FinSi
FinPour
Ecrire(‘’Le maximum du tableau est ’’,max) ;
Fin
2.11 Algorithme de suppression d’un élément
Algorithme Suppression
i,j,n,pos:Entier
Début
Faire
Ecrire(‘Donnez l’indice de la case pour l’insertionSVP !:\n‘’) ;

Lire(pos) ;
TanQue(pos<1 OU pos>n) ;
Pour ipos jusqu’à n-1Faire
T[i]T[i+1] ;
FinPour
nn-1
Fin
Question 1 : Ecrire un algorithme que supprime toutes les occurrences d’une valeur.
2.12 Algorithme d’insertion d’une valeur à une position :
Algorithme Insertion
i,j,n,pos,v:Entier
Début
//Le tableau T est initialisé avec n valeurs avec n<=99
Faire
Ecrire(‘Donnez l’indice de la case pour l’insertion SVP !:\n‘’) ;
Lire(pos) ;
TanQue(pos<1 OU pos>n) ;
Ecrire(‘Donnez la valeur à insérer SVP !:\n‘’) ;
Lire(v) ;
Pour in jusqu’à pos Faire
T[i+1]T[i] ;
FinPour
T[pos]v
nn+1
Fin

Question 1 : Ecrire un algorithme qui insère une valeur dans un tableau trié sans changer l’ordre de tri.
2.13 Algorithme qui inverse l’ordre des éléments :
Algorithme Inverser
i,n,a:Entier
Début
Pour i1 jusqu’à n Div 2 Faire
aT[i]
T[i]T[n-i+1]
T[n-i+1]a ;
FinPour
Fin
2.14 Algorithme d’éclatement en deux selon une condition :
Algorithme EclatementEnDeux
Variable TP[100] ,TI[100],T[100]:Entier
i,j,k,n:Entier
Début
//Les entiers pairs seront rangés dans TP,et les impairs dans TI
j1 ;
k1 ;
Si(T[i]%2=0)Alors
TP[j]T[i] ;
jj+1 ;
Sinon
TI[k]T[i] ;
kk+1 ;

FinSi
FinPour
Ecrire(‘’Le tableau des entiers pairs:\n ‘’ ) ;
Pour i1 jusqu’à j-1 Faire
Ecrire(TP[i] ,’’ ‘’) ;
FinPour
Ecrire(‘’Le tableau des entiers impairs:\n ‘’ ) ;
Pour i1 jusqu’à k-1 Faire
Ecrire(TI[i] ,’’ ‘’) ;
FinPour
Fin

Algorithmes de tri
Tri par échange :
Algorithme TriParEchangeCroissant
i,j,n,aux:Entier
Début
Pour i1 jusqu’à n-1 Faire
Pour ji+1 jusqu’à n Faire
Si (T[i]>T[j] )Alors
aux T[i] ;
T[i] T[j] ;
T[j]aux ;
FinSi
FinPour
Fin
Python :
# tri par Echange croissant:

liste=[3,1,6,9,4,2,8]
n=len(liste)
for i in range(0,n-1):
for j in range(i+1,n):
if liste[i]>liste[j]:
temp=liste[j]
liste[j]=liste[i]
liste[i]=temp
print('tri avec Echange croissant',liste)

Tri à bulles
Algorithme TriBulleCroissant
i,j,n,aux:Entier
Début
Faire
triéVrai ;
Pour j1 jusqu’à n-1 Faire
si(T[j]>T[j+1] )Alors
auxT[j] ;
T[j]T[j+1] ;
T[j+1]aux ;
triéFaux ;
FinSi
FinPour
TantQue (trié=Faux)
Fin
Par Python :
## tri bulle
liste=[3,1,6,9,4,2,8]
n=len(liste)
tri=True
while tri:
tri=False
for i in range(0,n-1):
if liste[i]>liste[i+1]:
temp=liste[i+1]
liste[i+1]=liste[i]
liste[i]=liste[i+1]
tri=True
print(liste)

Tri par insertion :
Algorithme TriParInsertion
i,j,n,aux:Entier
Début
//n est le nombre des éléments saisi
ji ;
TantQue((j>1) ET (T[j]<T[j-1])) Faire
auxT[j] ;
T[j]T[j-1] ;
T[j-1]aux ;
jj-1 ;
FinTantQue
FinPour
Fin
# tri par insertion

liste=[3,1,6,9,4,2,8]
n=len(liste)
for i in range(1,n):
j=i
while j>0 and liste[j]<liste[j-1]:
temp=liste[j-1]
liste[j-1]=liste[j]
liste[j]=temp
j=j-1
print(liste)

Tri par sélection des minimums successifs :
Algorithme TriSelectionMin
i,j,n,aux,pmin:Entier
Début
//n est le nombre des éléments du tableau T
Pour i1 jusqu’à n-1 Faire
pmini ;
valminT[i] ;
Pour ji +1 jusqu’à nFaire
Si (T[j]<valmin) Alors
valminT[j] ;
pminj ;
FinSi
auxT[i] ;
T[i] T[pmin] ;
T[pmin]aux ;
FinPour
FinPour
Fin
Tri par comptage :
Algorithme TriComptage
Variable T[100],ind[100] :Entier
i,j,n,aux,pmin:Entier

Début
Pour j1 jusqu’à n Faire
s0 ;
Pour k1 jusqu’à n Faire
Si((T[k]<T[j]) OU( (T[k]=T[j]) ET (k<=j))))Alors
ss+1 ;
FinSi
FinPour
ind[s]j
FinPour
Fin
//affichage du tableau
Ecrire(‘’La tableau trié:\n’’) ;
Pour i1 jusqu’à nFaire
Ecrire(T[ind[i]],’’ ‘’) ;
FinPour
#tri par comptage

liste=[3,1,6,9,4,2,8,1]
indice=[0,0,0,0,0,0,0,0]
n=len(liste)
for j in range(0,n):
s=-1
for k in range(0,n):
if (liste[k]<liste[j]) or (liste[k]==liste[j] and k<=j):
s=s+1
indice[s]=j
print('tri par comptage')
for i in range(0,n):
print(liste[indice[i]],end=",")

Tableaux à deux dimensions (matrices) :
1. Notations de base:
Dans la vie courante, on a plutôt tendance à utiliser le mot tableau pour un ensemble de valeurs
susceptibles d’etre présentées sous forme d’un schéma à deux dimensons comportant à la fois
des lignes et des colonnes. Ainsi, on peut faire un tableau donnant les notes de chaque stagiaires
d’un groupe, dans chacun des différents modules. Il pourrait se présenter ainsi :
Ce tableau est de deux dimensions : la dimension Module et la dimension Stagiaire. Le contenu

représente les notes.
a. Syntaxe de déclaration
variables NomMatrice[nbrLigne][nbrColonnes] :Type;
b. Exemple :
Variables T[4][9] :Entier ;
c. Accès à un élément :
Syntaxe :

Un élément d’une matrice est équivalent à une variable ayant le type du tableau, il est identifié par le
nom du tableau suivi de l’indice de la ligne et l’indice de colonne (c’est l’intersection d’une ligne et
d’une colonne).
NomTableau[indiceLigne][indiceColonne]
d. Exemples
Algorithme AccèsAuxElements
Variables M[4][3] :Entier ;
c :Entier ;
Début
T[1][1]2; //affecter la valeur 2 au premier élément de la matrice T
cT[1][1] ; //affecter la valeur de T[1][1] à la variable c
T[c][2](T[1][1] +2 )*3 //affecter le résultat de l’expression (T[1][1] +2 )*3 à T[2][2] (l’indice c=2)
T[2+1][1] c*3 ; //affecter le résultat de l’expression c*3 à l’élément T[3][1]
Lire(T[3][2] ) ; //lire au clavier la valeur de l’élément T[3][2]
Ecrire(T[1] [1]) ; //Afficher à l’écran le premier éléments
Fin
Remarque : Un variable de type primitif, non initialisée contient une valeur par défaut ou une valeur
indéterminée. Il n’y a pas de variable vide.
e. Parcourir une matrice :
La majorité des traitements sur les matrices nécessitent le parcours des éléments de la matrice.Vue qu’un
élément de la matrice est référencé à l’aide de deux indice, l’utilisation de deux boucles imbriquées est
nécessaire, une pour le parcours des lignes et l’autre pour le parcours des colonnes. Les deux boucles
utilisent deux compteurs différents .
Syntaxe :
Pour i1 jusqu’à nbrLignesFiare
Pour j1 jusqu’à nbrColonnes Fiare

Traitement sur l’élément en cours (d’indice i,j)
FinPour
FinPour
Exemple :
La mise à zéro d’une matrice
Algorithme RAZ
Variable M[100] [100]:Entier
i,j:Entier
Début
Pour j1 jusqu’à 100 Faire
M[i][j]0
FinPour
FinPour
Fin
2. Algorithmes de base :
2.1 Lecture au clavier :
Algorithme LireMatrice
i,j ,n,m:Entier
Début
//lecture des deux dimensions
Faire
Ecrire(‘’Donnez le nombre de lignes SVP ! (un entier <=100)’’) ;
Lire(n) ;
TantQue (n<1 OU n>100) ;
Faire
Ecrire(‘’Donnez le nombre de colonnes SVP ! (un entier <=100)’’) ;

Lire(m) ;
TantQue (m<1 OU m>100) ;
//Lecture des éléments
Pour j1 jusqu’à m Faire
Ecrire(‘’Donnez l’élément M[‘’,i,’’][‘’,j,’’] ’’) ;
Lire(M[i][j])
FinPour
FinPour
2.2 Affichage à l’écran :
Algorithme AfficherMatrice
i,j ,n,m:Entier
Début
//M est déjà remplis n :dimension ligne ,m :dimension colonne
Ecrire(M[i][j],’’ ‘’) ;
FinPour
FinPour
2.3 Somme des éléments d’une matrice
Algorithme SommeEle
i,j ,n,m,s:Entier
Début
//M est déjà remplis n : dimension ligne ,m :dimension colonne
s0

ss+M[i][j];
FinPour
FinPour
Ecrire(‘’La somme des éléments de la matrice M est :’’,s) ;
Fin
2.4 Trace d’une matrice (somme des éléments de la diagonale principale) :
Algorithme Trace
i,j ,n,m,s:Entier
Début
//M est déjà remplis n : dimension ligne, m:dimension colonne
s0
si(i=j)Alors
ss+M[i][j];
FinSsi
FinPour
FinPour
Ecrire(‘’La trace de la matrice M est :’’,s) ;
Fin
Remarque : Il existe une deuxième solution : Vous pouvez calculer cette

sommation en parcourant juste la diagonale principale.
Question : Ecrire l’algorithme correspondant !
2.5 Somme de deux matrices
Algorithme Somme2Matrices
Variables M1[100][100] ,M2[100][100] ,S[100][100] :Entier ;

i,j ,n,m:Entier
Début
//M1 et M2 sont déjà remplis n : dimension ligne ,m :dimension colonne
S[i][j]M1[i][j]+M2[i][j];
FinPour
FinPour
Ecrire(‘’La matrice somme des deux matrices M1 et M2 est:\n’’) ;
Ecrire(S[i][j],’’ ‘’) ;
FinPour
FinPour
Fin
2.6 Construction de la matrice unitaire
Algorithme MatriceUnitaire
Variables U[100][100] :Entier ;
i,j ,n:Entier
Début
Faire
Ecrire(‘’Donnez la dimension SVP ! (un entier <=100)’’) ;
Lire(n) ;
TantQue (n<1 OU n>100) ;
Pour j1 jusqu’à nFaire

si(i=j)Alors
U[i][j]=1;
sinon
U[i][j]=0;
FinSsi
FinPour
FinPour
Ecrire(‘’La matrice unitaire de dimension ’’,n,’’est \n’’) ;
Pour j1 jusqu’à nFaire
Ecrire(U[i][j],’’ ‘’) ;
FinPour
FinPour
Fin
Résultat d’exécution :pour n=5
1 0 0 0 0
0 1 0 0 0
0 0 1 0 0
0 0 0 1 0
0 0 0 0 1
Il existe une autre solution, qui consiste à :
-La mise à zéro de la matrice.
-L’initialisation de la diagonale principale avec 1
Question : Ecrire l’algorithme correspondant !

2015/2016
ISGI/TDI 1
▪ Manipuler des données complexes sous la forme de tableaux (une

dimension et deux
dimensions).
▪ Mettre au point des algorithmes complexes
▪ Réaliser un jeu d’essaies

DESCRIPTION DE L ’ACTIVITÉ
Exercice 1:
Écrire un algorithme qui lit la dimension N d'un tableau T du type entier (dimension maximale:
20 éléments), remplit le tableau par des valeurs entrées au clavier et affiche le tableau. Effacer
ensuite toutes les occurrences de la valeur 0 dans le tableau T et tasser les éléments restants.
Exercice 2:
Écrire un algorithme qui lit la dimension N d'un tableau T du type
Entier (dimension maximale: 20 éléments), remplit le tableau par des valeurs entrées au clavier
et affiche le tableau. Copiez ensuite toutes les composantes strictement positives dans un
deuxième tableau TPOS et toutes les valeurs strictement négatives dans un troisième tableau
TNEG.
Exercice 3:
Ecrire un algorithme qui demande à l'utilisateur de taper 10 entiers compris entre 0 et 20 qui
seront stockés dans un tableau et qui affiche le nombre de fois qu'on a tapé un 0, le nombre de
1, le nombre de 2, ..., le nombre de 20.
Exercice 4 :
On considère une séquence d'entiers s de longueur L représentée dans un tableau T d'entiers

défini sur l'intervalle [1…Lmax], 0 < L < Lmax.

On veut écrire un programme qui remplace dans T la suite s par la suite s' de longueur L' (avec L'
<= L), déduite de s en supprimant tous les éléments redondants. Un élément de s est redondant
s'il est égal à un autre élément de s. Le programme ne doit pas utiliser de tableau intermédiaire
pour créer s'. L'ordre des éléments reste celui de la séquence de départ. Etudier tout d'abord le
problème en supposant que T peut ne pas être trié en ordre croissant.
Exemple : si s = [15, 4, 19, 4, 8, 11, 11, 3, 4, 19] et L = 10 alors s' = [15, 4, 19, 8, 11, 3] et L = 6
Exercice 5: Vérifier que deux tableaux sont identiques (les éléments des deux tableaux seront
saisis par l’utilisateur).
Exercice 6: Rotation des éléments d’un tableau
Saisir un tableau tab[10] d’entiers;
Saisir le nombre de rotation
On effectue la rotation des éléments du tableau du nombre entré en faisant une rotation.
Afficher le tableau de départ, la valeur du déplacement et le vecteur à l'arrivée.
Exemple :
Départ 0 1 2 3 4 5 6 7 8 9
Rotations = 4
Arrivée 6 7 8 9 0 1 2 3 4 5
Exercice 7 : m personnes sont assises autour d'une table circulaire et entament le jeu suivant.
Elles se fixent entre-elles un entier k>0 et une personne P1 par laquelle elles commenceront le
jeu. On commence à compter de 1 à k en partant de P1 et en tournant à droite. La k ième personne
quitte la table et on continue à compter de 1 à k à partir de la personne suivante encore à table.
La personne gagnante est la dernière qui reste à table.
Analyser ce problème et faire un programme permettant de réaliser ce jeu.
Exercice 8: Les points cols d'un tableau à deux dimensions sont les éléments du tableau qui sont
minimum sur leur ligne et maximum sur leur colonne.
Ecrire le programme principal qui recherche dans un tableau à deux dimensions les points cols.
Exemple : soit le tableau suivant T[3][3]
123
-7 8 9

-6 -3 -4
Les points cols du tableau sont :
T[0][0]=1
T[2][1]=-3
Exercice 9: Un carré magique est un carré rempli de nombres qui, lorsque l’on en fait la somme
sur chaque ligne, colonne ou diagonale, donne le même résultat. Pour simplifier le travail nous
ne considérerions ici que des carrés d’ordre impair.
Écrire un algorithme qui teste si un carré est magique.
Exemple de carré d’ordre 3 :
816
357
492
Exercice 10:
1. Lire une matrice de N lignes et M colonnes ligne par ligne. Les données sont dans l’ordre :
NM
A[1][1] … A[1[[M]
A[N][1] … A[N][M]
Écrire ensuite cette matrice ligne par ligne.
Les exercices suivants supposent que cette phase d’initialisation vient d’être faite.
2. Compter (et afficher) le nombre de zéros de chaque colonne.
3. Compter (et afficher) le nombre de colonnes contenant au moins un zéro.
4. Afficher le minimum de chaque colonne.
5. Afficher le numéro de la colonne contenant le minimum de la matrice. (A égalité, donner le

plus petit numéro de colonne).
Exercice 11 :
1. Écrire un algorithme qui transfère une matrice M à deux dimensions L et C (dimensions

maximales: 10 lignes et 10 colonnes) dans un tableau V à une dimension L*C.

2. Écrire un algorithme qui effectue la transposition tA d'une matrice A de dimensions N et M en
une matrice de dimensions M et N.
3.Écrire un algorithme qui effectue la multiplication de deux matrices A et B. Le résultat de la

multiplication sera mémorisé dans une troisième matrice C qui sera ensuite affichée.
Recherche dichotomique :
Il existe plusieurs méthodes pour faire une recherche d’une variable dans un tableau. L’une des
plus importantes est appelée recherche dichotomique. Ce type de recherche est utilisé que si le
tableau est trié :
2 7 19 84 190
Le principe est de comparer la valeur recherchée X par celle du milieu du tableau T[N/2] ;
Si T[N/2]=X on arrête car on a trouvé ce qu’on cherche, c’est T[N/2] ;
Si X>T[N/2], refaire la recherche sur la 2ème partie du tableau
Si X<T[N/2], refaire la recherche sur 1ère partie du tableau
Si la dimension du tableau est paire, on prend l’élément équivalent à la valeur absolue

majoritaire.
Écrire l’algorithme qui permet d’effectuer la recherche dichotomique dans un tableau.

I. Les structures (Enregistrements) :
1. Définition :
Une structure est un assemblage de variables (champs) qui peuvent avoir différents types.
Contrairement aux tableaux qui vous obligent à utiliser le même type dans tout le tableau, vous

pouvez créer une structure comportant des champs de types Entier, Caractère, Réel et Chaine de
caractères à la fois.
Les structures sont utilisées généralement pour définir des nouveaux types (non primitifs).
2. Syntaxe de déclaration :
Les structures sont déclarées avant les variable, puisqu’elles définies des types. La syntax e en
pseudo-Langage peut être :
Structure NomStructure :
champs1 :Type ;
champs2 :Type ;
… ….
champsN :Type ;
FinStructure
Exemple :
Structure Stagiaire :
Nom :Chaine de caractères ;
Prénom ; Chaine de caractères ;
Num :Entier ;
Niveau :Entier ;
Filière :Chaine de caractères ;
FinStructure
3. Variables structure:
La déclaration d’une structure définie un nouveau type (Stagiaire dans l’exemple), elle ne
réserve pas d’espace mémoire. Pour utiliser cette structure déclarez des variable s en utilisant la
structure comme type:
Syntaxe :
Variables nomVariable :NomStructureType ;
Exemple :
Variables s1:Stagiaire ;

4. Accès aux champs :
Pour accéder à un champ, utilisez le nom de la variable suivi d’un point de sélection et du nom
du champ :
Algorithme UtiliserTypeStagiaire
Num :Entier ;
Niveau :Entier ;
FinStructure
Variables s :Stagiaire
Début
s.Nom’’Salhi’’ ;
s.Prénom’’Ali’’ ;
Lire(s.Filière) ;
s.Num1 ;
s.Niveau2 ;
Ecrire(‘’Informations stagiaire:\n’’) ;
Ecrire(‘’Nom :’’,s.Nom,’’\n’’) ;

Ecrire(‘’Prénom :’’,s.Prénom,’’\n’’) ;
Ecrire(‘’Niveau:’’,s.Niveau,’’\n’’) ;
Ecrire(‘’N° :’’,s.Num,’’\n’’) ;
Fin
5. Structures imbriquées :
Une structure peut contenir un champ de type structure.
Exemple :
Algorithme LireDateNaissance
Structure Date :
Jour :Entier ;
Mois :Entier ;
Année :Entier ;
FinStructure
Num :Entier ;
Niveau :Entier ;
DateNaissance :Date
FinStructure
Variables s :Stagiaire ;
Début
Ecrire(‘’Donnez la date de naissance j/m/a ’’) ;
Lire(s. DateNaissance.Jour) ;
Lire(s. DateNaissance.Mois) ;
Lire(s. DateNaissance.Année) ;

Ecrire(s. DateNaissance.Jour,’’ /’’, s. DateNaissance.Mois,’’/’’, s. DateNaissance.Année) ;
Fin
6. Champ de type tableau :
Un champ peut être un tableau. Voir l’exemple ci-après.
Algorithme LireFilière
Structure Filière :
Modules[100] : Chaine de caractères ;
NombreModule :Entier ;
FinStructure
Variable f :Filière ;
Début
Ecrire(‘’Donnez l’intitulé de la filière SVP !’’) ;
Lire(f.Nom) ;
Ecrire(‘’Donnez le nombre de modules de la filière SVP (max=100) !’’) ;
Lire(f.NombreModule) ;
Pour i1 jusqu’à f.NombreModule faire
Ecrire(‘’Donnez le nom du module num ‘’,i) ;
Lire(f.Modules[i]) ;
FinPour
Fin
7. Tableaux de type structure (Table) :
Un tableau de type structure est appelé table, et ses éléments enregistrements. Les tableaux de
type structure peuvent subir les mêmes algorithmes que les tableaux de types primitifs.

Algorithme TableStagiaire
Num :Entier ;
FinStructure
Variables s[100] :Stagiaire ;
n,i :Entier ;
Début
Faire
Ecrire(‘’Donnez le nombre de stagiaires, ne dépassez pas 100’’) ;
Lire(n) ;
TantQue(n<1 OU n>100) ;
//lecture
Pour i1 jusqu’à n faire
Ecrire(‘’Donnez le nom,le prénom et le numéro du stagiaire’’) ;
Lire(s[i].Nom,s[i].Prénom,s[i].Num) ;
FinPour
//Affichage
Ecrire(‘’La liste des stagiaires’’) ;
Pour i1 jusqu’à n faire
Ecrire(s[i].Num ,s[i].Nom,s[i].Prénom,’’\n’’) ;
FinPour
Fin


▪ Manipuler des données complexes sous la forme de tableaux.

▪ Mettre au point des algorithmes complexes
▪ Travailler avec enregistrements et des tableaux d’enregistrements.

Exercice 1 :
Le directeur d’une société offre des primes à ses employés. Chaque employé possède les
informations suivantes :
CIN, Nom, Prénom, Date de naissance, Date d’embauche, Salaire, Nombre d’année d’expérience
(NAE), prime.
Les primes sont offertes selon le critère suivant :
Si nombre d’année d’expérience 2 < NAE <=4 alors prime=salaire
Si nombre d’année d’expérience 4 < NAE <=6 alors prime=salaire* 1,5
Si nombre d’année d’expérience 6 < NAE <=8 alors prime=salaire *2
Si nombre d’année d’expérience NAE > 8 alors prime=salaire *4
Questions :
1- Créer les structures nécessaires avec les attributs cités dans l’énoncé, en choisissant un type
de données convenable pour chaque attribut.
2- Remplir toutes les informations des 6 employés sauf le NAE et la prime.
3- Calculer le nombre d’année d’expérience de chaque employé.
4- Afficher tous les employés qui ont été embauché avant la date 01/04/2005 et âgés d’au moins
de 30 ans.
5- Trier la liste des employés selon leur salaire.
Exercice 2 :

➢ Pour simplifier l’algorithme, nous travaillons avec un seul groupe TDI,c'est-à-dire le
champ Filière=’’TDI’’.
➢ CodeMatière est un champ auto incrémenté. La valeur initiale est 1, le pas
d’incrémentation est 1.
➢ Le coefficient est un entier entre 1 et 5.
➢ La note est comprise entre 0 et 20

➢ Les champs codeInscription et codeMatière doivent être valides (existe déjà dans les deux
tables Stagiaire et Matière).
Travail à faire :
Ecrire un algorithme qui permet de :
1- Saisir les informations de tous les stagiaires

2- Saisir les informations de toutes les matières
3- Saisir les notes de tous les stagiaires pour toutes les matières.
4- Afficher le majorant de la classe.
5- Afficher le bulletin des notes d’un stagiaire dont le code d’inscription est saisi au
clavier.
6- Afficher la liste des stagiaires avec leurs moyennes générales.

CHAPITRE 5 Programmation modulaire : LES SOUS-ALGORITHME
Dans la résolution d’un problème, on peut constater qu'une suite d'actions revient
plusieurs fois. Dans ce cas il serait judicieux de l'écrire une seule fois, et de l'utiliser
autant de fois que c'est nécessaire, en effectuant des calculs avec des données différentes.
Cette suite d'actions sera définie dans un sous algorithme, qui peut prendre soit la forme
d’une procédure, soit la forme d’une fonction.
D’autre part, on peut observer que certains groupes d’actions se rapportent à des traitements
précis et différents. Il est souhaitable alors de représenter chacun d’eux dans un sous
algorithme, ce qui permettra d’améliorer la conception de l’algorithme et sa lisibilité. On perçoit
alors un algorithme comme un ensemble de procédures/fonctions. La structuration d’un
algorithme par morceaux (modules) est la base de la programmation structurée et modulaire.
I. Fonction :
Une fonction est un bloc d’instructions qui retourne un seul résultat.L’appel (avec
ou sans paramètres) de la fonction déclenche l’exécution de ses instruction.
1. Déclaration d’une fonction :
a. Syntaxe :
Fonction nomFonction (paramètre1 :Type,paramètre2 :Type…..) :Type de
retour
Variables déclaration des variables locales
Début
Instructions de la fonction
Retourne expression
FinFonction

b. Exemple :
Fonction Somme2(n1 :Réel,n2 :Réel) :Réel
Variable s :Réel ;
Début
sn1+n2 ;
Retourne s ;
FinFonction
c. Les paramètres :
C’est un ensemble de variables, moyen de communication entre la fonction et l’extérieur. Ils existent deux
types de paramètres :Les paramètres utilisés dans la définition de la fonction (paramètres formels),et
ceux utilisés dans l’appel de la fonction (paramètres effectifs).
d. La valeur de retour :
Une fonction doit retourner une valeur à l’algorithme appelant. Cette valeur est unique. Le retour de la
valeur, c'est-à-dire l’exécution de l’instruction retourne, signifie l’arrêt de la fonction.
2. L’appel d’une fonction :
Pour déclencher l’exécution d’une fonction dans un algorithme, il suffit de l’appeler. L’appel de la fonction
s’écrit en mettant son nonm suivi de la liste de paramètres entre parenthèses, séparés par des virgules :
NomFonction(paramètre1,Paramètre2….,paramètreN) ;
3. Exécution d’une fonction :
Trois étapes sont toujours nécessaires à l’exécution d’une fonction :
1-L’algorithme appelant interrompt son exécution .
2-La fonction appelée effectue son bloc d’instructions. Dès qu’une instruction Retourner est exécutée, la
fonction s’arrête en retournant la valeur calculée.
3-le programme appelant reprend alors son exécution.
Exemple :Fonction sans paramètres qui retourne une note saisie par l’utilisateur lorsque celle-ci est
valide.
Fonction LireNoteValide() :Réel
Variables note :Réel
Début
Ecrire(‘’donnez la note svp /20’’) ;
Lire(note) ;

TantQue(note<0 Ou note>20)Faire
Ecrire(‘’donnez la note svp /20’’) ;
Lire(note) ;
FinTantQue
Retourner note ;
FinFonction
Remarques:
• Le nom d’une fonction est un identificateur

• Une fonction peut être avec ou sans paramètre.
• Le type de retour est le type de résultat (expression) retourné par l’instruction
Retourner.
• Une fonction peut utiliser des variables intermédiaires dites variable locales.
Exemple1 :Une fonction qui calcule le carré d’un nombre
Fonction Carré(X :Réel) : Réel
Variable c :Réel ;
Début
cX* X ;
Retourner c ;
FinFonction
Ou bien sans variable intermédiaire :
Fonction Carré(X :Réel) :Réel
Début
Retourner X*X ;
FinFonction
Exemple2 :
Fonction qui détermine si un entier passé en paramètre est pair ou non.
Fonction EstPair(N :Entier) :Booléen Fonction EstPair(N :Entier) :Booléen

Début Variables r :Booléen
si(N% 2=0) Alors Début
Retourner Vrai ; rFaux
Sinon si(N% 2=0) Alors

RetournerFaux ; rVrai ;
FinSI FinSI
FinFonction Retourner r ;
FinFonction
Exemple 3 : Fonction qui retourne la valeur maximale d’un tableau
Fonction MaxTab(T[] :Entier,n :Entier) :Entier
Variables
i, max:Entier
Début
maxT[1] ;
Si(T[i]>max)Alors
maxT[i] ;
FinSi
FinPour
Retourner max ;
FinFonction
II. Les procédures :

1. Définition :
Une procédure est un sous algorithme sans valeur de retour ou dont le type de retour est rien(void).
2. Syntaxe :
Procédure NomProcédure (liste paramètres)
Variables :déclaration des variables locales

Début
bloc d’instructions
FinProcédure
Exemple 1:
Procédure AffichageMessage(msg :Chaine)

Début
Ecrire(‘’*****************Le message
est***************\n’’) ;
Ecrire(msg,’’\n’’) ;
Ecrire(‘’********************************************\n’’
);
FinProcédure
Exemple 2 :
Procédure AfficherTable(T[] :Réel,n :Entier)
Variables : i :Entier
Début
pour i1 jusqu’à n faire
Ecrire(T[i],’’ ‘’) ;
FinPour
FinProcédure
3. Passages de paramètres :
Les échanges d’informations entre un algorithme appelant et un sous algorithme appelé se font par
l’intermédiaire de paramètres.
Il existe deux types de passage de paramètres :
3.1 Passage de paramètres par valeur :

Dans ce type de passage, le paramètre formel reçoit uniquement une copie de la
valeur du paramètre effectif (valeur uniquement). La valeur du paramètre effectif ne sera
jamais modifiée, même si la valeur du paramètre formel correspondant a changé dans le
corps de la fonction.
Exemple1 :

Fonction Inverser(n :réel) :Réel
Début
n -n ;
retourne n ;
FinFonction
Algorithme AppelInverser
variables x, y :réel ;
Début
x122
yInverser(x) ;
Ecrire (x) ;
Fin
Exemple2 :
Procédure PermuterValeurs( nbr1 :Réél, nbr2 :Réel)
Variables : aux : Réel
Début
auxnbr1 ;
nbr1nbr2 ;
nbr2aux ;
FinProcédure
Algorithme PassageParValeur
Varaiables x1,x2 :Réel
Début
x112.5
x2-9.25
Ecrire(‘’Avant l’appel x1=’’,x1,’’ x2=’’,x2,’’\n’’) ;
PermuterValeurs(x1,x2) ;
Ecrire(‘’Après l’appel x1=’’,x1,’’ x2=’’,x2,’’\n’’) ;
Fin

3.2 Passage de paramètre par adresse ou référence :
Dans ce type de passage de paramètres, le sous algorithme utilise l’adresse
(l’emplacement dans la mémoire vive) du paramètre effectif, c'est-à-dire accède
directement à son contenu.Si la valeur du paramètre formel correspondant a changé, au
cours d’exécution du sous algorithme, la valeur du paramètre effectif change aussi.
Un paramètre passé par adresse est précédé du mot Réf.
Fonction Inverser(réf n :réel) :Réel

Début
n -n ;
retourne n ;
FinFonction
Algorithme AppelInverser
variables x, y :réel ;
Début
x122
yInverser(x) ;
Ecrire (x) ;
Fin
Exemple2 :
Procédure PermuterValeurs( réf nbr1 :Réél,réf nbr2 :Réel)
Variables : aux : Réel
Début
auxnbr1 ;
nbr1nbr2 ;
nbr2aux ;
FinProcédure
Algorithme PassageParValeur
Varaiables x1,x2 :Réel
Début

x112.5
x2-9.25
Ecrire(‘’Avant l’appel x1=’’,x1,’’ x2=’’,x2,’’\n’’) ;
PermuterValeurs(x1,x2) ;
Ecrire(‘’Après l’appel x1=’’,x1,’’ x2=’’,x2,’’\n’’) ;
Fin
Remarque :
Il existe un passage de paramètre par adresse particulier : c’est le passage de paramètre en sortie.
Le paramètre est passé par adresse et il est utilisé pour recevoir une sortie calculée par le sous
algorithme.
Exemple :
Procédure Somme3( n1 :Réel,n2 :Réel,n3 :Réel, sortie s :Réel)
Début
sn1+n2+n3 ;
FinProcédure
Algorithme appelSortie
variables x1,x2,x3,som :Réel ;
Début
Somme3(x1,x2,x 3,sortie som) ;
Ecrire (‘’la somme est ‘’,som) ;
Fin

▪ Optimiser le code d’un programme en ayant recours aux fonctions et procédures.
▪ Utiliser la notion de récursivité dans un algorithme.
Exercice 1: Écrire :
Une procédure, nommée f1, se contentant d’afficher bonjour (elle ne possèdera aucun argument) ;
Une procédure, nommée f2, qui affiche bonjour un nombre de fois égal à la valeur reçue en argument
(entier);
Une fonction, nommée, f3, qui fait la même chose que f2, mais qui, de plus, renvoie la valeur (entier) 0.
Exercice 2: Ecrire une fonction qui calcule la somme des N premiers terme d’une série harmonique.
Exercice 3: Ecrire deux fonctions qui calculent la valeur XN pour une valeur réelle X (type reel) et une
valeur entière positive N (type entier) :
a) EXP1 retourne la valeur XN comme résultat.
b) EXP2 affecte la valeur XN à X.
Exercice 4:
-a Écrire une fonction nommée estVoyelle examinant si un caractère fourni en paramètre est une voyelle
et
fournissant un résultat de type booléen.
-b Ecrivez un algorithme qui demande une phrase à l’utilisateur et qui affiche à l’écran le nombre de
voyelles contenues dans cette phrase.
Exercice 5: Écrire la fonction NCHIFFRES du type entier qui obtient une valeur entière N (positive ou
négative) du type long entier comme paramètre et qui fournit le nombre de chiffres de N comme résultat.

Écrire un petit programme qui teste la fonction NCHIFFRES:
Exemple:
Introduire un nombre entier : 6457392
Le nombre 6457392 a 7 chiffres
Exercice 6: En mathématiques, on définit la fonction factorielle de la manière suivante:
0! = 1
n! = n*(n-1)*(n-2)* ... * 1 (pour n>0)
Ecrire une fonction FACT du type entier long qui reçoit la valeur N (type entier) comme paramètre et qui
fournit la factorielle de N comme résultat. Ecrire un petit programme qui teste la fonction FACT.
Exercice 7 : refaire l’exercice 6 en faisant appel à la récursivité.
Exercice 8 : Déterminer le maximum de N éléments d'un tableau TAB d'entiers de deux façons différentes:
a) la fonction MAX1 retourne la valeur maximale
b) la fonction MAX2 retourne l'indice de l'élément maximal
Exercice 9 :
Demain est un autre jour. Nous supposerons que l'utilisateur ne rentre que des entiers strictement
positifs.
1) Définir le type date basé sur une structure permettant de représenter une date comportant le numéro
du jour, le numéro du mois et l'année.
Ex : 14 7 1792 pour le 14 juillet 1792
25 12 2007 pour le 25 décembre 2007
29 2 2008 pour le 29 février 2008
2) Écrire la fonction estBissextile() qui renvoie 1 si l'année est bissextile; 0 sinon. Nous rappelons qu'une
année est bissextile si elle est divisible par 4 mais pas par 100, elle est aussi bissextile si elle est divisible
par 400.
3) Écrire la fonction dateJuste() qui renvoie 1 si une date saisie est juste, 0 sinon
4) Écrire la procédure jourdulendemain() qui à partir d'une donnée de type date détermine la date du
lendemain.
5) Écrire une fonction comparedate() qui renvoie 1 si une date d1 est plus grande qu'une date d2, 0 si
elles sont égales, et -1 si la date d2 est plus grande que la date d1
6) Écrire une fonction ecartjour() qui retourne le nombre de jours qui séparent deux dates.
Exercice 10 :

Le but est de créer un ensemble de fonction de gestion des nombres complexes. On rappelle que les
nombre complexes d’écrivent comme suit : x=a+ib, où a et b sont des nombres entiers, i*i=-1.
1- Définir la structure de données nécessaires pour manipuler les nombres complexes.
2- Ecrire une fonction permettant de prendre deux nombres complexes et de retourner un nombre
complexe représentant la somme. Rappel si x=a+ib et y=c+id alors z=x+y=a+c+i(b+d)
3- Ecrire une fonction permettant de prendre deux nombres complexes et de retourner un nombre
complexe représentant le produit. Rappel si x=a+ib et y=c+id alors z=x*y= (ac-bd)+i*(ad+bd)
4- Ecrire une procédure permettant d’afficher un nombre complexe.
Exercice 11 :
Ecrire la procédure INSERER qui place un élément X à l'intérieur d'un tableau qui contient N éléments triés
parordre croissant, de façon à obtenir un tableau à N+1 éléments triés par ordre croissant. La dimension
du
tableau est incrémentée dans la fonction INSERER.
Exercice 13:
Ecrire une procédure qui permet d’afficher la forme suivante :
**
***
****
*****
****
***
**
Le nombre de lignes est passé en paramètres
Exercice 14:
Ecrire une procédure inverser qui inverse l’ordre des éléments d’un vecteur .
Exemple :
12 9 4 34

Aprés l’appel de la procédure
34 4 9 12


Cours Algorithme On Structur Ée

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

Cours Algorithme On Structur Ée

Transféré par

Droits d'auteur :

Formats disponibles

Office de la formation Professionnelle et de la promotion du travail

Filière : Techniques de Développement Informatique

Module : Programmation structurée

Proposé par :Abdelmounaim BENDAOUD

Programmation structurée Page 1 sur 109

La structure générale d’un algorithme: .................................................................7

L’entête de l’algorithme : .......................................................................................8

Les données de l'algorithme :.................................................................................8

I. Le concept de variable : ................................................................................8

1. Type d’une variable: .....................................................................................9

2. La valeur d’une variable ...............................................................................9

Les types primitifs de DONNEES : ....................................................................10

1. Les types numériques .................................................................................. 10

Opérations définies sur les entiers : ......................................................................10

les opérateurs de comparaison : ............................................................................ 10

Opérations définies sur les types Réel : ................................................................11

Déclaration d’une variable : .................................................................................14

Les expressions : ..................................................................................................15

Expressions arithmétiques : ..................................................................................15

Instructions de base :............................................................................................18

Les instructions d’entree /sortie ...........................................................................18

Module : Techniques de Programmation Structurée. ..........................................25

LES STRUCTURES DE CONTROLES .............................................................30

1. Structures de contrôle conditionnelles :.....................................................30

Programmation structurée Page 2 sur 109

La structure de branchement Selon…Cas : ..........................................................34

DESCRIPTION DE L’ACTIVITÉ ......................................................................38

LES STRUCTURES DE CONTROLE REPETITIVES (BOUCLES) : .............41

La boucle TantQue….Faire (while).....................................................................45

La boucle JUSQU’À .............................................................................................48

La boucle Pour ......................................................................................................49

Les instructions de rupture de séquences : sortir (break) et continue . .................51

CHAPITRE 6 LES STRUCTURES DE DONNEES ..........................................57

Les tableaux : .......................................................................................................57

i. Tableau à une dimension : ........................................................................57

1. Concepts de base : ......................................................................................57

a. Syntaxe de déclaration : ............................................................................57

b. Accès à un élément : ..................................................................................57

2. Algorithmes de base : ...............................................................................59

2.1 Lecture au clavier d’un tableau (tous les éléments) ..............................59

2.2 Lecture au clavier d’un tableau (selon le besoin de l’utilisateur) ........59

2.3 Affichage des éléments ..............................................................................60

2.4 La somme des éléments d’un vecteur : ...................................................61

2.5 La somme de deux vecteurs :.....................................................................61

2.6 Multiplication par un scalaire ...................................................................61

2.7 Produit scalaire de deux vecteurs : ...........................................................62

2.8 Recherche de l’indice de la première occurrence d’une valeur v : .........62

Programmation structurée Page 3 sur 109

2.11 Algorithme de suppression d’un élément ..............................................64

2.12 Algorithme d’insertion d’une valeur à une position : ..........................65

2.13 Algorithme qui inverse l’ordre des éléments :.......................................66

2.14 Algorithme d’éclatement en deux selon une condition : ......................66

Algorithmes de tri ................................................................................................68

Tri par échange : ...................................................................................................68

Tri à bulles ............................................................................................................69

Tri par insertion : ..................................................................................................70

Tri par sélection des minimums successifs :.........................................................71

Tri par comptage :.................................................................................................71

Tableaux à deux dimensions (matrices) :.............................................................73

1. Notations de base: ......................................................................................73

a. Syntaxe de déclaration ............................................................................... 73

c. Accès à un élément :................................................................................... 73

e. Parcourir une matrice : ................................................................................ 74