Introduction lalgorithme Licence 1re anne Gnie Informatique Dr

Introduction à l’algorithme Licence 1ère année Génie Informatique Dr Daouda Traoré Université de Ségou email: daoudatr 2008@gmail. com

Algorithme : Définition Ø Ø 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’algorithmique est le permis de conduire de l’informatique

Algorithmique : premier pas Ø Calcul de la somme de deux entiers variable a, b : entier variable s : entier Debut afficher(" Donner le premier entier ") saisir(a) afficher(" Donner le deuxième entier ") saisir(b) s<- a+b afficher(" La somme de a et b est : ") afficher("s") Fin

Algorithmique : les étapes Ø Initialisation des variables Ø Permet de donner des valeurs initiales aux variables qui seront utilisées dans la résolution du problème posé Ø Traitement Ø Résolution du problème étape par étape. Ø Affichage du résultat ou retour du résultat Ø Affichage du résultat du problème à l’écran, dans un fichier, ou sauvegarde du résultat du programme dans une variable

Algorithmique : pseudo code Ø Ø Dans ce cours les algorithmes seront exprimés sous la forme de programmes écrits en pseudo-code. Un pseudo code n’est pas un « vrai code » , il permet d’employer l’écriture qui semble être la plus claire et la plus concise pour spécifier un algorithme.

Pseudo code : déclaration de variables Ø Pour déclarer une variable dans notre pseudo algorithme, il faut d’abord préciser le mot variable, suivi du nom de la variable, suivi de deux points et le type de la variable. Ø La syntaxe d’une déclaration de variable est la suivante : variable Nom_variable : type Ø Exemple : variable nom : chaine de caractère Ø L’opérateur d’affectation d’une variable : Ø Ø Exemple : a 5 Il est possible de déclarer plusieurs variables sur une même ligne Ø La syntaxe d’une déclaration de variable est la suivante : variable 1, variable 2, …: type Déclaration d’une constante constante Nom_constante: type Ø

Pseudo code : les entrées-sorties Ø Ø La fonction afficher(<liste des noms de variables, de constantes ou d’expression>) permet d’afficher à l’écran les informations fournies à son entrée. La fonction saisir(<liste des noms de variables>) permet de stocker dans les variables en entrées les informations fournies par l’utilisateur.

Pseudo code : exemple Ø Calcul de la surface d’un cercle variable r : réel variable S : réel Debut constante PI : réel PI 3. 14 afficher(" Donner le rayon du cercle") saisir(r) S r*r*PI afficher(" La surface est : ") afficher(r) Fin

Pseudo-code : Traitement conditionnel Un traitement conditionnel permet d’effectuer des choix (alternative) ou de faire un choix parmi plusieurs. Ø Instruction : « si-alors-sinon » si (expression conditionnelle égale à vraie) alors faire séquence 1 d’ instructions sinon séquence 2 d’ instructions finsi Ø Expression conditionnelle vraie Sequence 1 d’instructions fausse Sequence 2 d’instructions Suite du programme

Pseudo code : maximum de deux entieres Ø Calcul du maximum de deux entiers Entrée : deux entiers a et b Sortie : un entier max Debut afficher(" Donner deux entiers") saisir(a) saisir(b) si a > b alors max a sinon max b finsi Fin

Les différentes formes du si si avec sinon si E alors A 1 sinon B 1 finsi Ø si sans sinon si E alors A 1 Ø si vrai E faux B 1, A 1, si vrai A 1 E faux

Les différentes formes du si si emboités si E 1 alors si E 2 alors A 1; A 2, . . . ; An; sinon B 1; B 2, . . . ; Bn; finsi sinon C 1; C 2, . . . ; Cn; finsi Ø si E 1 vrai faux E 2 vrai A 1, A 2; . . An; faux B 1, B 2; . . Bn; C 1, C 2; . . Cn;

Exemple de si emboité Ø si emboités si moyenne >=12 alors afficher("admis") sinon si moyenne >=10 alors afficher(" admis avec crédits ") sinon afficher(" ajourné ") finsi

Pseudo-code : Traitement conditionnel Un traitement conditionnel permet d’effectuer des choix (alternative) ou de faire un choix parmi plusieurs. Ø Instruction : « selon » selon <identificateur> (liste de ) valeur (s) : séquence 1 d’instructions … [autres : instructions par défaut] Ø

Exemple de selon Ø selon code. Couleur "0" : afficher("vert") "1" : afficher("jaune") "2" : afficher("rouge") autres : afficher("noir")

Traitement répétitif (boucle) Ø Ø Les boucles permettant d’exécuter plusieurs fois la même série d’instructions jusqu’à ce qu’une condition ne soit plus réalisée. Les variantes se différencient par la manière de caractériser le nombre de boucles effectivement réalisées. Ø Ø Ø pour : on exprime le décompte exact de boucles Tant que : on exprime la condition de continuation Répéter … Tant que : on exprime la condition d’arrêt

La boucle pour Ø La boucle pour permet d’exécuter plusieurs fois la même série d’instructions. Dans sa syntaxe, il suffit de préciser : Ø Le nom de la variable qui sert de compteur (et éventuellement sa valeur de départ), Ø La condition sur la variable pour laquelle la boucle s’arrête (basiquement une condition qui teste si la valeur dépasse une limite) Ø Une instruction qui incrémente (ou décrémente) le compteur. Ø Elle se présente sous la forme suivante : pour <Cpt> Cpt. Init à Cpt. Fin [par <pas>] faire séquence d’ instructions; finpour

La boucle pour Ø Exemple : exécuter l’instruction A, puis exécuter N fois l’instruction B; puis après l’instruction C variable i : entier; A; pour i=1 à N faire B; finpour C; A Répéter N fois B C

La boucle pour : schéma détaillé de l’exemple variable i : entier A; pour i=1 à 10 par 1 faire B; finpour C; A i=1 i!=10 Répéter 10 fois B i=i+1 C

La boucle pour : exemple {Saisie de n nombres et calcul de la moyenne } variable n : entier variable i : entier variable note. Courant, somme : réel Début somme 0 {initialisation du calcul} -> commentaire afficher("Donnez le nombre de notes que vous voulez saisir: "); saisir(n); pour i 1 à n faire afficher("Note", i ) afficher(" : ") saisir(note. Courant) somme+note. Courant; finpour afficher("Moyenne : ", (somme)/n); Fin

La boucle tant que Ø La boucle tant que permet d’exécuter plusieurs fois la même série d’instructions. Elle se présente sous la forme suivante : tant que (expression est vraie ) faire séquence d’ instructions; fintanque Ø Exemple : exécuter l’instruction A, puis tant que E est vraie faire B et si E est fausse faire C; A A; Tant que E faire B; fintanque C; vrai E B faux C

La boucle tant que Tant que (Expression) faire sequence d’instructions; fintanque Ø Expression constitue la condition de poursuite de la boucle. La présence des parenthèses permet de délimiter cette condition. Ø Expression est évaluée avant le premier tour de boucle. Il est donc nécessaire que sa valeur soit définie à ce moment. Ø On doit assurer la convergence (arrêt de la boucle) : la condition doit à un moment donné s’évaluer à faux. Ø Ø Condition nécessaire : la condition doit faire intervenir une variable qui sera modifiée dans le corps de boucle Dans le cas d’une conjonction de conditions (tant que ( E 1 Et E 2)…) Ø L’arrêt est provoquée quand l’une des deux conditions s’évalue à faux Ø La condition d’arrêt est alors : !E 1 Ou !E 2

La boucle pour : exemple { Moyenne d’une série de notes saisies au clavier } -> commentaire variable note, somme : réel somme 0; variable nb. Note : entier Debut nb. Note <- 0; afficher(" Donnez une note >=0 ou -1 pour terminer : "); saisir(note); tant que note ≠-1) faire somme + note; nb. Note+1; afficher (" Donnez une note >=0 ou -1 pour terminer : "); saisir(note) fintanque afficher(" Le nombre de notes saisies est : ", nb. Note); afficher(" La moyenne est des notes saisies est : ", (somme)/nb. Note)); Fin

Equivalence d’un tant que et d’un pour Ø Le pour est un cas particulier du tant que pour i=binf à bsup faire P i binf finpour tant que(i <= bsup) faire P i i+1 fintanque Ø Plus généralement : pour Cpt<-Cpt. Init à Cpt. Max par k faire P Cpt. Init; finpour tant que Cpt <= Cpt. Maxfaire P Cpt+k fintanque

La boucle répéter…tant que Ø L’a boucle répéter…tant que est un autre moyen d’exécuter plusieurs fois la même série d’instructions. Elle est toujours parcourue au moins une fois. La condition d’arrêt n’est examinée qu’à la fin de chaque répétition. Elle se présente sous la forme suivante : répéter séquence d’ instructions; tant que (expression est vraie );

La boucle répéter…tant que : exemple variable n : entier Début répéter afficher("Donnez un entier strictement supérieur a zéro : ") saisir(n) afficher("Vous avez fourni : " , n) tant que (n <=0) ; afficher("La valeur positive strictement supérieure à zéro est : "); afficher(n); Fin

La boucle tant que : exemple {Saisie avec filtre : saisie d’une note entre 0 et 20} variable note : réel Début afficher(" Donnez une note : ") saisir(note) tant note < 0 ou note > 20 faire afficher("la note saisie est incorrecte, veuillez ressaisir : ") saisir("note) fintanque Fin

Algorithme du plus grand commun diviseur {PGCD (plus grand commun diviseur)} Algorithme PGCD Entrée : deux entiers a et b variable x, y : entier Début x<-a, y<-b; si (a < 0) alors x=-a; si (b < 0) alors y=-b; tant que (x≠y) faire si(x < y) alors y y-x; sinon x x-y; finsi fintanque afficher("Le pgcd de ", a, b); afficher("est : ", x) Fin

La boucle pour : exemple { Incrément de n en n : affichage des multiples de n inférieurs à 100 } variable n : entier variable i : entier variable max : entier max 99 afficher("Donnez un nombre inferieur à 100 : ") saisir(n); pour i n à max par n faire afficher( i); afficher( " "); finpour

Algorithme du calcul de puissance { calcul de x a la puissance n } variable x , n, p, resultat : entier resultat 1 afficher("Donnez la valeur de x : "); saisir(x); afficher("Donnez la valeur de n : "); saisir(n); pour p=1 à n faire resultat*x; finpour afficher("Resultat : ", resultat);