Bases d’algorithmique 2nde → BTS1 janvier 2012
Polycopié
PLAN
1 .Vocabulaire.
1.1 Définition d'un algorithme.
1.2 Variable, affectation.
2. Structures importantes.
2.1 Instruction conditionnelle .
2.2 Boucle itérative.
2.3 Boucle conditionnelle.
Liste d'exemples d'algorithmes
1 Image par une fonction .
2 Triangle rectangle en C
3 Image par une fonction en tenant compte
de l’ensemble de définition .
4 Jeu de Pile ou Face.
5 Table de multiplication .
6 Calcul d’une somme d’entiers .
7 Algorithme d’Euclide de calcul du PGCD.
-------------------------------------------------------------------------------------------------------------
Prévoir une activité simple en introduction.
1 Vocabulaire
1.1 Définition :
Un algorithme est une suite finie d’opérations élémentaires,
à appliquer dans un ordre déterminé,à des données.
Sa réalisation permet de résoudre un problème donné.
Exemples :
Suivre un plan pour se rendre à un endroit, faire une division euclidienne
à la main sont des exemples d’algorithme.
Remarques : ( Quelques banalités..... )
• Un algorithme doit être lisible de tous.
Son intérêt, c’est d’être codé dans un langage informatique
afin qu’une machine (ordinateur, calculatrice, etc.)
puisse l’exécuter rapidement et efficacement.
• Un algorithme comporte tois phases ordonnées:
•• L’entrée des données.
•• Le traitement des données.
•• La sortie des résultats.
Traiter quelques exercices à ce stade.
1.2 Variable, affectation.
Définition :
Lors de l’exécution d’un algorithme, on va avoir besoin
de stocker des données, voire des résultats.
Pour cela, on utilise des variables.
On attribue un nom à chaque variable.
Remarques :
• Une variable est comme une boîte, repérée par un nom,
qui va contenir une information.
Pour utiliser le contenu de cette boîte, il suffit
de l’appeler par son nom.
• Dans l’écriture d’un algorithme, ( avec ALGOBOX )on prendra l’habitude
de préciser des le départ le nom des variables
utilisées en indiquant leur type (nombre, chaîne de caractère, liste, etc.).
Cette étape est appelée déclaration des variables.
Mais Python par exemple ne demande pas de déclaration de variable d'abord.
( En Python le simple fait de dire a =2 fait que la variable a existe
puisque à un instant donné elle a une valeur.
En algobox , par contre, on devra indique avant le début de l'algorithme :
a VARIABLE_DE_TYPE ...... NOMBRE ou CHAINE ou LISTE )
Définition :
Les instructions de base sur des variables sont les suivantes :
– La saisie : on demande à l’utilisateur de l’algorithme de donner une valeur à la variable ;
– l’affectation : le concepteur de l’algorithme donne une valeur à la variable.
Cette valeur peut-être le résultat d’un calcul ;
– l’affichage : on affiche la valeur de la variable.
Algorithme 1 Image par une fonction y = 3x2 − 2x + 1
Variables :
x, y : nombres réels
Entrée :
Saisir x
Traitement :
y reçoit 3x2 − 2x + 1 Affectation
Sortie :
Afficher y
2 Des structures importantes
2.1 L’instruction conditionnelle.
Définition :
La résolution des certains problèmes nécessite la mise
en place d’un test pour savoir si l’on doit effectuer une tâche.
Si la condition est remplie alors on effectue la tâche,
sinon on effectue (éventuellement) une autre tâche.
Dans un algorithme, on code la structure du « Si... Alors.. Sinon » sous
la forme suivante :
Si condition
Alors
Tâche 1
Tâche 2
...
Sinon
Tâche 1bis
Tâche 2bis
...
Fin Si
Remarques :
• Il est important de respecter les espaces laissés au début de
chaque ligne, car ils permettent une meilleure lisibilité
de l’algorithme.
• Le « Sinon » n’est pas obligatoire.
S’il n’est pas présent, aucune tâche ne sera effectué si la condition
n’est pas remplie.
Exemples :
Algorithme: Triangle rectangle en C
Variables :
AB, AC, AB, x, y : nombres réels
Entrée :
Afficher « Entrer la valeur de AB »
Saisir AB
Afficher « Entrer la valeur de AC »
Saisir AC
Afficher « Entrer la valeur de BC »
Saisir BC
Traitement :
x reçoit AB²
y reçoit AC²+BC²
Si x = y
Alors
Afficher « Le triangle ABC est rectangle en C »
Sinon
Afficher « Le triangle ABC n’est pas rectangle en C »
Fin Si
Algorithme: Image par une fonction en tenant
compte de l’ensemble de définition.
Soit la fonction rationnelle f : x → (x + 1) / (x − 1)
Variables :
x, y : nombres réels
Entrée :
Saisir x
Traitement :
Si x != 1 ( != mis pour ≠ )
Alors
y reçoit (x + 1) / (x − 1)
Afficher y
Sinon
Afficher « La valeur choisie n’est pas dans
l’ensemble de définition »
Fin Si
Algorithme: Jeu de Pile ou Face
Variables :
choix, tirage : nombres réels
Entrée :
Saisir choix
tirage reçoit un nombre au hasard choisit
dans l’ensemble {0 ; 1}
Traitement :
Si choix =tirage
Alors
Afficher « Gagné ! »
Sinon
Afficher « Perdu ! »
Fin Si
2.2 La boucle itérative
Définition :
Lorsque l’on doit répéter un nombre de fois connu à l’avance
la même tâche, on utilise une boucle
itérative de la forme
« Pour.. allant de... à ».
Dans un algorithme, cette structure est codée
de la façon suivante :
Pour variable allant de valeur_départ à valeur_fin faire
tâche 1
tâche 2
...
Fin pour
La variable utilisée dans la boucle est
appelée compteur.
À chaque passage dans la boucle, sa valeur est
automatiquement augmentée de 1.
Algorithme: Affiche la table de multiplication (de 0 à 10)
d’un nombre entier donné. ( Table de multiplication)
Variables :
n, m, i : nombres entiers
Entrée :
Saisir n
Traitement :
Pour i allant de 0 à 10 faire
m reçoit n × i
Afficher n ,« x », i, « = », m
Fin Pour
Algorithme : Affiche la somme de tous les entiers jusqu’à un entier donné.
Variables :
S , i, n : nombres entiers
Entrée :
Saisir n
S reçoit 0
Traitement :
Pour i allant de 1 à n faire
S reçoit S + i
Fin Pour
Sortie :
Afficher S
2.3 La boucle conditionnelle
Définition :
Lorsque l’on doit répéter une tâche un nombre de fois
non connu à l’avance, mais tant qu’une condition est remplie,
on utilise une boucle conditionnelle de la forme
« Tant que.. ».
Dans un algorithme, cette structure
est codée de la façon suivante :
Tant que condition faire
tâche 1
tâche 2
...
Fin Tant que
Algorithme : Algorithme d’Euclide du calcul du PGCD de deux nombres entiers.
Le reste de la division euclidienne d’un nombre a par un nombre b
est codé par l’instruction « a mod b ».
Variables :
a, b, r : nombres entiers
Entrée :
Afficher « Entrer le plus grand nombre »
Saisir a
Afficher « Entrer le plus petit nombre »
Saisir b
Traitement :
r reçoit b
Tant que r != 0 faire
r reçoit (a mod b)
a reçoit b
b reçoit r
Fin Tant que
Sortie :
Afficher « Le PGCD est », a
---------------------------------------------------------------------------------------------------------