Introduction à L’algorithmique

Dr. A . SIDIBE
 Introduction à L’algorithmique
1. Notion d’Algorithme et de programme

Un ordinateur est une machine électronique programmable servant au

traitement de l’information codée sous forme binaire

Un algorithme représente l'enchaînement des actions (instructions) nécessaires

pour faire exécuter une tâche à un ordinateur (résoudre un problème) Un
algorithme s'écrit le plus souvent en pseudo-langage de programmation
(appelé langage algorithmique)

Un programme est un assemblage et un enchaînement d’instructions

élémentaires écrit dans un langage de programmation, et exécuté par un
ordinateur afin de traiter les données d’un problème et renvoyer un ou plusieurs
résultats.
L'algorithmique, l'art d'écrire des algorithmes, permet de se focaliser sur la
procédure de résolution du problème sans avoir à se soucier des spécificités
d'un langage particulier.
Pour résoudre un problème, il est vivement conseillé de réfléchir d'abord à
l'algorithme avant de programmer, c'est à dire d'écrire le programme en langage de
programmation.
2. Notion de variables et déclarations

Les programmes ont pour but de traiter différentes données afin de produire des
résultats. Les résultats peuvent eux-mêmes être des données pour d'autres
programmes.

Une variable peut être représentée par une case mémoire, qui contient
la valeur d'une donnée.
Chaque variable possède un nom unique appelé identificateur par lequel
on peut accéder à son contenu.
 Par exemple, on peut avoir en mémoire une variable prix et une variables
quantité qui contiennent les valeurs 10.2 et 5

NB : Attention à ne pas confondre la variable et son contenu

Une variable est un contenant, c'est à dire une sorte de boîte,
alors que le contenu d'une variable est une valeur numérique, alphanumérique ou
booléenne, ou de tout autre type
Deux variables peuvent avoir la même valeur, mais une variable ne peut pas
avoir plusieurs valeurs en même temps.
En revanche, la valeur d'une variable peut varier au cours du programme.
L'ancienne valeur est tout simplement écrasée et remplacée par la nouvelle.
Les variables dont la valeur ne change pas au cours de l'exécution du programme
sont appelées variables constantes ou plus simplement constantes.
Pour qu'un programme puisse utiliser une variable, il faut au préalable que cette
variable soit déclarée, c'est-à-dire que le programme lui ait réservé une place
en mémoire et ait attribué l'identificateur à cette place.
Mais toutes les variables n'ont pas besoin de la même place en mémoire. Un
grand nombre prend plus de place qu'un caractère. Selon le type de l'objet, il
faudra lui réserver plus ou moins de place: c'est pourquoi il faut déclarer le type
des variables et pas seulement leur nom. Par ailleurs, selon le type des
variables, les opérations possibles seront différentes.
Donc la déclaration d'une variable indique deux choses:
❖ son identificateur (son nom)
❖ son type (sa taille)
 Un identificateur peut être composé de lettres et de chiffres mais il ne peut pas
commencer par un chiffre et ne peut comporter d'espaces.
L'identificateur des variables doit être suffisamment signifiant pour qu'on
reconnaisse leur fonction aisément. Par exemple pour des variables représentant
un prix et une quantité, évitez a et b mais utilisez plutôt prix et quant.
Lorsqu’on déclare une variable (réserver un emplacement mémoire), on doit
préciser ce que l’on voudra mettre dedans, car de cela dépendent la taille de
l’emplacement de la mémoire et le type de codage utilisé.
2.1.1 Types numériques classiques
Le type de variable choisi pour un nombre déterminera :
❖ les valeurs maximales et minimales des nombres pouvant être stockés dans la
variable.
❖ la précision de ces nombres (dans le cas de nombres décimaux).
Tous les langages, quels qu’ils soient offrent un « bouquet » de types
numériques, dont le détail est susceptible de varier légèrement d’un langage
à l’autre.
2.1.2 Autres types numériques
Certains langages autorisent d’autres types numériques, notamment :
❑ le type monétaire (avec strictement deux chiffres après la virgule)
❑ le type date (jour / mois / année).

2.1.3 Type alphanumérique

On dispose également du type alphanumérique (également appelé type
caractère, type chaîne ou en anglais, le type string ). Dans une variable de ce
type, on stocke des caractères, qu’il s’agisse de lettres, de signes de
ponctuation, d’espaces, ou même de chiffres. Le nombre maximal de caractères
pouvant être stockés dans une seule variable string dépend du langage utilisé.
En pseudo-code, une chaine de caractères est toujours notée entre
guillemets
2.1.4 Type booléen
Le dernier type de variables est le type booléen : on y stocke uniquement les
valeurs logiques VRAI et FAUX. On peut représenter ces notions de VRAI et
de FAUX par TRUE et FALSE ou par des nombres 0 et 1. Ce qui compte,
c'est de comprendre que le type booléen est très économique en termes de
place mémoire occupée, puisque pour stocker une telle information binaire,
un seul bit suffit.
la déclaration de constante en pseudo-code se fait de la manière suivante :
CONST Identificateur = valeur
Exemple :
CONST Pi = 3,14
Mois = " Janvier "
La déclaration de variables en pseudo-code se fait de la manière suivante :
VAR Identificateur : Type
Exemple :
VAR nombre : entier
VAR PrixHT, TauxTVA, PrixTTC : réel
Nom, Prenom, Marque : chaine
Change : booléen
LA SYNTAXE GÉNÉRALE D’UN PSEUDO-CODE
 3.L’INSTRUCTION D’AFFECTATION
L’une des manipulations qu’on puisse faire avec une variable, c’est l’affecter,
c’est-à-dire lui attribuer une valeur.
En pseudocode, l'instruction d'affectation se note avec le signe ←

My_var ← valeur (permet d'affecter une valeur a une variable)

La valeur peut etre :

✓une variable du même que type que My_var ;
✓une constante du dit My_var ;
✓une expression dont l'évaluation produit un résultat du type My_var
Exemples 1: VAR R : entier
R ← 10
VAR X, Y : entier
R←Y R prend la valeur de Y
X←R X prend la valeur de R
R ← X + Y R prend la valeur de X+Y
R ← R +1 on évalue R + 1 avec l'ancienne valeur de R et on range le
résultat dans R
Exemples 2
MyVar1← 24
Cette instruction attribue la valeur 24 à la variable MyVar1.
Cela sous-entend impérativement que MyVar1 soit une variable de type
numérique. Si MyVar1 a été défini dans un autre type, cette instruction
provoquera une erreur.
On peut en revanche sans aucun problème attribuer à une variable la valeur
d’une autre variable, telle quelle ou modifiée. Par exemple :
MyVar2 ← MyVar1
Signifie que la valeur de MyVar2 est maintenant celle de MyVar1.

Notez bien que cette instruction n’a en rien modifié la valeur de MyVar1. Une instruction
d’affectation ne modifie que ce qui est situé à gauche de la flèche.
MyVar2 ← MyVar1 + 4
Si MyVar1 contenait 12, MyVar2 vaut maintenant 16. De même que précédemment, MyVar1
vaut toujours 12.
MyVar2 ← MyVar2 + 1
Si MyVar2 valait 6, il vaut maintenant 7. La valeur de MyVar2 est modifiée, puisque
MyVar2 est la variable située à gauche de la flèche.
3.1 Ordre des instructions
Il va de soi que l’ordre dans lequel les instructions sont écrites va
jouer un rôle essentiel dans le résultat final. Considérons les deux
algorithmes suivants :
Exemple 1
Var A : Entier
Début
A ← 34
A ← 12
Fin
Exemple 2
Var A : Entier
Début
A ← 12
A ← 34
Fin
 Il est clair que dans le premier cas la valeur finale de A est 12, dans l’autre elle
est 34 .
Il n’y a aucun intérêt à affecter une variable pour l’affecter différemment
juste après. En l’occurrence, on aurait tout aussi bien atteint le même résultat
en écrivant simplement :

Exemple 1
Var A : Entier
Début
A ← 12
Fin
Exemple 2
Var A : Entier
Début
A ← 34
Fin
 PARTIE 1

Énoncé des Exercices

Exercice 1.1
Quelles seront les valeurs des variables A et B après exécution des instructions
suivantes ?
Var A, B : Entier
Début
A ← 1
B ← A + 3
A ← 3
Fin
 Corrigé exercice 1.1

Après La valeur des variables est :

A←1 A=1B=?
B←A+3 A=1B=4
A←3 A=3B=4
Exercice 1.2
Quelles seront les valeurs des variables A, B et C après exécution des
instructions suivantes ?
Var A, B, C : Entier
Début
A ← 5
B ← 3
C ← A + B
A ← 2
C ← B – A
Fin
Exercice 1.3
Quelles seront les valeurs des variables A et B après exécution des
instructions suivantes ?
Var A, B : Entier
Début
A ← 5
B ← A + 4
A ← A + 1
B ← A – 4
Fin
Exercice 1.4
Quelles seront les valeurs des variables A, B et C après exécution des
instructions suivantes ?
Var A, B, C : Entier
Début
A ← 3
B ← 10
C ← A + B
B ← A + B
A ← C
Fin
Exercice 1.5
Quelles seront les valeurs des variables A et B après exécution des
instructions suivantes ?
Var A, B : Entier
Début
A ← 5
B ← 2
A ← B
B ← A
Fin
Les deux dernières instructions permettent-elles d’échanger les deux
valeurs de B et A ? Si l’on inverse les deux dernières instructions, cela
change-t-il quelque chose ?
 4. EXPRESSIONS ET OPÉRATEURS

Une expression est un ensemble de valeurs, reliées par des opérateurs, et

équivalent à une seule valeur.
En résumé, on s’aperçoit que dans une instruction d’affectation, on trouve :
▪ A gauche de la flèche , un nom de variable, et uniquement cela .
▪ A droite de la flèche , ce qu’on appelle une expression.
▪ Une condition supplémentaire de validité d’une instruction d’affectation
est que :
l’expression située à droite de la flèche soit du même type que la variable
située à gauche.
Un opérateur est un signe qui relie deux valeurs, pour produire un
résultat.
Les opérateurs possibles dépendent du type des valeurs qui sont en jeu.
4.1 Opérateurs numériques :
Ce sont les quatre opérations arithmétiques tout ce qu’il y a de classique.

+ : addition
- : soustraction
* : multiplication
/ : division
 4.2 Opérateur alphanumérique : &
Cet opérateur permet de concaténer, autrement dit de mettre bout à bout,
deux chaînes de caractères. Par exemple :

Var A, B, C : chaine de Caractère

Début
A ← "Gloubi"
B ← "Boulga"
C ← A & B
Fin

La valeur de C à la fin de l’algorithme est "GloubiBoulga"

4.3 Opérateurs logiques (ou booléens) :
Il s’agit du ET, du OU et du NON .
Exercice 1.8
Que produit l’algorithme suivant ?
Var A, B, C : chaine
Début
A ← "423"
B ← "12"
C ← A + B
Fin
Exercice 1.9
Que produit l’algorithme suivant ?
Var A, B, C : Chaine
Début
A ← "423"
B ← "12"
C ← A & B
Fin
4.4 Les types et les opérateurs correspondants
1. Pour les entiers, la division est notée Div. Elle est nommée division

entière et diffère un peu de la division que l'on trouve sur les calculettes.
Elle ne donne que le chiffre avant la virgule du résultat (elle renvoie un
entier).
2. Les entiers supportent une opération supplémentaire appelée modulo,
notée mod et qui renvoie le reste de la division entière.
Exemple:
7 / 2 donne 3.5
7 Div 2 donne 3
7 Mod 2 donne 1
3. Les caractères sont comparés selon l’ordre du code ASCII (American
Standard Code for Information Interchange – Code standard Américain de
codage d’information). C’est ainsi qu’on peut comparer tous les caractères
entre eux. Par exemple la lettre Z (majuscule), de code ASCII 90 est inférieure
à la lettre a (minuscule) de code ASCII 97. L’ordre ASCII des lettres de la
même casse suit l’ordre alphabétique, de sorte que A<B<C<D<…
4. L’opérateur & sert à concaténer des chaînes de caractère, ce qui signifie
transformer plusieurs chaînes en une seule en les ajoutant les unes à la suite
des autres.
Ex : « Bonjour » & « à tous » donne « Bonjour à tous »
Table ASCII
 5. Lecture et Ecriture

5.1 Notion de lecture et écriture

Imaginons que nous ayons fait un programme pour calculer le carré d’un
nombre, mettons 12. Si on a fait au plus simple, on a écrit un truc du genre :
Var A : Entier
Début
A ← 12^2
Fin
D’une part, ce programme nous donne le carré de 12. Mais si l’on veut le
carré d’un autre nombre que 12, il faut réécrire le programme.
D’autre part, le résultat est incontestablement calculé par la machine. Mais
elle le garde soigneusement pour elle, et l’utilisateur qui fait exécuter ce
programme, lui, ne saura jamais quel est le carré de 12.
C’est pourquoi, heureusement, il existe des instructions pour permettre à la
machine de dialoguer avec l’utilisateur.
Dans un sens, ces instructions permettent à l’utilisateur de rentrer des
valeurs au clavier pour qu’elles soient utilisées par le programme. Cette
opération est la lecture.
Dans l’autre sens, d’autres instructions permettent au programme de
communiquer des valeurs à l’utilisateur en les affichant à l’écran. Cette
opération est l’écriture.
 5.2 Les instructions de lecture et d’écriture

Pour que l’utilisateur entre la (nouvelle) valeur de la variable Prix, on

mettra :

Lire (Prix)

Dès que le programme rencontre une instruction Lire, l’exécution

s’interrompt, attendant la saisi d’une valeur au clavier par l’utilisateur

Dès lors, aussitôt que la touche Entrée (Enter) a été frappée, l’exécution reprend.
Dans le sens inverse, pour écrire quelque chose à l’écran, c’est aussi simple que :

écrire (Prix )
Avant de Lire une variable, il est très fortement conseillé d’écrire des libellés à
l’écran, afin de prévenir l’utilisateur de ce qu’il doit saisir (sinon, l’ utilisateur
passe son temps à se demander ce que l’ordinateur attend de lui) :

Ecrire ("Entrez la valeur du rayon du cercle:" )

Lire (Rayon)
 Énoncé des Exercices

Exercice 5.1
Quel résultat produit le programme suivant ?
Programme Prog1
Var val, double : réel
Début
Val ← 231
Double ← Val * 2
Ecrire (Val)
Ecrire (Double)
Fin
 Corrigés de l’exercice 5.1

On verra apparaître à l’écran 231, puis 462 (qui vaut 231 * 2)

Exercice 5.2
Ecrire un programme qui demande un nombre à l’utilisateur, puis qui calcule et
affiche le carré de ce nombre.
 Correction de l’Exercice 5.2
Programme NombreCarrée
Var nb, carr : Entier
Début
Ecrire ("Entrez un nombre :")
Lire (nb)
carr ← nb * nb
Ecrire "Son carré est : ", carr
Fin
En fait, on pourrait tout aussi bien économiser la variable carr en remplaçant
les deux avant-dernières lignes par :
Ecrire ("Son carré est : ", nb*nb )
C'est une question de style ; dans un cas, on privilégie la lisibilité de
l'algorithme, dans l'autre, on privilégie l'économie d'une variable.
Exercice 5.3
Ecrire un programme qui lit le prix HT d’un article, le nombre d’articles et le
taux de TVA, et qui fournit le prix total TTC correspondant. Faire en sorte que
des libellés apparaissent clairement.
 Correction Exercice 5.3
Programme CalculPrixTTC
Var nb, pht, ttva, pttc : Réel
Début
Ecrire ("Entrez le prix hors taxes :" )
Lire (pht)
Ecrire ("Entrez le nombre d’articles :")
Lire (nb)
Ecrire ("Entrez le taux de TVA :")
Lire (ttva)
pttc ← nb * pht * (1 + ttva)
Ecrire ("Le prix toutes taxes est : ", pttc)
Fin
Exercice 5.4
Ecrire un algorithme utilisant des variables de type chaîne de caractères, et
affichant quatre variantes possibles de la célèbre « belle marquise, vos beaux
yeux me font mourir d’amour ». On ne se soucie pas de la ponctuation, ni des
majuscules.
 CorrectionExercice 5.4
Programme ExempleChaine
Var Mot1, Mot2, Mot3, Mot4 : Chaine
Début
Mot1 ← "belle Marquise"
Mot2 ← "vos beaux yeux"
Mot3 ← "me font mourir"
Mot4 ← "d’amour"
Ecrire (Mot1 & " " & Mot2 & " " & Mot3 & " " & Mot4 )
Ecrire (Mot3 & " " & Mot2 & " " & Mot4 & " " & Mot1)
Ecrire (Mot2 & " " & Mot3 & " " & Mot1 & " " & Mot4)
Ecrire (Mot4 & " " & Mot1 & " " & Mot2 & " " & Mot3)
Fin
6. Les instructions de branchement conditionnel SI - SINON
6.1 Structure d’un Branchement conditionnel
Il n’y a que deux formes possibles pour un Branchement conditionnel ; la
première est la plus simple, la seconde la forme complete.

Si condition Alors Si condition Alors

Instructions Instructions 1
Finsi Sinon
Instructions 2
Finsi

Forme simple Forme complete

Ou condition est une expression dont la valeur est VRAI ou FAUX. Cela peut
donc être (il n’y a que deux possibilités) :
• une variable (ou une expression) de type booléen
• une condition
Dans la forme la plus simple, arrivé à la première ligne (Si… Alors) la
machine examine la valeur de la condition. Si cette condition a pour valeur
VRAI, elle exécute la série d’instructions. Cette série d’instructions peut être
très brève comme très longue, cela n’a aucune importance. En revanche, dans
le cas où la condition est fausse, l'ordinateur saute directement aux instructions
situées après le FinSi.
Dans le cas de l’instruction de branchement conditionnel complète, c'est à
peine plus compliqué. Dans le cas où la condition est VRAI, et après avoir
exécuté la série d'instructions 1, au moment où elle arrive au mot « Sinon », la
machine saute directement à la première instruction située après le « Finsi ».
De même, au cas où la condition a comme valeur « Faux », la machine saute
directement à la première ligne située après le « Sinon » et exécute
l’ensemble des « instructions 2 ». Dans tous les cas, les instructions situées
juste après le FinSi seront exécutées normalement.
6.2 Qu’est ce qu’une condition ?

Une condition est une comparaison

Cette définition est essentielle. Elle signifie qu’une condition est
composée de trois éléments :
• une valeur
• un opérateur de comparaison
• une autre valeur
Les valeurs peuvent être a priori de n’importe quel type (numériques,
caractères…). Mais si l’on veut que la comparaison ait un sens, il faut que
les deux valeurs de la comparaison soient du même type !
Les opérateurs de comparaison sont illustrés dans le tableau ci-dessous:

opérateurs Symbole
Égal à =
Différent de <>
Strictement inférieur à <
Strictement supérieur à >
Inférieur ou égal à <=
Supérieur ou égal à >=
 Énoncé des Exercices
Exercice 6.1
Ecrire un algorithme qui demande un nombre à l’utilisateur, et l’informe
ensuite si ce nombre est positif ou négatif (on laisse de côté le cas où le nombre
vaut zéro).

Programme test1
Var n : Entier
Début
Afficher( "Entrez un nombre : " )
Saisir( n )
Si n > 0 Alors
Afficher( "Ce nombre est positif " )
Sinon
Afficher ("Ce nombre est négatif" )
Finsi
Fin
6.3 Conditions composées

Certains problèmes exigent parfois de formuler des conditions qui ne peuvent pas
être exprimées sous la forme simple exposée ci-dessus. Par exemple dire que la
variable « Toto est inclus entre 5 et 8 ». revient à dire que « Toto est supérieur
à 5 et Toto est inférieur à 8 ». Il y a donc bien là deux conditions, reliées par ce
qu’on appelle un opérateur logique, le mot ET.
Comme nous l’avons vu plus haut, l’informatique met à notre disposition quatre
opérateurs logiques : ET, OU, NON, et XOR (OU Exclusif).
❑ Pour que "Condition1 ET Condition2" soit VRAI, il faut impérativement
que Condition1 soit VRAI et que Condition2 soit VRAI. Dans tous les autres cas,
"Condition 1 et Condition2" sera faux.
❑ Pour que "Condition1 OU Condition2" soit VRAI, il suffit que Condition1
soit VRAIE ou que Condition2 soit VRAIE. Le point important est que si
Condition1 est VRAIE et que Condition2 est VRAIE aussi, Condition1 OU
Condition2 reste VRAIE. Le OU informatique ne veut donc pas dire « ou bien »
❑ Le XOR (ou OU exclusif) fonctionne de la manière suivante. Pour que
"Condition1 XOR Condition2" soit VRAI, il faut que soit Condition1 soit
VRAI, soit que Condition2 soit VRAI. Si toutes les deux sont fausses, ou que
toutes les deux sont VRAI, alors le résultat global est considéré comme FAUX.
Le XOR est donc l'équivalent du "ou bien" du langage courant.
❑ le NON inverse une condition : NON(Condition1) est VRAI si Condition1
est FAUX, et il sera FAUX si Condition1 est VRAI.
Exercice 6.2
Ecrire un algorithme qui demande deux nombres à l’utilisateur et l’informe
ensuite si leur produit est négatif ou positif (on laisse de côté le cas où le
produit est nul). Attention toutefois : on ne doit pas calculer le produit des
deux nombres.
Programme test2
Var m, n : Entier
Début
Afficher ("Entrez deux nombres : " )
Saisir (m, n )
Si (m > 0 ET n > 0) OU (m < 0 ET n < 0) Alors
Afficher ("Leur produit est positif" )
Sinon
Afficher ( "Leur produit est négatif " )

Finsi
Fin
Exercice 6.3
Ecrire un algorithme qui demande trois lettres à l’utilisateur et l’informe
ensuite s’ils sont rangés ou non dans l’ordre alphabétique.
Programme test3
Var a, b, c : Caractère
Début
Afficher( "Entrez successivement trois lettres : " )
Saisir(a, b, c )
Si a < b ET b < c Alors
Afficher( "Ces lettres sont classés alphabétiquement " )
Sinon

Afficher( "ces lettres ne sont pas classés" )

Finsi
Fin
6.4 Branchement conditionnel imbriqués

Par exemple, un programme devant donner l’état de l’eau selon sa

température doit pouvoir choisir entre trois réponses possibles (solide, liquide
ou gazeuse). Une première solution serait la suivante :
Programme TemperatureEau_1
Var Temp : Entier
Début
Afficher ( "Entrez la température de l’eau :")
Saisir ( Temp)
Si Temp < = 0 Alors
Afficher ("C’est de la glace" )
FinSi
Si Temp > 0 Et Temp < 100 Alors
Afficher ("C’est du liquide" )
Finsi
Si Temp > 100 Alors
Afficher ("C’est de la vapeur" )
Finsi
Fin
Il serait ainsi bien plus rationnel d’imbriquer les tests de cette manière :

Programme TemperatureEau_2
Var Temp : Entier
Début
Afficher ("Entrez la température de l’eau :")
Saisir( Temp)
Si Temp < =0 Alors
Afficher ("C’est de la glace")
Sinon
Si Temp < 100 Alors
Afficher ("C’est du liquide")
Sinon
Afficher ("C’est de la vapeur" )
Finsi
Finsi
Fin
 Nous avons fait des économies : au lieu de devoir taper trois conditions,
dont une composée, nous n’avons plus que deux conditions simples. Mais
aussi, et surtout, nous avons fait des économies sur le temps d’exécution de
l’ordinateur. Si la température est inférieure à zéro, celui-ci écrit dorénavant «
C’est de la glace » et passe directement à la fin, sans être ralenti par l’examen
d’autres possibilités (qui sont forcément fausses).
Cette deuxième version n’est donc pas seulement plus simple à écrire et
plus lisible, elle est également plus performante à l’exécution.
Les structures de tests imbriqués sont donc un outil indispensable à la
simplification et à l’optimisation des algorithmes.
Exercice 6.4
Ecrire un algorithme qui demande un nombre à l’utilisateur, et l’informe ensuite
si ce nombre est positif ou négatif (on inclut cette fois le traitement du cas où
le nombre vaut zéro).
Programme statuNombre_2
Var n : Entier
Début
Afficher("Entrez un nombre : ")
Saisir(n)
Si n < 0 Alors
Afficher("Ce nombre est négatif")
Sinon
Si n = 0 Alors
Afficher("Ce nombre est nul")
Sinon
Afficher("Ce nombre est positif")
Finsi
Finsi
Fin
Exercice 6.5
Ecrire un algorithme qui demande deux nombres à l’utilisateur et l’informe
ensuite si le produit est négatif ou positif (on inclut cette fois le traitement du
cas où le produit peut être nul). Attention toutefois, on ne doit pas calculer le
produit !
Programme test2v2
Var m, n : Entier
Début
Afficher("Entrez deux nombres : " )
Saisir(m, n)
Si m = 0 OU n = 0 Alors
Afficher("Le produit est nul")
Sinon
Si (m < 0 ET n < 0) OU (m > 0 ET n > 0) Alors
Afficher ("Le produit est positif")
Sinon
Afficher("Le produit est négatif")
Finsi
Finsi
Fin
Exercice 6.6
Ecrire un algorithme qui demande l’âge d’un enfant à l’utilisateur.
Ensuite, il l’informe de sa catégorie :
❖ "Poussin" de 6 à 7 ans
❖ "Pupille" de 8 à 9 ans
❖ "Minime" de 10 à 11 ans
❖ "Cadet" après 12 ans
Programme CategoriEnfant
Var age : Entier
Début
Afficher("Entrez l’âge de l’enfant : ")
Saisir(age)
Si age >= 12 Alors
Afficher("Catégorie Cadet")
Sinon
Si age >= 10 Alors
Afficher("Catégorie Minime")
Sinon
Si age >= 8 Alors
Afficher( "Catégorie Pupille")
Sinon
Si age >= 6 Alors
Afficher("Catégorie Poussin ")
Finsi
Finsi
Finsi
Finsi
Fin
Programme EquationSecondDegré
Var a, b , c : Entier
d, x1, x2 :Réel
Début
Afficher( "Entrez le coefficient a : " )
Saisir( a)
Afficher( "Entrez le coefficient b : " )
Saisir( b)
Afficher("Entrez le coefficient c : " )
Saisir( c)
d  b^2 - 4*a*c
Si d < 0 Alors
Afficher( "Pas de solution« )
Sinon
Si d = 0 Alors
x1  -b/2*a
x2  -b/2*a
Afficher(" x1= ",x1 )
Afficher( " x2= ",x2)
Sinon
x1  (-b - racine(d))/2*a
x2  (-b + racine(d))/2*a
Afficher(" x1= ",x1 )
Afficher(" x2= ",x2)
Finsi
Finsi
Fin
 7. Structure Selon
La structure Selon permet de choisir l’instruction (ou ensemble
d’instructions) à exécuter en fonction de la valeur ou de l'intervalle de valeur
d'une variable ou d'une expression. Cette structure permet de remplacer
avantageusement une succession de structures Si…Alors. La syntaxe de cette
structure est :

Selon variable Faire

valeur 1 : instruction 1
valeur 2 : instruction 2
valeur 3 : instruction 3
…………….
[Sinon instruction par défaut]
FinSelon

La valeur de la variable ou de l’expression est comparée successivement aux

valeur1, valeur2, valeur3, etc. et en cas d’égalité l’instruction correspondantes
est exécutée. Si aucune des valeurs ne correspondent à la valeur de la variable et
que sinon est présent, c’est l’instruction par défaut qui est exécutée . Si en
revanche le sinon n’est pas présent, on sort de la structure selon.
Exemple : l'algorithme qui affiche le mois en toute lettre selon son numéro.
Le numéro du mois en mémorisé dans la variable mois.
Programme NomduMois
Var mois : entier
Début
Ecrire " Entrez le numéro du mois "
Lire mois
Selon mois Faire
1 : Ecrire "Janvier"
2 : Ecrire "Février"
3 : Ecrire "Mars"
4 : Ecrire "Avril"
5 : Ecrire "Mai"
6 : Ecrire "Juin"
7 : Ecrire "Juillet"
8 : Ecrire "Aout"
9 : Ecrire "Septembre"
10 : Ecrire "Octobre"
11 : Ecrire "Novembre"
12 : Ecrire "Décembre"
Sinon Ecrire "Un numéro de mois doit être compris entre 1 et 12"
Finselon
Fin
Exercice : Un Robot conduit une voiture, il peut exécuter trois actions
« S’arreter», « Ralentir», « Passer» en fonction de la couleur des feux qui sera
saisi . Ecrire le programme du robot.

Programme Robot
Var couleur : chaine
Début
Ecrire "Entrez la couleur "
Lire couleur
Selon couleur Faire
Vert : Ecrire "Passer"

Orange: Ecrire "Ralentir"

Rouge : Ecrire " S’arreter "
Sinon Ecrire "Entrez une couleur correcte"
Finselon
Fin
 8. La Boucle ou structure répétitive TANT QUE … Faire
Tant Que Condition Faire
Instruction
etc.
FinTantQue
Instruction peut être :
- - une instruction simple
-- un ensemble d’instructions
-- un algorithme ou un sous-programme.
Le principe de fonctionnement de la boucle TantQue est simple : lorsque
programme arrive sur la ligne du TantQue. Il examine alors la valeur de la
condition. Si cette valeur est VRAI, le programme exécute les instructions qui
suivent, jusqu’à ce qu’il rencontre la ligne FinTantQue. Il retourne ensuite sur
la ligne du TantQue, procède au même examen, et ainsi de suite. Le l’exécution
du programme ne s’arrête que lorsque la condition prend la valeur FAUX.
Exercice 8.1
Ecrire un algorithme qui demande à l’utilisateur un entier naturel N > 1 puis
calcul et affiche son factoriel par la suite.
Programme factoriel
Var N , i : Entier
Fact : Réel
Début
Ecrire "Entrez la valeur de N"
Lire (N )
TantQue N < 0 Faire
Ecrire ("Entrez une valeur valide de N supérieur ou égale à 0" )
Lire (N)
FinTantQue
Si N = 0 Ecrire " Fact= ", 1
Sinon
i←1
Fact ← 1
TantQue i < = N
Fact ←Fact*i
i ←i+1
FinTantQue
Ecrire " Fact = ", Fact
FinSi
Fin
 9. La Boucle ou structure répétitive répéter … jusqu’à

Répéter
Action 1
Action 2
etc.
Jusqu’à Condition
Action 1, Action 2, … peut être :
- - une instruction
-- un ensemble d’instructions
-- un algorithme
La condition est testée après l’exécution des l’actions définies (action 1, action 2,etc.).
Cette boucle est utilisée lorsque le corps de la boucle doit être exécuter au moins une fois.
Exemple : Ecrire un programme qui permet d’afficher la table des carrées de 1 à 5
1^2=1, 2^2= 4, 3^2 = 9, 4^2 = 16, 5^2 = 25

Programme carré
Var
nb : entier
Début
nb 1
Répéter
Ecrire nb, « ^2= » nb*nb
nb  nb +1
Jusqu’à nb = 6
Fin
10. La Boucle ou structure répétitive Pour
Algorithmes et Structures de
Données 2

Dr. A . SIDIBE
Structure de données

Une structure de données est un moyen particulier de stocker et d'organiser des données dans un ordinateur
afin qu'elles puissent être utilisées efficacement.
Différents types de structures de données sont adaptés à différents types d'applications, et certains sont
hautement spécialisés pour des tâches spécifiques.
Les structures de données fournissent un moyen de gérer efficacement d'énormes quantités de données,
telles que de grandes bases de données et des services d'indexation Internet. En général, des structures de
données efficaces sont essentielles pour concevoir des algorithmes efficaces.
 Aperçue des structures de données
❑ Une structure de données de tableau stocke un certain nombre d'éléments du même type dans un ordre
spécifique. Ils sont accessibles en utilisant un entier pour spécifier quel élément est requis (bien que les
éléments puissent être de presque n'importe quel type). Les tableaux peuvent être de longueur fixe ou
extensibles.
❑ Enregistrement (également appelé tuple ou struct) Les enregistrements font partie des structures de
données les plus simples. Un enregistrement est une valeur qui contient d'autres valeurs, généralement
sous forme de nombre et de séquence fixes et généralement indexées par noms. Les éléments des
enregistrements sont généralement appelés champs ou membres.
❑ Un hachage, un dictionnaire ou une carte est une variante plus flexible d'un enregistrement, dans
laquelle des paires nom-valeur peuvent être ajoutées et supprimées librement.
❑ Union. Une définition de type d'union spécifiera lequel parmi un certain nombre de types primitifs
autorisés peut être stocké dans ses instances, par ex. "float ou long integer". Contraste avec un
enregistrement, qui pourrait être défini pour contenir un flottant et un entier; alors que, dans une union,
il n'y a qu'une seule valeur à la fois.
❑ Un ensemble est une structure de données abstraite qui peut stocker des valeurs spécifiques, sans ordre
particulier et sans valeurs répétées. Les valeurs elles-mêmes ne sont pas extraites des ensembles, on teste
plutôt une valeur d'appartenance pour obtenir un booléen "in" ou "not in".
❑ Un objet contient un certain nombre de champs de données, comme un enregistrement, ainsi qu'un certain
nombre de fragments de code de programme pour y accéder ou les modifier. Les structures de données ne
contenant pas de code, comme celles ci-dessus, sont appelées structures de données anciennes.
Beaucoup d'autres sont possibles, mais ils ont tendance à être d'autres variations et composés de ce qui
précède.
Principes de base

Les structures de données sont généralement basées sur la capacité d'un ordinateur à récupérer et à stocker des
données à n'importe quel endroit de sa mémoire, spécifié par une adresse - une chaîne de bits qui peut être elle-
même stockée en mémoire et manipulée par le programme. Ainsi, les structures de données d'enregistrement et
de tableau sont basées sur le calcul des adresses d'éléments de données avec des opérations arithmétiques;
tandis que les structures de données liées sont basées sur le stockage des adresses d'éléments de données dans la
structure elle-même. De nombreuses structures de données utilisent les deux principes, parfois combinés de
manière non triviale (comme dans la liaison XOR).
L'implémentation d'une structure de données nécessite généralement l'écriture d'un ensemble de procédures qui créent et
manipulent des instances de cette structure. L'efficacité d'une structure de données ne peut être analysée séparément de ces
opérations.
Cette observation motive le concept théorique d'un type de données abstrait, une structure de données qui est définie
indirectement par les opérations qui peuvent être effectuées sur elle, et les propriétés mathématiques de ces opérations (y
compris leur coût en espace et en temps).
 Les Tableaux
Type de données de tableau
Un type de tableau est un type de données destiné à décrire une collection d'éléments (valeurs ou variables),
chacun sélectionné par un ou plusieurs indices (clés d'identification) qui peuvent être calculés au moment de
l'exécution par le programme. Une telle collection est généralement appelée une variable de tableau, une
valeur de tableau ou simplement un tableau. Par analogie avec les concepts mathématiques de vecteur et de
matrice, les types de tableaux avec un et deux indices sont souvent appelés respectivement type de vecteur et
type de matrice.

Structure des données du tableau

Une structure de données de tableau ou simplement un tableau est un ensemble d'éléments de même type
désignés par un identificateur unique ; chaque élément est repéré par un indice précisant sa position au sein
de l'ensemble. Au lieu de déclarer des variables individuelles, telles que nombre0, nombre1, ... et nombre99,
vous déclarez une variable de tableau telle que des nombres et utilisez les nombres [0], les nombres [1] et ...,
les nombres [99] pour représenter variables individuelles. Un élément spécifique d'un tableau est accessible
par un indice.
Tous les tableaux sont constitués d'emplacements mémoire contigus. L'adresse la plus basse correspond au
premier élément et l'adresse la plus élevée au dernier élément.

Les tableaux sont analogues aux concepts mathématiques de vecteurs et matrices. En effet, les tableaux
avec un ou deux indices sont souvent appelés respectivement vecteurs ou matrices. Les tableaux sont
souvent utilisés pour implémenter des tables, en particulier des tables de recherche; le mot table est parfois
utilisé comme synonyme de tableau.
Les tableaux sont parmi les structures de données les plus anciennes et les plus importantes, et sont utilisés
par presque tous les programmes. Ils sont également utilisés pour implémenter de nombreuses autres
structures de données, telles que des listes et des chaînes.
Applications des Tableaux

Les tableaux sont utilisés pour implémenter des vecteurs et des matrices mathématiques, ainsi que d'autres
types de tableaux rectangulaires. De nombreuses bases de données, petites et grandes, se composent (ou
incluent) des tableaux unidimensionnels dont les éléments sont des enregistrements.
Les tableaux sont utilisés pour implémenter d'autres structures de données, telles que des tas, des tables de
hachage, des deques, des files d'attente, des piles, des chaînes et des listes virtuelles.
Déclaration de tableaux

Pour déclarer un tableau en C, on spécifie le type des éléments et le nombre d'éléments requis par
un tableau comme suit:

type arrayName [ arraySize ];

C'est ce qu'on appelle un tableau a une dimension. Le arraySize doit être une constante entière supérieure à
zéro et le type peut être n'importe quel type de données C valide.
Par exemple, pour déclarer un tableau de 10 éléments appelé TableauA de type double, on utilise
instruction suivante:

double TableauA[10];

Ici, TableauA est un tableau de variables qui est suffisant pour contenir jusqu'à 10 nombres de type double.
Initialisation des tableaux
On peut initialiser un tableau en C un par un ou en utilisant une seule instruction comme suit:

double TableauA[5] = {1000.0, 2.0, 3.4, 7.0, 50.0};

Le nombre de valeurs entre accolades {} ne peut pas être supérieur au nombre d'éléments que nous déclarons
pour le tableau entre crochets []. Si vous omettez la taille du tableau, un tableau juste assez grand pour contenir
l'initialisation est créé. Par conséquent, si vous écrivez
double TableauA[] = {1000.0, 2.0, 3.4, 7.0, 50.0};

Vous allez créer exactement le même tableau que vous l'avez fait dans l'exemple précédent. Voici un exemple
pour affecter un seul élément du tableau.

TableauA[4] = 50.0;

L'instruction ci-dessus attribue au 5e élément du tableau une valeur de 50,0. Tous les tableaux ont 0 comme
index de leur premier élément qui est également appelé l'index de base et le dernier index d'un tableau sera la
taille totale du tableau moins 1. Ci-dessous est la représentation picturale du tableau dont nous avons discuté
ci-dessus. TableauA
Accès aux éléments du tableau

Un élément est accessible en indexant le nom du tableau. Cela se fait en plaçant l'index de l'élément entre
crochets après le nom du tableau. Par exemple

double salary = tableauA[9];

L'instruction ci-dessus prendra le 10e élément du tableau et attribuera la valeur à la variable de salary. L'exemple
suivant montre comment utiliser les trois concepts mentionnés ci-dessus, à savoir. déclaration, affectation et accès
aux tableaux.
#include <stdio.h> Lorsque le code ci-contre est compilé et
exécuté, il produit le résultat suivant
int main () {

int n[ 10 ]; /* n est un tableau de 10 entiers */

int i,j;

/* initialisation des elements du tableau n a 0 */

for ( i = 0; i < 10; i++ ) {
n[ i ] = i + 100; /* définir l'élément à l'emplacement i a i + 100 */
}

/* afficher la valeur de chaque élément du tableau*/

for (j = 0; j < 10; j++ ) {
printf("Element[%d] = %d\n", j, n[j] );
}

return 0;
}
Tableaux a multiple dimensions
Le langage de programmation C autorise les tableaux multidimensionnels. Voici la forme générale d'une
déclaration de tableau multidimensionnel
type name[size1][size2]...[sizeN];

Par exemple, la déclaration suivante crée un tableau d'entiers en trois dimensions:

int threedim[5][10][4];

Tableaux a deux dimensions

La forme la plus simple de tableau multidimensionnel est le tableau à deux dimensions. Un tableau à deux
dimensions est, par essence, une liste de tableaux à une dimension. Pour déclarer un tableau d'entiers à
deux dimensions de taille [x][y], vous écririez quelque chose comme suit:
type arrayName [x][y];

Où type peut être n'importe quel type de données C valide et arrayName sera un identificateur C valide.
Un tableau à deux dimensions peut être considéré comme un tableau qui aura x nombre de lignes et y
nombre de colonnes.
Un tableau à deux dimensions a, qui contient trois lignes et quatre colonnes peut être affiché comme suit:

Ainsi, chaque élément du tableau a est identifié par un nom d'élément de la forme a [i] [j], où 'a' est le nom du tableau,
et 'i' et 'j' sont les indices qui identifient de manière unique chaque élément dans ‘a’.

Initialisation de tableaux à deux dimensions

Les tableaux multidimensionnels peuvent être initialisés en spécifiant des valeurs entre crochets pour chaque ligne. Voici
un tableau avec 3 lignes et chaque ligne a 4 colonnes.

int a[3][4] = {
{0, 1, 2, 3} , /* initialiseurs pour la ligne indexée par 0*/
{4, 5, 6, 7} , /* initialiseurs pour la ligne indexée par 1*/
{8, 9, 10, 11} /* initialiseurs pour la ligne indexée par 2*/
};
Les accolades imbriquées, qui indiquent la ligne voulue, sont facultatives. L'initialisation suivante est
équivalente à l'exemple précédent:
int a[3][4] = {0,1,2,3,4,5,6,7,8,9,10,11};

Accès aux éléments d’un tableau a deux dimensions

Un élément d'un tableau à deux dimensions est accessible en utilisant les indices, c'est-à-dire l'index de ligne
et l'index de colonne du tableau. Par exemple:
int val = a[2][3];
L'instruction ci-dessus prendra le 4ème élément de la 3ème ligne du tableau. Vous pouvez le vérifier dans la
figure ci-dessus. Vérifions le programme suivant où nous avons utilisé une boucle imbriquée pour gérer un
tableau à deux dimensions
#include <stdio.h> Lorsque le code ci-dessus est compilé et exécuté, il
produit le résultat suivant:
int main () {

/* an array with 5 rows and 2 columns*/

int a[5][2] = { {0,0}, {1,2}, {2,4}, {3,6},{4,8}};
int i, j;

/* output each array element's value */

for ( i = 0; i < 5; i++ ) {

for ( j = 0; j < 2; j++ ) { Comme expliqué ci-dessus, vous pouvez avoir des
printf("a[%d][%d] = %d\n", i,j, a[i][j] ); tableaux avec n'importe quel nombre de
} dimensions, bien qu'il soit probable que la plupart
} des tableaux que vous créez soient d'une ou deux
dimensions.
return 0;
}