Algorithmique I

Algorithme

 Un algorithme est une suite finie d'instructions bien détaillées qui, si elles sont
correctement exécutées dans un ordre bien déterminé, conduit à un résultat
donné.

 Exemple: Pour résoudre une équation de deuxième groupe t-q : 𝑎𝑋 2 + 𝑏𝑋 + 𝑐 = 0

o Calculer le delta
o Vérifier si le delta : (∆ < 0) ou (∆ == 0) ou (∆ > 0).
o Si l’équation admet une solution on calcule le X.
 Si ∆ < 0 L’équation n’admet pas de solution dans R.
−𝑏
 Si ∆ == 0 Cette équation admet une solution inique 𝑋 = 2𝑎
−𝑏− ∆ −𝑏+ ∆
 Si ∆ > 0 Cette équation admet deux solutions 𝑋1 = 𝑒𝑡 𝑋2 =
2𝑎 2𝑎
o On affiche la solution (X).
Phases d’un algorithme

 D’après l’exemple précèdent on peut détruire que les étapes d’un algorithme sont :

 Etape 1 : L’entrée des données

o Les donnes d’entrées : a, b et c.

 Etape 2 : Le traitement des données

o Le calcule de delta
o Vérification de delta
o Calcule de x si l’équation admet une solution

 Etape 3 : La sortie des résultats

o L’affichage de X ou bien afficher un message pour indique que l’équation n’admet pas de solution.
Structure d’un algorithme

Entête Algorithme nom d’algorithme. Algorithme Equation

Variable Variable
a, b ,c : réel ;
Déclaration Nom_variable : type_variable; x : réel ;

Début Début
- Instruction 1 ; - Saisir a, b et c;
Manipulation - Instruction 2 ; - Calculer le delta;
(Corps) - Instruction 3 ; - Vérification de delta;
- . - Calculer le x;
- . - Afficher le x;
- Instruction n ; Fin
Fin
Déclaration des objets

 Les Objets sont de deux type : les constantes et les variables

 Constante : une constante est un objet qui reste inchangé durant toute l’exécution de
programme.

 Variable : une variable est un objet dont le contenu peut être modifie par une action.
Déclaration des objets

 Constante

 Syntaxe :
Constante Nom_Constante = valeur ;
 Exemple :
Constante Pi= 3.14;

 Pour calculer la surface d’une cercle, la valeur de Pi est constante.

Déclaration des objets

 Variable

 Syntaxe :
 Variable Nom_Variable : type ;
 Exemple :

 Variable A : réel;
 Variable nom : chaine de caractères;
 Variable i, j, k : Entier;
Type de Variable

 Le type entier : Les entiers sont des nombres qui s’expriment sans virgule, et peuvent
être positifs ou négatifs.
 Le type réel : Les réels sont des nombres qui s’expriment avec ou sans une virgule.
 Le type caractère : représentent un type qui accepte un seul caractère alphabétique,
numériques ou symboles.
 Le type chaîne de caractères : représentent un type qui accepte des caractères
alphabétiques, numériques ou symboles. Il s’agit tout simplement d’un texte.
 Le type logique ou booléen: Les booléens représentent un type qui n’accepte que l’une
des deux valeurs « vrai » ou « faux », que l’on peut aussi représenter par 0 ou 1.

Une variable de type numérique ne peut

pas recevoir une chaine de caractères ou
booléen
Traitement séquentiel (affectation, écriture et lecture)

 L’affectation consiste à attribuer une valeur à une variable.

 En pseudo-code, l'affectation est notée par le signe  Python:
A=6
 Var  e : attribue la valeur de e à la variable Var B=A+4
 L’affectation ne modifie que ce qui est à gauche de la flèche.
Exemple :
• L’instruction : A  6 signifie « mettre la valeur 6 dans la case mémoire identifiée par A ».
• L’instruction : B  (A + 4) range dans B la valeur 10 (A toujours égale à 6).

 • La valeur ou le résultat de l’expression à droite du signe d’affectation doit être de

même type ou de type compatible avec celui de la variable à gauche.
Traitement séquentiel (affectation, écriture
et lecture)

 L'écriture permet d'afficher des résultats à l'écran (ou de les écrire dans un fichier).
 En pseudo-code, on note :

Algorithme: Python:
Ecrire (variable); print (variable)
Ecrire (“message”); print (“message”)
Ecrire(“message”, variable); Print (“message”, variable)

 Par exemple:
 Ecrire (A) : Afficher sur l’écran la valeur de la variable A
 Ecrire (“Hi”) : Afficher sur l’écran le message Hi
 Ecrire(“Hi”, A) :Afficher sur l’écran le message Bonjour! Suivi par la valeur de la
variable A
Traitement séquentiel (affectation, écriture
et lecture)

 La lecture permet d'entrer des données à partir du clavier. La machine met la valeur
entrée au clavier dans la zone mémoire nommée var.
 En pseudo-code, on note :
Algorithme:
Python:
Lire (variable1) ;
Var1 = input (“message”)
Lire (variable2) ;
Var2 = input (“Entrez un nombre”)
Lire (variable1, variable2) ;
Var3 = input ()

 Par exemple:
 Lire(A); : Demande à l'utilisateur d'entrer une valeur pour la variable A
 Les opérateurs
Conditions

 Les instructions conditionnelles servent à n'exécuter une instruction ou une séquence

d'instructions que si une condition est vérifiée.
 En pseudo-code:

Algorithme: Python:
Si x > 0 alors if x > 0:
Ecrire (‘x est positif’); print (‘x est positif’);
Sinon else:
Ecrire (‘x est negative ou nul’); print (‘x est negative ou nul’);
FinSi
Application de conditions

 On dispose d’un ensemble des tâches que l’on souhaite exécuter en fonction de la
valeur d’une variable choix de type entier, conformément au tableau suivant :

Valeur de choix Tâche à exécuter

1 Commande
2 Livraison
3 Facturation
4 Règlement
5 Stock
Autre valeur ERREUR
Algorithme ensemble des tâches
Variable :
Choix : Entier ;
Début
Ecrire (‘’Donner votre choix’’) ;
Lire (choix) ;
Si choix == 1 alors
Commande
sinon selon cas choix faire :
si choix == 2 alors cas 1: Commande
Livraison
cas 2: Livraison
Sinon
si choix == 3 alors
cas 3: Facturation
Facturation cas 4: Règlement
Sinon sinon Ecrire (‘’Erreur’’);
si choix == 4 alors fin Selon
Règlement
Sinon
si choix == 5 alors
Stock
Sinon
Ecrire (‘’Erreur’’);
finsi
finsi
finsi
finsi
finsi
Fin
Pour ……….Faire

 Structure « Pour ……….Faire »

 Le compteur (variable de contrôle) prend la valeur initiale au moment d’accès à la
boucle puis, à chaque parcours, il passe automatiquement à la valeur suivante dans
son domaine jusqu’à atteindre la valeur finale.
 Syntaxe:
Pour <compt> de <VI> à <VF> faire
Instructions;
Finpour

 exercice : écrire un algorithme permettant de lire N réels, de calculer et d’afficher

leur moyenne.
Algorithme moyenne
Var
n, i : Entier; Python:
x, s : réel ;
Debut
Lire(n) ; N = int( input())
S 0; S=0
Pour i de 1 à n faire : for i in range(0, N):
Lire (x); X = float( input ())
ss+x; S=S+X
Finpour print("la moyenne est :", S)
ecrire( “la moyenne est :”, s ) ;
Fin
TantQue Faire

 Structure « TantQue Faire »

 Le traitement est exécuté aussi longtemps que la condition est vérifiée. Si dès le début
cette condition est fausse, le traitement ne sera exécuté aucune fois.
 Syntaxe:
tant que <Condition> faire :
Instructions;
Fin tant que

 Exercice : Afficher tous les multiples d’un entier N, inférieurs à 100

Algorithme Multiples_de_N
Variable
Python:
N, i : Entier ;
Début
Ecrire (‘’ saisir l’entier N’’) ;
N = int( input("saisir l’entier N \n"))
Lire(N) ;
i=1
i1;
while (N*i <100):
Tant que (N*i< 100) faire
print(N, "est un multipe")
ecricre(‘’ les mult est ’’, N*i)
N = N*i
ii+1;
i=i+1
Fin tant que
Fin
Répéter…..Jusqu' à

 Structure « Répéter…..Jusqu' à »
 La séquence d’instructions est exécutée une première fois, puis l’exécution se répète
jusqu’à ce que la condition de sortie soit vérifiée.

 Syntaxe: Répéter
<Instructions> ;
Jusqu’à <condition>
 Exercice : Calcul de la somme des nombres pairs

 Écrivez un algorithme qui calcule et affiche la somme des nombres pairs de 1 à

un nombre entier positif saisi par l'utilisateur.
Algorithme Somme_pairs Python:
Variable
print("Entrez un nombre entier positif :\n")
Nombre, somme, i : Entier
Début N = int(input())
Ecrire( "Entrez un nombre entier positif :") somme = 0
lire (nombre) for i in range (1, N):
somme  0 if (i % 2 == 0):
pour i  1 à nombre Faire somme = somme + i
si (i mode 2 == 0) alors print( "La somme des nombres pairs de 1 à", N, "est :",
somme  somme + i somme )
fin si
fin pour
Ecrire ( "La somme des nombres pairs de 1 à", nombre, "est :", somme )
Fin
Tableaux

 Un tableau est une structure de données qui permet de stocker à l’aide d’une seule
variable un ensemble de valeurs de même type.
 Syntaxe :
 Variable tab[N] : Entier
 Exemple : 0 1 2 3 4 5 6
 Variable Note[7] : réels 13 5 19 11 7 10 15
 L’accès à un élément du tableau se fait via la position
 Note[2] correspond à la case 2 ayant la valeur 5
Lecture et Ecriture d’un tab

Algorithme Lecture_Ecriture_Tab Python:

Variable
note [20] : Réel tab = []
i : Entier
Début
// Lecture d’un tab
# Lecture d’un tab
Pour i 1 à 20 faire for i in range(0,20):
Écrire ("Donner la note de l’étudiant " , i , " : ") print(" Donner la note de l’étudiant",i)
Lire(note[i]) elet=int(input())
Finpour
[Link](elet)
// Ecriture d’un Tab
Pour i 1 à 20 faire # Ecriture d’un Tab
Ecrire(‘’La note de l’étudiant " , i , " est: " , note[i] ) print("affichage des notes")
Finpour
for i in range(0,20):
Fin print(tab[i])
Tableaux

 Exercice :

 Ecrire un algorithme permettant de déclarer et remplir un tableau d’entier de taille

maximal 20 et qui affiche le maximum et sa position.
 // Algorithme Maximum Python:
 Variable Table: Réel [20]
 i, Pmax : Entier tab = []
 Max : Réel print("Donner le premier nombre \n")
 Début elet=int(input())
[Link](elet)
 Écrire ("Donner la premier nombre")
Max = elet
 Lire (Table[1])
Pmax = 0
 Max  Table [1]
# Lecture d’un tab
 Pmax  1 for i in range(1,5):
 Pour i  1 à 20 Faire print("saisir l'élement d'indice ",i)
 Écrire ("Donner le nombre ", i , " : ") elet=int(input())
 Lire (Table [i]) [Link](elet)
 Si (Table [i] > Max) Alors if elet> Max:
 Max  Table [i] Max = elet
 Pmax  i Pmax = i
 FinSi print("Le maximum est : " , Max, "ce
 Fin Pour trouve a la position", Pmax )
 Écrire ("Le maximum est : " , Max, ‘’ ce trouve a la position ‘’, Pmax )
 Fin
Les tableaux à deux dimensions

 Les tableaux à deux dimensions se représentent comme une matrice ayant un

certain nombre de lignes (première dimension) et un certain nombre de colonne
(seconde dimension).
 Syntaxe de déclaration d’un tableau à n dimensions :
Variable identificateur : tableau [nb_lignes , nb_colonnes] de <type>

0 1 2 3 4 5
0 13 5 19 11 7 10
 Exemple:
1 15 4 10 19 12 8
 Variable Note : Réels [ 3, 6 ]
2 16 5 9 14 7 6
 // Saisir
 Pour i  1 à 3 Faire
 Pour j  1 à 6 Faire
 Écrire ("Donner la note de l’étudiant " , i , " : dans la matière : " , j , " : " )
 Lire (note [i, j])
 Fin Pour
 Fin Pour

 // Affichage
 Pour i  1 à 3 Faire
 Pour j  1 à 6 Faire
 Écrire (" La note de l’étudiant " , i ," : dans la matière ; " , j , " est : ", note [i, j] )
 Fin Pour
 Fin Pour
Trier par sélection

 Exercice :
Ecrire un algorithme qui permet de saisir et de stocker N nombres dans un tableau puis de trier
par sélection les éléments de ce tableau (tri par ordre croissant).

 Principe :
Le tri par sélection est la méthode de tri la plus simple. Elle consiste à :
• Chercher l’indice du plus petit élément du tableau T[1..n] et permuter
l’élément correspondant avec l’élément d’indice 1.
• Chercher l’indice du plus petit élément du tableau T[2..n] et permuter
l’élément correspondant avec l’élément d’indice 2.
•…
• Chercher l’indice du plus petit élément du tableau T[n-1..n] et permuter
l’élément correspondant avec l’élément d’indice (n-1).
 #--------------- Tri par selection ---------------
//Algorithme TriTableau croissant
Variables i, j, val, N: Entiers
T[N] : Réel print("saisir la taille du tableau \n")
Début n=int(input())
Ecrire ("Entrer la taille du tableau :") T = []
Lire (N) for i in range(0,n):
Pour i←1 à N Faire print("saisir l'élement d'indice ",i)
Ecrire ("Entrez le nombre n° ", i) elet=int(input())
Lire (T[i]) [Link](elet)
Fin Pour
// Tri par selection # Tri par selection
Pour i←1 à N-1 Faire
for i in range(0,n-1):
Pour j←i+1 à N Faire
Si (T[j] < T[i]) Alors for j in range(i+1, n):
val ← T[j] if(T[j] < T[i]):
T[j]← T[i] val=T[j]
T[i] ← val T[j]= T[i]
Fin Si T[i] = val
Fin Pour
Fin Pour print("le tableau après modifications ::::::")
Fin for i in range(0,n):
print(T[i])
par Insertion

 Exercice :
Ecrire un algorithme qui permet de saisir et de stocker N nombres dans un tableau puis de
trier par Insertion les éléments de ce tableau (tri par ordre croissant).

 Principe :
 //Algorithme Tri_par_order_croissant
 Variables i, j, k, N: Entiers
 T[N] : Réel
 Début
 Ecrire ("Entrer la taille du tableau :")
 Lire (N)
 Pour i←1 à N Faire
 Ecrire ("Entrez le nombre n° ", i)
 Lire (T[i])
 Fin Pour
 // tri_par_insertion
 j ←2
 tant que j<=N faire:
 i←j–1
 k ← t[j]
 tant que i>0 et t[i]>k faire:
 t[i+1] ← t[i]
 i←i-1
 Fin tant que
 T[i+1] ← k
 j←j+1
 Fin tant que
 Fin
Tri à Bulles

 Exercice :
Ecrire un algorithme qui permet de saisir et de stocker N nombres dans un tableau puis de
trier à bulles les éléments de ce tableau (tri par ordre croissant).

 Principe :

 La méthode de tri à bulles nécessite deux étapes :

 Parcourir les éléments du tableau de 1 à (n–1) ; si l’élément i est
supérieur à l’élément (i+1), alors on les permute.
 Le programme s’arrête lorsqu’aucune permutation n’est réalisable
après un parcours complet du tableau.
Algorithme Tri_Bulle
Variable
 i, x, N : Entier
 échange : Booléen
 T[N] : Réel
Début
 Ecrire ("Entrer la taille du tableau :")
 Lire (N)
 Pour i←1 à N Faire
 Ecrire ("Entrez le nombre n° ", i)
 Lire (T[i])
 Fin Pour
 // tri_par_Bulle
 Répéter
 échange ← Faux
 Pour i ← 1 à (n-1) Faire
 Si (T[i] > T[i+1]) Alors
 x ← T[i]
 T[i] ← T[i+1]
 T[i+1] ← x
 échange:= Vrai
 FinSi
 FinPour
 Jusqu’à (échange = Faux)
Fin
 Solution:
Algorithme Calcul de la somme des nombres pairs
Variable
nombre : Entier;
Somme : Entier;
Début
Ecrire( "Entrez un nombre entier positif :");
lire nombre;
Somme  0;
 schéma conditionnel à choix multiple

Algorithme Algorithme

Cas <var> de: Cas <var> de:

<valeur 1> : <action 1> <valeur 1> : <action 1>
< valeur 2> : <action < valeur 2> : <action
2> 2>
... ...
< valeur n> : <action < valeur n> : <action
n> n>
Sinon : <action_sinon> Sinon : <action_sinon>
FinCas FinCas
 40

Algorithmique en informatique

 Les types des variables

Le type de la variable représente la taille et les caractéristique de la boite (case mémoire).

Les valeur qu’on peut donner aux variables doivent respecter le type renseigné

• Les entiers
• Les réels
Les entiers sont des nombres qui s’expriment sans virgule, et peuvent être positifs ou
négatifs.
Les réels sont des nombres qui s’expriment avec une virgule.
• Les booléens
Les booléens
• Les chaines représentent un type qui n’accepte que l’une des deux valeurs « vrai » ou
de caractères
« faux », que l’on peut aussi représenter par 0 ou 1.
Les chaines de caractères représentent un type qui accepte des caractères alphabétiques,
numériques ou symboles. Il s’agit tout simplement d’un texte.