Slide Algo Bases Algo1 Cours2

La structure séquentielle
Les structures alternatives

Introduction 2I
Les structures répétitives
Application au Langage C
Dans un langage impératif, on peut définir l’état d’un
programme en cours d’exécution par deux choses :
L’ensemble des variables du programme ;
L’instruction qui doit être exécutée
UE INFO111 : Algorithme et Programmation I :
L’exécution d’un programme est alors une séquence
Structures de contrôle d’affectations qui font passer d’un état initial à un état final
considéré comme résultat.
Pr. David C. FAYE/UFR SAT-UGB Les structures de contrôle définissent comment les affectations
s’enchaînent séquentiellement.
UFR SAT/UGB
david-celestin.faye@ugb.edu.sn
26 avril 2022
Pr. David C. FAYE/UFR SAT-UGB UE INFO111 -Algo I : Structures de contrôle
Introduction 3 II La structure séquentielle

Les structures alternatives La notion de séquence
Les structures répétitives Les instructions composées
Plan 4
1 La structure séquentielle
En programmation structurée, le transfert de contrôle s’exprime La notion de séquence
par : Les instructions composées
1 enchaînement séquentiel (une instruction puis la suivante) ; 2 Les structures alternatives
Le choix simple
2 traitements conditionnels ;
La sélection multiple : le CAS...
3 traitements répétitifs(itératifs) ; Le concept de condition
4 appel d’un sous-programme (un autre programme qui réalise 3 Les structures répétitives
un traitement particulier). Définition
Boucle à bornes définies (POUR...FAIRE)
Boucles à bornes non définies
Exemple comparatif
Que choisir entre pour... tant que...répéter... ?
4 Application au Langage C
notion de séquence 5I notion de séquence 6I
Une structure séquentielle ou séquence est une suite
d’instructions rangées dans l’ordre où elles sont écrites.
Dans une structure séquentielle l’ordre des instructions joue
une séquence est une structure algorithmique très élémentaire.
un rôle fondamental.
Ainsi par exemple, si S1 et S2 représentent deux instructions,
leur composition est notée : Ainsi par exemple, dans la séquence d’instructions.Ainsi par
S1; S2; exemple, dans la séquence d’instructions
respectivement : X1 ← 2;
X2 ← X1 + 3;
S1;
Ecrire(X2);
S2;
Il n’est pas possible de revenir en arrière pour recommencer
Ce qui signifie que : l’opération.
les instructions S1 et S2 sont exécutées une par une, L’exécution d’une instruction déterminée n’est possible que
chacune d’elles est exécutée exactement une fois, lorsque toutes les instructions qui la précèdent ont été
l’ordre dans lequel elles sont exécutées est le même que celui exécutées.
dans lequel elles ont été écrites,
terminer l’instruction S2 implique de finir la séquence.
notion de séquence 7 Calcul d’un produit de 2 nombres 8I

Il est évident que la notion de séquence peut être généralisée
pour un nombre quelconque N d’instructions :
S1; S2; S3; ... ; SN;
La figure représente une traduction graphique de la structure
séquentielle. Une telle représentation est appelée Algorithme Produit ;
Algorigramme , Ordinogramme ou encore Organigramme. Variable
a, b : reel ; /*opérandes*/
p : reel ; /* résultat du produit*/
S1 début
Ecrire(’Saisir le nombre a ’) ;
S2
Lire(a) ;
Ecrire(’Saisir le nombre b ’) ;
Lire(b) ;
p ← a ∗ b;
SN
Ecrire (p) ;
fin
Les instructions composées 9I Les instructions composées 10 II
début
S1 ;
Une instruction composée est une série de N (N ≥ 2) S2 ;
instructions qui doivent être exécutées en séquence. début
Une instruction composée est délimitée par les accolades S31 ;
debut et fin qui indiquent respectivement le début et la fin S32 ;
de l’instruction composée. S33 ;
Voici quelques exemples d’instructions composées : fin
S4 ;
début
Lire( X, Y ) ; début
S51 ;
Ecrire( X, Y ) ;
début
Z ← X; S521 ;
X ←Y; S522 ;
Y ← Z; fin
Ecrire( X, Y ) S53 ;
fin fin
S6 ;
fin
Le choix simple Les structures alternatives 12 I
Le concept de condition
Plan 11
La notion de séquence
Une instruction alternative permet de faire le choix entre une,
Les instructions composées
deux ou plusieurs actions suivant qu’une certaine condition est
2 Les structures alternatives
remplie ou non.
Le choix simple
La sélection multiple : le CAS... Une telle structure algorithmique est encore appelée sélection.
On distingue deux types d’instructions alternatives :
le choix simple (instruction SI ) et
3 Les structures répétitives
la sélection multiple( instruction SUIVANT...FAIRE).
Définition
Exemple comparatif
Le choix simple 13 I Le choix simple 14 I
* SYNTAXE : En pseudo-code
Point important : Instruction alternative facultative. En effet
si < condition > alors les deux formes suivantes sont équivalentes.
<bloc_instructions1>
sinon si < condition > alors
<bloc_instructions2> < instruction > ;
si < condition > alors

Cette instruction exprime les instructions qui sont exécutées <bloc_instructions1>
suivant que la condition (l’expression booléenne) sinon
; /*Rien*/
<condition> est remplie.
SEMANTIQUE :
• Valeur de la condition : booléenne
« Si la condition <condition> est vraie, alors exécuter
l’instruction qui suit le mot réservé ALORS, sinon exécuter • Blocs d’instructions :
l’instruction qui suit le mot réservé SINON. » Instructions simples
Instructions structurées
L’exécution des instructions <bloc_instructions1> et Instructions composées.
<bloc_instructions2> est mutuellement exclusive ce qui
signifie que seule une des deux instructions sera exécutée. Organigrammes :
Le choix simple 15 II Le choix simple 16 III

sans SINON
avec SINON
Figure – Organigramme de la sélection sans alternative
Figure – Organigramme de la sélection avec alternative

Le choix simple : Exemple 17 I Le choix simple : Exemple 18 II
Calcul d’une racine carrée (SI... ALORS... SINON)

Calcul d’une racine carrée (avec SI... ALORS) Algorithm SI_ALORS_SINON ;
Algorithm SI_ALORS ; Variable x : reel ; /*opérande*/
Variable x : reel ; /*opérande*/ r : reel ; /*résultat de la racine carrée*/
r : reel ; /*résultat de la racine carrée*/ début
Ecrire (’Saisir le nombre x’) ;
début
Ecrire (’Saisir le nombre x’) ; Lire (x) ;
Lire (x) ; si x < 0 alors
Ecrire (’x est négatif’)
si x > 0 alors
sinon
début
r ← racine(x); début
r ← racine(x);
Ecrire (r) ;
fin Ecrire (r) ;
fin
fin
fin
Le choix simple : Ambiguïtés syntaxiques 19 I Le choix simple : Ambiguïtés syntaxiques 20 II
Il faut bien percevoir que la formulation de l’instruction SI

n’est pas toujours sans ambiguïté. Cette façon de procéder est appelée indentation ou
Ainsi par exemple, l’ambiguïté syntaxique de la construction : paragraphage. L’identation est très souvent effectuée de
Si < expr1 > Alors Si < expr2 > Alors < st1 > Sinon < st2 >; manière automatique par un outil qui accompagne le
peut être évitée par le réécriture suivante : compilateur (indenteur ou paragrapheur).
si < expr1 > alors En général, une telle ambiguïté syntaxique est écartée
si < expr2 > alors définitivement soit en utilisant les parenthèses symboliques
< st1 > DEBUT et FIN, soit en respectant la règle suivante :
sinon Règle : « "La partie SINON se rapporte toujours au mot
< st2 >; réservé SI précédent le plus proche pour lequel il n’existe pas
On dit ici que les instructions SI sont imbriquées. de partie SINON. »
Afin d’éviter des ambiguïtés de ce genre lors de la lecture d’un Dans une construction de structures alternatives imbriquées il
programme, il est vivement recommandé de bien mettre un SI doit y avoir autant de mots SINON que de mots SI.
et un SINON de la même structure alternative au même niveau
vertical afin de ne pas les mélanger entre eux.
Le choix simple : Ambiguïtés syntaxiques 21 III Le choix simple : Ambiguïtés syntaxiques 22 IV
Ainsi par exemple, dans le texte :
SI N>0 ALors Si A>B Alors Max ← A Sinon M ax ← B;
la partie ELSE se rapporte au mot réservé IF situé à l’intérieur
Si ce n’est pas ce qu’on a voulu exprimer, il faut se servir des
de la séquence ce qui peut être élucidé en écrivant :
parenthèses symboliques Debut et Fin pour forcer des
appartenances respectives comme par exemple :
si N > 0 alors
si A > B alors si N > 0 alors
M ax ← A début
sinon si A > B alors
M ax ← B; M ax ← A
fin
sinon
M ax ← B;
Le lecteur se rendra bien compte de la signification différente
des deux constructions précédentes.
Le choix simple : Exemple 23 I Le choix simple : Exemple 24 II

Ecrire un programme qui résoud une équation du premier degré
Ax+b=0 qui lit les valeurs de A et B entrées par l’utilisateur. Ecrire un programme qui calcule le maximum de deux nombres
entrés au clavier.
Algorithme Premier_Degre ;
Var A, B : reel ; Algorithm MAXIMUM_DEUX ;
début var X, Y : reel ;
Ecrire(’entrez les coefficients A et B : ’) ; M AX : reel ;
Lire(A, B) ; début
si A = 0 alors Ecrire(’Tapez les deux nombres :’)
si B = 0 alors Lire (X, Y ) ;
Ecrire(’Indéterminé !’) si X > Y alors
sinon M AX ← X
Ecrire(’Impossible !’) sinon
sinon M AX ← Y ;
Ecrire(’La solution est : ’,−B/A) ; Ecrire(’Le plus grand nombre est ’,M AX) ;
fin fin
Le choix simple : Exemple 25 III Exemple : Algorithme max et min de 3 entiers 26
Signe du produit de 2 nombres, sans calculer ce produit
Variables X, Y, Z, M in, M ax : Entier

Algorithme Signe ; début
Ecrire(" saisir X : ") ; Lire(X) ;
Variables a, b : Réel Ecrire(" saisir Y : ") ; Lire(Y ) ;
début Ecrire(" saisir Z : ") ; Lire(Z) ;
Ecrire(" saisir 2 nombres : ") ; Lire(a, b) ; M in ← X M ax ← X
si (a = 0) ou (b = 0) alors si Y < M in alors
Ecrire(" le produit des deux nombre est : nul ") M in ← Y
sinon sinon
si (a > 0 et b > 0) ou (a < 0 et b < 0) alors M ax ← Y
si Z < M in alors
Ecrire("le produit des deux nombre est : positif") M in ← Z
sinon sinon
Ecrire("le produit des deux nombre est : si Z > M ax alors
négatif") M ax ← Z
fin Ecrire(’ la valeur maximale saisie est : ’,M ax)
Ecrire(’ la valeur minimum saisie est : ’,M in)
fin
Le choix simple : Exemple 27 La sélection multiple : le CAS... 28 I

Algorithme SeconDegre /*Resolution de aX2 + bX + c = 0*/ Cette méthode est utilisée pour tester une solution parmi N.
var a, b, c, x1, x2, delta, aux : reel ;
début Par exemple, au cas où un menu est proposé à l’utilisateur (1)
si a = 0 alors pour lire, 2) pour écrire, 3) pour calculer, 4) pour sortir etc...),
si b = 0 alors
si c = 0 alors
il est important de tester si l’utilisateur a tapé 1, 2, 3 ou 4.
Ecrire(’Tout x reel ou complexe est solution’) Au lieu d’utiliser plusieurs ISI... ALORS... SINON...
sinon
Ecrire(’Aucune solution’) imbriqués
sinon
x1 ← −c/b; Ecrire(’Solution unique : ’,x1)
si reponse=1 alors
sinon Instructions de lecture...
delta ← b ∗ b − 4 ∗ a ∗ c; sinon
si delta > 0 alors
aux ← sqrt(delta); x1 ← (−b + aux)/(2 ∗ a); si IF reponse=2 alors
x2 ← (−b − aux)/(2 ∗ a); Instructions d’écriture...
Ecrire(’2 solutions reelles : ’,x1,’ et ’,x2) sinon
sinon
x1 ← −b/(2 ∗ a); si reponse=3 alors
si delta = 0 alors instructions de calcul...
Ecrire(’Solution unique : ’,x1)
sinon sinon
aux ← sqrt(−delta)/(2 ∗ a); ..
Ecrire(’2 solutions complexes : ’,x1,’+’,aux,’i et .
’,x1,’-’,aux,’i’) ; fin
fin
La sélection multiple : le CAS... 29 II La sélection multiple : le CAS... 30 I
il est préférable de choisir une sélection multiple

vrai faux
Condition suivant reponse faire
Sequence 1
cas où 1 faire
Instructions de lecture...
cas où 2 faire
vrai faux
Condition Instructions d’écriture...
Sequence 2
cas où 3 faire
instructions de calcul...
●
●
fin
●
L’instruction de sélection multiple ou instruction
vrai faux
SUIVANT ..FAIRE encore appelée analyse par cas est une
Condition
généralisation supplémentaire de l’instruction SI. Elle est
Sequence N Sequence fréquemment utilisée en programmation s’il faut faire le choix
entre plus de deux alternatives.
La sélection multiple : le CAS... 31 II La sélection multiple : le CAS... 32 III
La variable variable est appelée sélecteur et doit être d’un type
suivant variable faire scalaire.
cas où constante1 faire Les constantes CAS doivent être toutes différentes et du même
suite d’instructions1 type que le sélecteur. Elles sont interprétées comme des
cas où constante2 faire étiquettes.
suite d’instructions2 Seules les égalités sont possibles au niveau du test (Pas de
cas où constante3 faire comparaisons de type <,>,<=,>= ou <>) On peut néanmoins
suite d’instructions3
utiliser des intervalles .
cas ...
où ... faire
On peut donner une liste de constantes, ou des intervalles de
autres cas faire constantes. Attention, chaque valeur possible ne doit être
suite d’instructions par defaut; représentée qu’une fois au plus (sinon il y a erreur à la
fin compilation). Par exemple, on ne peut pas faire des intervalles
se chevauchant, comme 3..6 et 5..10, les cas 5 et 6 étant
Comme dans l’instruction SI, l’exécution de chaque branche représentés 2 fois.
est mutuellement exclusive.
La sélection multiple : le CAS... 33 Le concept de condition 34 I
Une condition est une expression booléennedont les seules
Algorithme calculette ; valeurs sont les valeurs de vérité Vrai et FAux.
variable A, B, RESU LT AT : reel ; Une valeur booléenne est obtenue en appliquant les opérateurs
T OU CHE : caractere ;
booléens ET, OU et NON ainsi que les opérateurs relationnels
début
Ecrire(’entrez une opération ’) ; =, <>, <, <=, >, >= à des opérandes booléennes.
Ecrire(’(taper un nombre, un opérateur puis un nombre) : ’) ; On envisage les conditions de relation simple et les conditions
lire(A, T OU CHE, B) ; de relation composée.
suivant T OU CHE faire
cas où ’+’ faire Dans une condition de relation simple deux expressions
RESU LT AT ← A + B; arithmétiques sont comparées au moyen des opérateurs
cas où ’-’ faire relationnels.
RESU LT AT ← A − B;
Une condition de relation composée se construit au moyen de
cas où ’*’ faire
RESU LT AT ← A ∗ B; conditions de relation simple reliées les unes aux autres par les
cas où ’/’ faire opérateurs booléens.
RESU LT AT ← A/B; Exemple
fin
Ecrire(A, T OU CHE, B," = ", RESU LT AT ) ; NON( A<=B ) ( A>3 ) OU ( B<5 )
fin ( X>3 MOD 4 ) ET ( Racine( B )<=6 )
Le concept de condition 35 II Le concept de condition 36 III
L’opérateur ET permet de simplifier l’écriture d’une série

d’instructions SI imbriquées de la forme suivante :
si < expression1 > alors
si < expression1 > alors < suited0 instructions1 >;
si < expression2 > alors sinon
< suited0 instructions1 > ; si < expression2 > alors
sinon < suited0 instructions1 >;
< suited0 instructions2 > ; sinon
< suited0 instructions2 > ; sous la forme :
sous la forme :
si < expression1 > OR < expression2 > alors
si < expression1 > AND < expression2 > alors < suited0 instructions1 >;
< suited0 instructions1 >;
sinon
< suited0 instructions2 >;
L’opérateur OR permet de simplifier l’écriture d’une série
d’instructions IF imbriquées de la forme suivante :
Définition
Boucle à bornes définies (POUR...FAIRE) Définition 38 I
Exemple comparatif
Que choisir entre pour... tant que...répéter... ? Une structure répétitive permet d’exécuter une séquence
Plan 37 d’instructions un certain nombre de fois jusqu’à ce qu’une
condition déterminée soit remplie ou non.
La répétition se fait par l’intermédiaire de boucles et
d’itérations.
2 Les structures alternatives Une boucle consiste à parcourir une partie d’un programme un
Le choix simple certain nombre de fois. Une Itération est la répétition d’un
La sélection multiple : le CAS... même traitement plusieurs fois.
Le concept de condition La même séquence d’instructions est réitérée plusieurs fois au
3 Les structures répétitives cours d’une même exécution.
Définition La notion d’itération est une des notions fondamentales de
Boucle à bornes définies (POUR...FAIRE) l’algorithmique.
Exemple comparatif
Définition 39 II Boucle à bornes définies (POUR...FAIRE) 40 I
Dans le cas d’une boucle à bornes définies, nous connaissons

le nombre d’itérations à effectuer, grâce aux valeurs des bornes
On distingue les boucles à bornes définies (POUR...FAIRE) et minimum et maximum fournies dans la définition de la boucle.
les boucles à bornes non définies (TANTQUE...FAIRE et Un indice de boucle varie alors de la valeur minimum (initiale)
REPETE...JUSQU’A. jusqu’à la valeur maximum (finale)
Toute structure répétitive est composée de trois éléments : * SYNTAXE : En pseudo-code
d’une initialisation d’un compteur ;
d’une condition ; pour variable ← valeur_init a valeur_f in faire
d’un bloc d’instructions. <séquence d’instruction>
fin
Toute modification d’un quelconque de ces trois éléments
nécessite un contrôle de cohérence des deux autres.
Remarques
la variable doit être de type scalaire (entier, énuméré, intervalle
ou caractère) elle ne peut pas être réelle
si valeur_init > valeur_fin le POUR est ignoré
Boucle à bornes définies (POUR...FAIRE) 41 II Boucle à bornes définies (POUR...FAIRE) 42 III
Ecrire un algorithme qui affiche tous les diviseurs d’un nombre
entier N > 0.
Algorithm boucle_Pour ;
var i :entier ;
début
pour i ← 1 à 5 faire Algorithm Diviseurs ;
Ecrireln("le carré de ", i, " est :", i ∗ i) var N, d :entier ;
fin début
Ecrireln Ecrire(’Donnez N : ’) ; Lire(N ) ;
Ecrireln("FIN. A la prochaine...") ; pour d ← 1 à N faire
fin si (N mod d = 0) alors
Ecrire(d) ;
fin
fin
fin
NB : Cet algorithme peut être optimisé en réduisant

l’ensemble de recherche des diviseurs
Boucle à bornes définies (POUR...FAIRE) 43 IV Boucle à bornes définies (POUR...FAIRE) 44 V

Il est possible d’imbriquer plusieurs boucles POUR :
Table de multiplication
début
pour X1 ← C1 à C2 faire
début
...
Algorithme table_multiplication ;
pour X2 ← D1 à D2 faire
VAR i, j : entier ;
début
... début
fin pour i ← 1 à 10 faire
fin début
fin pour j ← 1 à 10 faire
fin Ecrire (i ∗ j," ") ;
fin fin
Ecrireln ;
fin
fin
fin
Boucle (POUR...FAIRE) exemple 45 I Boucle (POUR...FAIRE) exemple 46
n
Calcul de la somme des n premiers entiers : X
Ecrire un algorithme qui calcule la somme s = uk des n
s←0
k=0
pour i ← 1 à n faire premiers termes d’une suite arithmétique uk = a + bk.
s←s+i
n n
fin X X
s= (a + bk) = a(n + 1) + b k
Après l’exécution de cette instruction, s vaut :
k=0 k=1
n
n(n + 1) X n(n + 1)
1 + 2 + ... + n = avec S = k = 1 + 2 + ... + n =
2 k=1
2
Calcul de la somme des n premiers carrés : S = 1 + 2 + ... + n
s←0 S = n + n−1 + ... + 1
pour i ← 1 à n faire 2S = n+1 n+1 n+1 + ... + n+1 = n(n + 1)
s←s+i∗i Version constante :
fin s ← a ∗ (n + 1) + b ∗ n ∗ (n + 1)/2
Après l’exécution de cette instruction, s vaut : Version itérative :
s←0
n(n + 1)(2n + 1) pour i ← 1 à n faire
1 + 4 + 9 . . . + n2 =
6 s←s+a+b∗i
fin
Boucle (POUR...FAIRE) exemple 47 Boucles à bornes non définies 48 I

La suite de Fibonacci est définie par récurrence comme suit :
u0 = 1, u1 = 1, et un = un−1 + un−2 pour n ≥ 2
écrire un algorithme qui calcule le nième terme de la suite de
Fibonacci.
* Corrigé Lorsque les bornes ne sont pas connues, il existe deux autres types
Algorithme fibonacci ; de boucles :
n, u, v, i :entier ; Boucle TANT QUE ... FAIRE ...
début
Ecrire(’Donnez N : ’) ; Lire(N ) ; Boucle REPETER ... JUSQU’A ...
u←1
v ← 1;
pour i ← 2 à n faire
v ← u + v;
u ← v − u;
fin
fin
Boucles à bornes non définies TANT QUE 49 I Boucles à bornes non définies TANT QUE 50 II
Syntaxe de la boucle TANT QUE : Organigramme
tant que < condition > faire

<séquence d’instructions>
Faux
fin Condition
Vrai
Remarques
Sequence
arrêt si expression est fausse
=⇒pas de boucle si faux au départ
incrémentation gérée par le programmeur lui-même
=⇒pas d’augmentation automatique d’une variable
(contrairement à la boucle POUR)
Les variables de l’expression expression doivent être
initialisées avant le while, pour que au premier passage
expression puisse être évaluée.
Boucles à bornes non définies TANT QUE 51 III Boucles à bornes non définies REPETER 52 I
répéter
Algorithme boucle_tantque ; <séquence d’instructions>
var i :entier ; jusqu’à < condition >;
début
i ← 1;
tant que i <= 5 faire Remarques
début La boucle s’effectue tant que l’expression est fausse, arrêt
Ecrireln("le carré de ", i, " est :", i ∗ i) ; quand l’expression est vraie. C’est le contraire de la boucle
i ← i + 1; /* incrémentation gérée par le TANT QUE.
programmeur */
fin Contrairement au TANT QUE, il y a au moins un passage (1
fin boucle), même si l’expression est vraie.
Ecrireln ; De même que pour le TANT QUE, c’est le programmeur qui
Ecrireln(’FIN. A la prochaine...’) ; gère l’incrémentation.
fin
Boucles à bornes non définies REPETER 53 II Boucles à bornes non définies REPETER 54 III
Organigramme
Algorithme boucle_repeter ;
var i :entier ;
Sequence début
i ← 1;
répéter
Faux Ecrireln("le carré de ", i, " est :", i ∗ i) ;
Condition
i ← i + 1; /* incrémentation gérée par le programmeur
Vrai */
jusqu’à i > 5;
Ecrireln ;
Ecrireln(’FIN. A la prochaine...’) ;
fin
Boucles à bornes non définies REPETER 55 Boucles à bornes non définies 56 I
Faire attention aux conditions initiales, aux conditions d’arrêt

Algorithme Exemple et à l’incrémentation sinon la boucle risque d’être infinie
Variables a, b : reel ; /*opérandes */ Les deux boucles peuvent être choisies indifféremment.
p : reel ; /*résultat du produit */ Cependant, l’une est le contraire de l’autre, au niveau de la
c : caractère ; /*réponse de l’utilisateur */ condition d’arrêt :
début
répéter tant que condition1 faire
Ecrire (’Saisir le nombre a’) ; Lire (a) ; <Bloc d’instructions>
Ecrire (’Saisir le nombre b’) ; Lire (b) ; fin
⇐⇒
p ← a ∗ b;
répéter
Ecrire (p) ;
<Bloc d’instructions>
Ecrire ("encore un calcul ? Non touche N ; Oui autre
jusqu’à non (condition1);
touche") ;
Lire (c) ; Tant que condition1 est vraie, faire bloc d’instructions...
jusqu’à c =0 N 0 ; Répéter bloc d’instructions, jusqu’à ce que condition1 ne
fin soit plus vraie
Boucles à bornes non définies 57 II Boucles à bornes non définies 58 III
Dans ce cas, la condition d’arrêt de la boucle TANTQUE est
l’opposée de la condition d’arrêt de la boucle REPETER.
tant que (i <> 10) faire En effet, pour ce dernier type de boucle, si la condition est
i ← i + 1 /*on fait varier i jusqu’à 10*/ fausse dès le départ, le bloc d’instructions ne sera pas du tout
fin exécuté.
est équivalent à : En revanche, avec une boucle REPETER ... JUSQU’A, si la
répéter condition est fausse dès le départ, le bloc d’instructions sera
i←i+1 quand même exécuté une fois.
jusqu’à (i = 10)); Remarque :
Il est toujours équivalent d’utiliser une boucle TANTQUE ou une Les boucles REPETER et TANTQUE peuvent être utilisées même
boucle REPETER. si les bornes sont définies.
Cependant, il existe une petite différence entre les deux Dans ce cas, il est bien entendu préférable d’utiliser une boucle
boucles. POUR (vue précédemment)
Dans le cas d’une boucle REPETER... JUSQU’A, le bloc

d’instructions est effectué au moins une fois, ce qui n’est pas
forcément vrai pour une boucle TANTQUE.
Boucles à bornes non définies 59 I Boucles à bornes non définies 60 I
Forme 1 avec POUR
Nous allons à présent traiter le même exemple, avec trois

boucles différentes. Algorithme Avec_Pour ;
Il s’agit de reconstruire l’opération de multiplication, en var a, b, i, P :entier ;
effectuant des sommes successives. début
Ecrire(’Donner a et b’) ;
Soit à effectuer le produit des entiers naturels a et b (distincts
Lire(a, b) ;
de 0).
P ← 0;
Données : a multiplicande, b multiplicateur
pour i ← 1 à b faire
Résultat : P produit P ← P + a;
Méthode : ajouter b fois le multiplicande fin
Ecrire(’Le produit est’,P ) ;
fin
Boucles à bornes non définies 61 Boucles à bornes non définies 62 I
Forme 2 avec TANT QUE
Forme 3 avec REPETER
Algorithme Avec_TANTQUE ;
var a, b, i, P :entier ; Algorithme Avec_REPETER ;
début var a, b, i, P :entier ;
Ecrire(’Donner a et b’) ; début
Lire(a, b) ; Ecrire(’Donner a et b’) ;
P ← 0; Lire(a, b) ;
i ← 1; P ← 0;
tant que (i <= b) faire i ← 1;
début répéter
P ← P + a; P ← P + a;
i ← i + 1; i ← i + 1;
fin jusqu’à i > b;
fin Ecrire(’Le produit est’,P ) ;
Ecrire(’Le produit est’,P ) ; fin
fin
Boucles à bornes non définies 63 II Boucles à bornes non définies 64
Algorithme Avec_REPETER_Controle_REPETER ;
var a, b, i, P :entier ;
début
répéter
Modifions les algorithmes en y rajoutant des contrôles de saisie sur
les valeurs de a et de b, puisqu’elles doivent être strictement
Lire(a, b) ;
positives.
jusqu’à (a > 0) ET (b > 0);;
P ← 0;
i ← 1;
répéter
P ← P + a;
i ← i + 1;
jusqu’à i > b;
fin
Boucles à bornes non définies 65 Boucles à bornes non définies 66 I
Algorithme Avec_REPETER_Controle_TANTQUE ;
var a, b, i, P :entier ;
début • Implicitement, l’instruction pour :
initialise un compteur
Lire(a, b) ;
incrémente le compteur à chaque pas
tant que (a <= 0) OU (b <= 0) faire
vérifie que le compteur ne dépasse pas la borne supérieure
Lire(a, b) ; • Explicitement, l’instruction tant que doit
fin initialiser un compteur
P ← 0; i ← 1; incrémenter le compteur à chaque pas
répéter vérifier que le compteur ne dépasse pas la borne supérieure
P ← P + a;
i ← i + 1;
jusqu’à i > b;
fin
Que choisir entre pour... tant que...répéter... ? 67 Que choisir entre pour... tant que...répéter... ? 68 I
OUI
OUI Nombre
Nombre NON
NON
d'itérations
d'itérations Saisir des valeurs, les traiter, et s’arrêter à la saisie de la valeur
connu
connu ?? d’arrêt -1 ou après avoir saisi 10 données.
OUI
OUI Traitement
Traitement NON
NON
exécuté
exécuté au
au moins
moins
une fois ?
une fois ?
boucle Pour boucle répéter boucle tant que

Que choisir entre pour... tant que...répéter... ? 69 II Quelques difficultés avec les boucles 70 I
• Il faut être sûr d’en sortir

Algorithme QueChoisir ; V al ← 2
Constantes STOP=-1 ; tant que V al <> 100 faire
MAX =10 ; V al ← V al ∗ 2
Variables nbV al, val, som : entiers fin
début Cette boucle ne s’arrête jamais ! On dit qu’elle est infinie.
nbV al ← 0; /*compte les saisies traitees */ Si la condition (d’arrêt ou de continuité) ne change jamais de
Som ← 0 valeur, la boucle ne s’arretera pas et l’algorithme restera
Lire(val) ; /*saisie de la 1ere donnee */ bloqué sur le « tant que » ou le « repeter... jusqu’a ».
tant que (val <> ST OP ) ET (nbV al < M AX) faire Ceci est à éviter absolument.
nbV al ← nbV al + 1
som ← som + val /*traitement de la valeur saisie*/ • Ne jamais entrer dans une boucle
Lire(val) /*relance*/ Si la condition est, au départ, à FAUX, la boucle « tant que »
fin ne sera jamais executée. Cela peut dépendre des données et ce
Ecrire(val, nbVal)/*valeurs en sortie de boucle*/ n’est pas une forcément une catastrophe, sauf si c’est
fin involontaire.
Quelques difficultés avec les boucles 71 II Méthodologie pour l’écriture d’une boucle 72 I
1 Faire soi-même le calcul sur un ou plusieurs exemples

judicieusement choisis : cas généraux, cas particuliers
2 Repérer une action répétitive, donc une boucle
• Il faut savoir traduire un énoncé (en français) en une boucle 3 Choix entre boucle avec compteur ou sans question ? peut-on
(en langage algorithmique) prévoir/déterminer le nombre d’itérations ?
saisir des valeurs, les traiter, et s’arrêter à la saisie de la valeur • si oui, boucle avec compteur
d’arrêt -1 ou après avoir saisi 10 données. • si non, boucle sans compteur
• Il faut bien comprendre où l’on en est quand on sort d’une faut-il commencer l’action avant de tester ou l’inverse ?
boucle. si tester d’abord, alors boucle tant-que-faire
On est sorti de la boucle parce qu’on a saisit -1 ou bien parce si action puis tester, alors utiliser une technique de drapeau
qu’on a saisit plus de 10 valeurs booléen, sinon un autre type de boucle
4 Ecrire l’action répétitive et l’instruction de boucle choisie
question ? faut-il préparer les données à l’itération suivante ?
si oui, compléter le corps de boucle
5 Initialiser les variables utilisées (si nécessaires)
6 Ecrire les conditions d’arrêt,
Méthodologie pour l’écriture d’une boucle 73 II Logique et boucles 74 I
Il faut interpréter(et bien comprendre !) l’arrêt des itérations à la

sortie d’une boucle.
• Soit la boucle
7 Ecrire l’incrémentation de la variable de contrôle s’il y en a. tant que <cond> faire
8 Exécuter pour les cas extrêmes et au moins un cas "normal" • À la sortie : non(<cond>) est vrai
9 Voire essayer de prouver que cela fonctionne dans tous les cas. donc si cond = p et q
à la sortie : non (p et q)
c’est-à-dire : non p ou non q
Exemple :
saisir des valeurs, les traiter, et s’arrêter à la saisie de la valeur
d’arrêt -1 ou après avoir saisi 10 données.
Logique et boucles 75 II Les booléens et les boucles 76 I

Algorithme QueChoisirSuite ;
Constantes STOP=-1 ; MAX =10 ;
Variables nbV al, val, som : entiers Le type booléen est composé de deux constantes booleennes :
début VRAI , FAUX. On peut alors utiliser des variables booléennes
nbV al ← 0; {compte les saisies traitees } pour leur affecter des expressions booléennes comme suit :
Som ← 0
Lire(val); {saisie de la 1ere donnee} variables ok, continuer: booleen
tant que (val <> ST OP ) ET (nbV al < M AX) faire ................
nbV al ← nbV al + 1 ok:=rep=(’O’ OU rep=’o’)
som ← som + val {traitement de la valeur saisie}
continuer:=(val > O ET val < 10)
Lire(val) {relance}
fin Les variables booléennes peuvent remplacer es expressions
si val = ST OP alors booléennes dans les conditionnelles et les iteratives :
Ecrire(’Sortie de boucle car saisie de la valeur d’arrêt.’) ;
Ecrire(’Toutes les données significatives ont été TantQue ok Faire ....
traitées.’) Si continuer Alors ....
sinon
Ecrire(’Sortie de boucle car nombre maximum de valeurs
à traiter atteint.’) ; Ecrire(’Des données significatives
n’ont pas pu été traitées.’) ;
fin
Les booléens et les boucles 77 II Les booléens et les boucles 78 I
Algorithme QueChoisir ;
Constantes STOP=-1 ; MAX =10 ;
Variables nbV al, val, som : entiers
encore :booleen ; Algorithme BooleenRepeter ;
début
Variables
nbV al ← 0; /*compte les saisies traitees */
Som ← 0 nbf ois : entier ;
Lire(val) ; /*saisie de la 1ere donnee */ encore : booleen ;
encore ← val <> ST OP )ET (nbV al < début
M AX);{initialisation de la variable booléenne } nbf ois ← 5;
tant que encore faire répéter
nbV al ← nbV al + 1 Ecrire(’bonjour’) ;
som ← som + val /*traitement de la valeur saisie*/ nbf ois ← nbf ois − 1;
Lire(val)
encore ← nbf ois > 0;
encore ← (val <> ST OP )ET (nbV al < M AX);
jusqu’à (Non encore);
{relance}
fin Ecrire(’fini’) ;
si val fin
. . .= ST OP alors
sinon
...
fin
Les booléens et les boucles 79 II Les boucles : Exemple 80

Concevoir un algorithme qui imprime l’ensemble des tables de
multiplication par 1, 2, . . ., 12.
Algorithme BooleenTanque ;
Variables
nbfois : entier ; Algorithme Affichage_table_par_table
encore : booleen ; Variables i, j, produit :entier
début début
encore ← vrai; pour i ← 1 à 12 faire
nbf ois ← 0; pour j ← 1 à 12 faire
tant que encore faire produit ← i × j
Ecrire(’bonjour’) ; Ecrire( i,’×’,j,’=’,produit) ;
nbf ois ← nbf ois + 1; EcrireAlaLigne
encore ← nbf ois < 5; fin
fin EcrireAlaLigne
Ecrire(’fini’) ; fin
fin fin
Les boucles : Exemple 81 Les boucles : Exemple 82
Modifier l’algorithme pour qu’il imprime 3 tables côte à côte. Calculer le quotient et le reste de la division d’un entier a par un
entier b par soustractions successives.
Algorithme Affichage_des_tables_trois_par_trois Algorithme Division ;

Variables i, j, k, produit :entier var a, b, q :entier ;
début début
pour k ← 1 à 4 faire Lire (a, b) ;
pour j ← 1 à 12 faire si b = 0 alors
pour i ← 3 × (k − 1) + 1 à 3 × k faire Ecrire (’Division sur zéro’)
produit ← i × j sinon
Ecrire( i,’×’,j,’=’,produit) ; q ← 0;
fin tant que a >= b faire
EcrireAlaLigne a←a−b
fin q ←q+1
EcrireAlaLigne fin
fin Ecrire (’Le quotient est’,q)
fin Ecrire (’Le reste est’,a)
fin

Le pgcd de deux nombres par
 soustractions successives.
Calculer le PGCD de deux nombres entiers en se base sur le
pgcd(a − b, a) si a > b

fait que si a et b sont deux entiers naturels non nuls,

pgcd(a, b) = pgcd(a, b − a) si b > a

 pgcd(a, b) = pgcd(b, a mod b). C’est l’algorithme d’Euclide.
a si a = b Dans la tradition grecque, en comprenant un nombre entier
comme une longueur, un couple d’entiers comme un
Algorithme PGCD ;
rectangle, leur PGCD est la longueur du côté du plus grand
var a, b :entier ;
carré permettant de carreler entiérement ce rectangle.
début
répéter
Ecrire(’Donner a et b’) ; Lire(a, b) ;
jusqu’à (a > 0) ET (b > 0);;
tant que a <> b faire
si a > b alors
a←a−b
sinon
b←b−a
fin
Ecrire (’Le pgcd est’,a)
fin
Algorithme PGCD_Euclide ;
var a, b :entier ;
début
répéter
Lire(a, b) ;
jusqu’à (a > 0) ET (b > 0);;
x←a
y←b
tant que y 6= 0 faire
r ← x mod y
x←y
y←r
fin
Ecrire (’Le pgcd est’,r)
fin

Donner un algorithme qui détermine à la fois le PGCD et le PPCM
Afficher tous les nombres pairs compris entre deux valeurs entières
de deux entiers a et b
positives lue x et y
On rappelle que P P CM (a, b) × P GCD(a, b) = |a × b|
Algorithme NombresPairs ;
Algorithme PgcdPpcm ; var x, y, z :entier ;
Var a, b, k : entier ; début
Lire (x, y) ;
début
si x > y alors
répéter z ← x;
Ecrire(’a et b : ’) ; x ← y;
lire (a, b) ; y ← z;
jusqu’à a > 0 et b > 0; tant que x ≤ y faire
k ← 0 répéter si x mod 2 = 0 alors
k ←k+1 Ecrire (x) ;
jusqu’à a ∗ k mod b = 0; x ← x + 1;
Ecrire (’ppcm de ’, a, ’ et ’, b, ’ = ’, a ∗ k, ’ pgcd = ’, fin
b div k) fin
fin
Un nombre entier peut être considéré comme un palindrome1
numérique s’il garde la même valeur en inversant les chiffres le
Ecrire un nombre à l’envers constituant. Exemple : 12321, 101, 4
Algorithme palindrome ;
Algorithme Inverse ; var nombre, quotient, reste, somme : entier;
var n, r :entier ; début
début Ecrire(’Entrer un nombre : ’) ; lire(nombre) ;
Lire (n) ; somme ← 0; quotient ← nombre;
répéter tant que quotient <> 0 faire
r ← n mod 10; reste ← quotient mod 10;
Ecrire (r) ; somme ← somme ∗ 10 + reste;
n ← n div 10 quotient ← quotient div 10
jusqu’à n = 0; fin
fin si somme = nombre alors
ecrire(’Palindrome’)
sinon
ecrire(’pas palindrome’)
fin
Les boucles : Exemple 91 Les boucles : Exemple , Multiplication égyptienne 92 I

On appelle nombre d’Armstrong, un nombre autre que 0 ou 1 qui
est égal à la somme des cubes de ses chiffres. (il n’en existe que 4,
compris entre 2 et 1000). Exemple : 153 = 13 + 53 + 33
Algorithm Armstrong Dans l’antiquité, les égyptiens savaient, sans utiliser la

var nombre, quotient, reste, somme : entier; multiplication, sauf par 2, calculer le produit de deux entiers
début positifs, par décompositions successives, grâce à la décomposition
Ecrire(’Entrer un nombre : ’) ; Lire(nombre) ; suivante :
somme ← 0; quotient ← nombre;
tant que quotient <> 0 faire
reste ← quotient mod 10; a × b = a + a × (b − 1) si b est impair
somme ← somme + reste ∗ reste ∗ reste
= a × 2 × (b/2) sinon
quotient ← quotient div 10
fin
si somme = nombre alors
Ecrire(’Armstrong’)
sinon
Ecrire(’pas Armstrong’)
fin
fin
Les boucles : Exemple , Multiplication égyptienne 93 II Les boucles : Exemple , Multiplication égyptienne 94 III
Par exemple : Algorithm MultiplicationEgyptienne

Var a, b : entier début
7 × 5 = 7 + 7 × (5 − 1) Ecrire(’Donner deux entiers’)
= 7 + 7 × 2 × (4/2) Lire(a,b)
= 7 + 14 × (2) resultat ← 0
= 7 + 14 × 2 × (2/2) tant que b >= 1 faire
si b mod 2 = 0 alors
= 7 + 28 × 1 a←a∗2
= 7 + 28 b ← b div 2
= 35 sinon
resultat ← resultat + a
Ecrire l’algorithme réalisant le produit de deux entiers en utilisant b←b−1
fin
cette méthode.
Ecrire(’Le résultat est : ’,resultat )
fin
Les boucles : Exemple ,Exponentiation indienne 95 Les boucles : Exemple ,Exponentiation indienne 96
On se propose de calculer a puissance b (noté ab avec a et b des
entiers positifs) sachant que l’on ne dispose que de l’élévation au Dans le cas ou b est impair on se ramène au cas précédent.
carré, de la division euclidienne par 2 et de la multiplication de Exemple avec a5
deux nombres, le tout en minimisant le nombre d’opérations.
Dans le cas où b est pair les facteurs a sont regroupés deux à deux
pour minimiser le nombre de multiplications. Exemple avec a8
Il y a trois multiplications au lieu de quatre avec le calcul habituel.

L’intérêt de cette méthode est évident lorsque la variable b a une
très grande valeur. Donner un algorithme qui calcule la puissance
ab grâce à cette méthode, les valeurs de a et de b étant entières
et positives.
Les boucles : Exemple ,Exponentiation indienne 97 Les boucles : Exemple, test de primalité 98 I
Rappel :
1 n’est pas premier
Algorithme exponentiationIndienne ;(à revoir) On dit qu’un nombre naturel n ≥ 2 est premier s’il n’est
Variable a, b, resultat : entier ; divisible que par 1 et par lui même
x, y, reste :reel ; 2 est premier c’est le seul nombre pair premier
début Le début de la suite infinie de nombre premier est
répéter 2,3,5,7,11,13,17
Ecrire(’deux entiers positifs a et b ?’) ;Lire(a, b) ;
jusqu’à (a > 0) et (b > 0);
resultat ← 1; x ← a; y ← b;
reste ← b mod 2
si reste <>0 alors
y ← y − 1; resultat ← resultat ∗ a;
fin
tant que ((y <> 1) faire
x ← x ∗ x;
y ← y/2;
fin
Ecrire(a,’puissance’, b ,’=’,resultat ∗ x) ;
fin
Les boucles : Exemple, test de primalité 99 II Les boucles : Exemple, test de primalité 100
Algorithm nbPremier ; //VERSION 1
var n, d, nbdiv : entier ;
début
répéter
Ecrire(’Donner un entier positif : ’) ; Lire(n) Rappel :
jusqu’à n > 0; 1 n’est pas premier
si n = 1 alors On dit qu’un nombre naturel n ≥ 2 est premier s’il n’est
nbdiv ← 1// pour bon affichage en fin d’algorithme divisible que par 1 et par lui même
sinon
2 est premier c’est le seul nombre pair premier
nbdiv ← 0
pour d ← 2 to n − 1 faire Le début de la suite infinie de nombre premier est
si n mod d = 0 alors 2,3,5,7,11,13,17
nbdiv ← nbdiv + 1
fin
si nbdiv = 0 alors
ecrire(n,’ est premier’)
sinon
ecrire(n,’ n”est pas premier’)
fin
Les boucles : Exemple, test de primalité 101 Les boucles : Exemple, test de primalité : VERSION 2 102
Algorithme nbPremier ; //VERSION 1 var n, d : entier ; premier : booleen ;
var n, d, nbdiv : entier ; début
début /*Saisie n > 0 */
répéter si n = 1 alors
Ecrire(’Donner un entier positif : ’) ; Lire(n) premier ← f aux// pour bon affichage en fin
jusqu’à n > 0; d’algorithme
si n = 1 alors sinon
nbdiv ← 1// pour bon affichage en fin d’algorithme premier ← vrai
sinon d ← 2;
nbdiv ← 0 tant que (d * d < n) ET premier faire
pour d ← 2 to n − 1 faire premier ← (n mod d > 0);
si n M OD d = 0 alors d←d+1
nbdiv ← nbdiv + 1 fin
fin si premier alors
si nbdiv = 0 alors ecrire(n,’ est premier’)
ecrire(n,’ est premier’) sinon
sinon ecrire(n,’ n”est pas premier’)
ecrire(n,’ n”est pas premier’) fin
fin
Décomposition d’un nombre en facteurs premiers. 103 I Décomposition d’un nombre en facteurs premiers. 104
Algorithme decomposition ;
var nombre, diviseur : entier ;
début
On cherche à écrire un algorithme permettant de décomposer un diviseur ← 2;
nombre en facteurs premiers. Par exemple, pour 12, le programme répéter
devra afficher 12=1*2*2*3, pour 42 on aura 42=1*2*2*7 et enfin Ecrire(’Entrez le nombre dont vous voulez la
pour 37, 37=1*37 ; Donnez un programme saisit un nombre et decomposition : ’) ;
affiche ensuite la décomposition de ce dernier en produits de lire(nombre) ;
facteurs premiers. Il est conseillé de procéder d’abord à un jusqu’à (nombre > 0);
ecrire(nombre,’=1’) ;
traitement manuel sur un nombre quelconque. tant que (nombre <> 1) faire
si ((nombre M OD diviseur) = 0) alors
ecrire(’*’, diviseur) ;
nombre ← nombre DIV diviseur;
sinon
diviseur ← diviseur + 1;
fin
fin
105 106
n
X x2k x2 x4 x2n
y = cos(x) ≈ (−1)k =1− + + . . . + (−1)n
k=0
(2k)! 2 24 (2n)!
Calculer la fonction ci-dessous en fonction de son développement avec
x2(k+1) −x2 x2k
P
en série entière ( uk ). Les calculs seront arrêtés lorsque la valeur
absolue du terme uk sera inférieure à un certain seuil s uk+1 = (−1)k = · (−1)k =
(2(k + 1))! (2k + 1)(2k + 2) (2k)!
(0 < s < 1). On n’utilisera ni la fonction puissance (xn ) ni la −x2
fonction factorielle (n!). uk
(2k + 1)(2k + 2)
n
x2k x2 x4 x2n x2(k+1)
uk+1 =(−1)k
X
k
y = cos(x) ≈ (−1) =1− + + . . . + (−1)n (2(k + 1))!
k=0
(2k)! 2 24 (2n)!
−x2 x2k
= · (−1)k
(2k + 1)(2k + 2) (2k)!
−x 2
= uk
(2k + 1)(2k + 2)
107 Coefficients du binôme 108
Il s’agit ici de développer le binôme (a + b)n et de déterminer les

coefficients des termes an−k bk .
Algorithme cosinus ;
var y, u, s : reel ; n n
!
n
X n n−k k X n!
k : entier ; (a + b) = a b = an−k bk
début k=0
k k=0
k!(n − k)!
k←0 u←1
La formule de Pascal lie les coefficients binomiaux entre eux selon
y←u s ← 1.e − 6
répéter
la relation de récurrence :
Ecrire(’Entrer un réél : ’) ;
lire(x) ; ! ! ! ! !
jusqu’à (x > 0); n n−1 n−1 n n
= + pour(0 < k < n) et = =1
tant que abs(u) > s faire k k k−1 0 n
u ← −u ∗ x ∗ x/((2 ∗ k + 1) ∗ (2 ∗ k + 2))
y ←y+u Elle permet un calcul rapide des coefficients pour les petites
k ←k+1 valeurs de n sans division ni multiplication. Elle est utilisée pour
fin construire à la main le triangle de Pascal
fin
Coefficients du binôme 109 Coefficients du binôme 110
La version itérative ci-dessous calcule directement le numérateur
num et le dénominateur den du coefficient c en tenant compte de
la simplification suivante :
!
n n! n · (n − 1) . . . (n − k + 2) · (n − k + 1)
= =
k k!(n − k)! 1·2·3···k
............
début ............
num ← 1
den ← 1
pour i ← 1 à k + 1 faire
num ← num ∗ (n − i + 1)
den ← den ∗ i
fin
c ← num/den
............
fin
Coefficients du binôme 111 La structure séquentielle

Plan 112
2 Les structures alternatives
Le choix simple
3 Les structures répétitives
Définition
Exemple comparatif
Instructions 113 Instruction conditionnelle if....else 114 I
instruction de contrôle : permet de contrôler le
fonctionnement d’un programme. instructions de sélection et Syntaxe
les boucles if (expression)
Une instruction simple est instruction1
soit une instruction de contrôle,
soit une expression suivie de “ ;”
Un bloc a la structure suivante : if (expression)
une accolade ouvrante { instruction1
une liste de définitions locales au bloc (optionnelle) else
une suite d’instructions instruction2
une accolade fermante } (qui n’est pas suivie d’un ;).
if ( a == b ) {
x=0; printf ( " les variables a et b sont égales \ n " );
i++; } else {
printf("Coucou\n"); printf ( " les variables a et b ne sont pas égales \ n " ); }
if (x==0) { ATTENTION : Ne pas confondre a == b avec a = b :
x=1;
a == b est une comparaison qui vérifie si a et b sont égaux.
i++;
printf("Dans le bloc !\n"); a = b est une affectation, on affecte à la variable a la valeur
} de la variable b.
Instruction conditionnelle if....else 115 I Instruction conditionnelle if....else 116 II
int main (){

int a ,b ,c , max ;
Ecrivez un programme qui demande à l’utilisateur de saisir trois printf ( " Entrez les valeurs de a , b et c
( sous la forme a : b : c ) : \ n " );
entiers , et , puis qui affiche le plus grand de ces trois entiers.
scanf ( " % d :% d :% d " ,&a ,& b ,& c );
Respectez exactement la forme de l’exemple donné ci-dessous. max = a ;
exemple : if ( max < b )
max = b ;
if ( max < c )
max = c ;
printf ( " le plus grand des trois
entiers est % d .\ n " , max );
return EXIT_SUCCESS ;
}
Instruction conditionnelle if....else 117 I Instruction conditionnelle if....else 118 I
Année bissextile(leap year )

Si l’année A n’est pas divisible par 4, alors elle n’est pas bissextile.
Si A est divisible par 4, l’année est bissextile sauf si A est divisible
par 100 et pas par 400.
Exemples :
1901 n’est pas bissextile car non divisible par 4
2004 est bissextile car divisible par 4 et pas par 100
2100 n’est pas bissextile car divisible par 4, divisible par 100
mais pas par 400
2000 est bissextile car divisible par 4, par 100 et par 400
Ecrire un programme qui détermine si une année est bissextile ou
non.
Instruction conditionnelle if....else 119 II Instruction conditionnelle if....else 120 I
# include < stdio .h >

int main () {
int annee ; # include < stdio .h >
printf ( " Donner une année " ) ; int main () {
scanf ( " % d " ,& annee ); int annee ;
if (( annee % 4) == 0) printf ( " Donner une année " ) ;
if (( annee % 100) == 0) scanf ( " % d " ,& annee );
if (( annee % 400) == 0) if ( ( annee %4 == 0) &&
printf ( " % d est bissextile \ n " , annee ) ; (( annee %100 != 0) || ( annee %400 == 0 )))
else printf ( " % d est bissextile \ n " , annee )
printf ( " % d n ’ est pas bissextile \ n " , annee ) ; else
else printf ( " % d n ’ est pas bissextile \ n " , annee ) ;
printf ( " % d est bissextile \ n " , annee ) ; return 0;
else }
printf ( " % d n ’ est pas bissextile \ n " , annee ) ;
return 0 ;
}
Instruction conditionnelle if....else 121 I Instruction conditionnelle if....else 122

# include < math .h >
main (){
float a , b , c , delta , x , y ;
printf ( " trois flottants ? " ); scanf ( " % f % f %f ,& a ,& b ,& c );
if ( a ==0)
if ( b ==0)
if ( c ==0)
printf ( " tout est solution \ n " );
else
printf ( " pas de solution " );
else
printf ( " une solution : % f \ n " , -c / b );
else { delta = b *b -4* a * c
if ( delta >=0){
x =( -b - sqrt ( delta ))/(2* a );
y =( - b + sqrt ( delta ))/(2* a );
printf ( " Deux solutions : %f , % f \ n " ,x , y );
}
else printf ( " pas de solution reelle \ n " );
}
}
Instruction de sélection multiple switch 123 Instruction de sélection multiple switch 124
Syntaxe
switch (expression ){ La valeur de expression doit être de type entier, caractère
case constante1: ou énuméré.
liste d’instructions 1 L’expression qui se trouve après chaque case ne peut pas
break; contenir de variable ni d’appel de fonction et doit être de type
case constante2: entier, char ou enuméré.
liste d’instructions 2 Lorsqu’un cas est sélectionné, ce sont toutes les instructions
break; qui le suivent qui sont exécutées, y compris celles des autres
... cas et ceci jusqu’à la fin du bloc du switch et
case constanten: indépendamment des autres conditions.
liste d’instructions n break ; permet de rendre les blocs mutuellement exclusifs.
break; break; provoque la sortie du bloc de l’instruction switch.
default:
Si aucune des expressions ne correspond, la branche default
liste d’instructions
facultative est activée.
break;
}
Instruction de sélection multiple switch 125 Instruction de sélection multiple switch 126
int main (){
Remarques int i ;
Comme toutes les instructions qui suivent un case sont printf ( " Entre un chiffre : " );
scanf ( " % d " ,& i );
exécutées si celui-ci est activé, il est souvent nécessaire de switch ( i ) {
sortir avec un break, mais ce n’est pas obligatoire. case 0 : printf ( " ton chiffre est zero !\ n " );
Par ailleurs, ce mécanisme permet de faire des "ou" et de faire break ;
case 6 :
le même traitement pour différentes valeurs. case 8 : printf ( " ton chiffre est plus grand que 5\ n " );
Par exemple : case 4 :
case 2 : printf ( " ton chiffre est pair \ n " );
case valeur1: break ;
case valeur2: case 9 :
case valeur3: case 7 : printf ( " ton chiffre est plus grand que 5\ n " );
faire un ensemble de choses case 5 :
case 3 :
break;
case 1 : printf ( " ton chiffre est impair \ n " );
Permet de faire la même chose pour les trois valeurs valeur1, break ;
valeur2 et valeur3. default : printf ( " ce n ’ est pas un chiffre !\ n " );
}
}
Les Boucles 127 Les Boucles 128

Boucle while Vérifier si un entier n est un carré parfait
While (<condition> )
Corrigé
<Instruction>
# include < stdio .h > ;
main () {
int n , i , j ;
i = 1; printf ( " Donnez l ’ entier à tester : " );
while ( i < 10){ scanf ( " % d " , & n );
printf ( " \ n i = % d " ,i ); i = 0;
i ++; Faux
<Condition> j = 0;
} while (j < n ) {
Vrai
i = i +1 ;
j= i* i ;
<instruction> }
if ( j == n )
printf ( " % d est un carré parfait " , n );
else
printf ( " % d n ’ est pas un carré parfait " , n );
}
Ecrivez un programme qui saisit un entier , renverse l’entier et
Boucle do....while
affiche le résultat.
Exemple do
Entrez l’entier a renverser :1234 <Instruction>
Resultat : 4321 while (<condition> );
int a ;
Corrigé do {
printf ( " \ n un entier > 1 et <10 : " );
int main ( int argc , char ** argv ) { scanf ( " % d " ,& a );
int x , y ; }
printf ( " Entrez l ’ entier a renverser : " ); while (( a <= 1) || ( a >= 10)); <instruction>
scanf ( " % d " ,& x ); --------------------------------------
y =0; char c = ’a ’;
while (x >0){ do {
y = y *10 + x %10; printf ( " % c " ,c ); vrai
x = x /10; c += 1; <Condition>
} } while (c <= ’z ’ );
printf ( " Resultat : % d \ n " ,y ); faux
return EXIT_SUCCESS ;
}

Boucle for
Test de primalité d’un nombre entier.
for (<init> ;<test> ;<incrémentation>)
* Corrigé <instruction>
<init> : initialisation du compteur
int main ( void ){
int d , n , r ; <test> : test de continuation
printf ( " donnez un entier : " ); <incrémentation> :incrémentation du compteur
scanf ( " % d " , & n );
d = 1;
do { Une version équivalente plus intuitive est :
<initialisation>
d = d +1;
r = n % d; <init>;
} while (r >=1&& d *d <= n ); while (<test> ){ non
if ( r ==0) <Condition>
printf ( " nombre divisible par % d \ n " ,d );

<instruction>
vrai
else <incrémentation>;
<instruction>
printf ( " nombre premier \ n " ); return 0; }
}
<incrémentation>
Pour imprimer tous les entiers de 0 à 9, on écrit : for (expr 1 ;expr 2 ;expr 3)
instruction
for ( i = 0; i < 10; i ++)
printf ( " \ n i = % d " ,i );
expr1 et expr3 peuvent être absentes(les point-virgules
Pour calculer la factorielle d’un entier, on peut écrire : doivent cependant apparaître. Par exemple
for( ; expr2 ; )
int n , i , fact ; instruction
for ( i = 1 , fact = 1; i <= n ; i ++)
fact *= i ; équivaut à
printf ( " % d ! = % d \ n " ,n , fact );
while(expr2)
On peut également insérer l’instruction fact *= i ; dans la instruction
boucle for ce qui donne :
la condition de continuation expr2 peut elle aussi être
absente. On considère qu’elle est toujours vrai. Dans ce cas la
int n , i , fact ;
for ( i = 1 , fact = 1; i <= n ; fact *= i , i ++);
boucle devient infinie :
printf ( " % d ! = % d \ n " ,n , fact ); for( ; ; )
instruction
Inverser un entier
for ( ; ; ){
printf ( " donnez un nombre (0 pour sortir ) : " );
int main (){
scanf ( " % d " ,& n );
int num ,r , inverse =0;
if ( n == 0)
printf ( " Entrer un nombre : " );
break ;
scanf ( " % d " ,& num );
. . .
for (; num !=0; num = num /10){
// traitement de n
r = num %10;
. . .
inverse = inverse *10+ r ;
}
}
printf ( " Nombre à l ’ envers : % d " , inverse );
return 0;
}
L’instruction break 137 L’instruction break 138
Par construction, l’instruction
break for( expr1 ; expr2 ; expr3){

. . .
permet d’interrompre le déroulement de la boucle, et passe à break;
la première instruction qui suit la boucle. En cas de boucles . . .
imbriquées, break fait sortir de la boucle la plus interne. ♠ }
main (){ équivaut à

int i ;
for ( i = 0; i < 5; i ++){ {
printf ( " i = \% d \\ n " ,i );
for( expr1 ; expr2 ; expr3){
if ( i == 3)
break ; . . .
} goto sortie;
printf ( " valeur de i a la sortie de la boucle = \% d \\ n " ,i ); . . .
} }
sortie :;
}
L’instruction continue 139 Les instructions return et goto 140
return
continue A voir dans le chapitre sur les fonctions. permet d’abandon-
utilisée dans les boucles for, do ... while ou while per- ner une fonction pour retourner à la fonction appelante (en
met d’abandonner l’itération courante pour passer au début fournissant éventuellement une valeur) ♠
de l’itération suivante ♠
goto
for ( i = 0; i < 10; i = i + 1){ goto n’est pas très conseillée car elle est contraire aux prin-
printf ( " entrer votre \% deme entier : " ,i );
scanf ( " \% d " ,& n ); cipes de la programmation structurée ! Vous pouvez faire
if (n <0) continue ; /* on passe au i suivant dans le for */ précéder toute instruction par un identificateur (appelé
... /* traitement de l ’ entier fourni */ étiquette) suivi de :. Une instruction goto identificateur
} a pour effet de se brancher à l’instruction étiquetée par
identificateur qui est alors exécutée. ♠
* Corrigé
Ecriture en binaire
int main ( void ) {
La représentation binaire d ?un nombre entier x est la suite int x ,y , n ;
(bk , . . . , b1 , b0 ) définie par la formule : scanf ( " % d " , & n );
x = n ; y = 1;
x = bk 2k + . . . + b1 2 + b0 while ( y + y <= x )
y = y+y;
Principe de calcul : en deux étapes while ( y != 0) {
if ( x < y )
1 On calcule y = 2k comme la plus grande puissance de 2 t.q. printf ( " 0 " );
y ≤ x. else {
printf ( " 1 " );
2 Itérativement, on remplace y par y/2 en soustrayant y de x à x = x - y;
chaque fois que y ≤ x (et en écrivant 1 ou 0 suivant le cas). }
y = y / 2;
}
printf ( " \ n " );
return 0;
}
* Corrigé
écrire un programme qui demande à l’utilisateur un entier N positif
puis affiche le motif suivant avec les chiffres allant de 1 à N.. # include < stdio .h >
Affichage 2 Parexemple : N=5 int main (){
int N , cols , i , j ;
1 2 3 4 5 printf ( " Donner un entier N : " );
scanf ( " % d " , & N );
2 3 4 5 1 for ( i =1; i <= N ; i ++) {
3 4 5 2 1 for ( j = i ; j <= N ; j ++) {
4 5 3 2 1 printf ( " % d " , j );
5 4 3 2 1 }
for ( j =i -1; j >=1; j - -) {
printf ( " % d " , j );
}
printf ( " \ n " )
}
return 0;
* Corrigé
Construire un dessin de la lettre X , à l’aide d’espaces et d’un void main (){
« caractère » fourni par l’utilisateur, auquel on demande aussi la int N ,i , j ;
« hauteur » du dessin qu’il désire obtenir. Par exemple : char ch ;
printf ( " Entrer la taille N du ’X ’ " );
scanf ( " % i " , & N );
Entrez le caractère : *
printf ( " Entrer le caractère du ’X ’ " );
Nombre de lignes : 5 scanf ( " % c " , & ch );
* * for ( i =1; i <= N ; i ++){
* * for ( j = 1; j <= N ; j ++) {
* if ( i == j || j == N - i + 1)
printf ( " % c " , ch );
* * else
* * printf ( " " );
}
printf ( " \ n " );
}
}
Les Boucles 147 LesCalculez

Boucles la somme des N premiers termes de la série harmonique : 148
1 + 1/2 + 1/3 + . . . + 1/N
* Corrigé
main (){
int N ; /* nombre de termes à calculer */
int I ; /* compteur pour la boucle */
float SOM ; /* Type float à cause de la précision
du résultat . */
do {
scanf ( " % d " , & N );
} while (N <1);
for ( SOM =0.0 , I =1 ; I <= N ; I ++)
SOM += ( float )1/ I ;
printf ( " La somme des % d premiers termes
est % f \ n " , N , SOM );
return 0;
}
Les Boucles 149 I Les Boucles 150 II
* Corrigé
int main (){
int nombre , resultat =0 , placeDecimale = 1;
Ecrire un programme qui étant donné un nombre a strictement do {
printf ( " Donner un nombre " );
positif retourne, sans utiliser de tableau un autre nombre b formé à scanf ( " % d " , & nombre );
partir de a en remplaçant chaque 0 dans a par 5. } while ( nombre <0);
a = 102 ⇒ b = 152 resultat = nombre ;
a = 1020 ⇒ b = 1525 if ( nombre == 0)
resultat += (5 * placeDecimale );
while ( nombre >0){
if (( nombre % 10 == 0))
resultat += (5 * placeDecimale );
nombre /= 10;
placeDecimale *= 10;
printf ( " res % d \ n " , resultat );
}
printf ( " Le résulat est % d \ n " , resultat );
return 0;
Ecrire un programme qui affiche les entiers dans l’intervalle [1, N ] * Corrigé
de la façon suivante (exemple pour N = 20) : # include < stdio .h >
1␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣20 # define N 20
1␣␣2␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣19␣20 int main () {
1␣␣2␣␣3␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣18␣19␣20 int i , j ;
for ( i =0; i < N /2; i ++) {
1␣␣2␣␣3␣␣4␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣17␣18␣19␣20
for ( j =0; j <= i ; j ++) {
1␣␣2␣␣3␣␣4␣␣5␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣16␣17␣18␣19␣20 printf ( " %3 d " , j +1);
1␣␣2␣␣3␣␣4␣␣5␣␣6␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣15␣16␣17␣18␣19␣20 }
1␣␣2␣␣3␣␣4␣␣5␣␣6␣␣7␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣14␣15␣16␣17␣18␣19␣20 for ( j = i +1; j <N -i -1; j ++) {
printf ( " " ); // 3 espaces
1␣␣2␣␣3␣␣4␣␣5␣␣6␣␣7␣␣8␣␣␣␣␣␣␣␣␣␣␣␣␣13␣14␣15␣16␣17␣18␣19␣20
}
1␣␣2␣␣3␣␣4␣␣5␣␣6␣␣7␣␣8␣␣9␣␣␣␣␣␣␣12␣13␣14␣15␣16␣17␣18␣19␣20 for ( j =N -i -1; j < N ; j ++) {
1␣␣2␣␣3␣␣4␣␣5␣␣6␣␣7␣␣8␣␣9␣10␣11␣12␣13␣14␣15␣16␣17␣18␣19␣20 printf ( " %3 d " , j +1);
Le symbole represente ␣l’espace blanc. Votre programme doit }
pouvoir fonctionner avec n’importe quel entier N entre 0 et 99 printf ( " \ n " );
}
}
La structure séquentielle La structure séquentielle
Les structures alternatives Les structures alternatives
Les structures répétitives Les structures répétitives
Application au Langage C Application au Langage C
Références I Références II
Alfred V. Aho et Jeffrey D. Ullman. Philippe Flajolet et Robert Sedgewick.

Concepts fondamentaux de l’informatique, Introduction à l’analyse d’algorithmes,
Dunod, 1993. Addison-Wesley, 1996. Thomson Publishing, 1996
Brassard Gilles, Bratley Paul Danièle Beauquier, Jean Berstel, Philippe Chrétienne.
Fundamentals of Algorithmics, Éléments d’algorithmique,
Prentice Hall, 1996. Masson, 1992. http ://www-igm.univ-mlv.fr/b̃erstel/
Cormen Thomas H., Leiserson Charles E., Rivest Ronald L.,
C. Froidevaux, M-C. Gaudel, M. Soria :
Stein Clifford
Types de données et Algorithmes.
Introduction à l’algorithmique,
McGraw Hill Paris, 1990
Dunod, 2002 (seconde édition).
Pr. David C. FAYE/UFR SAT-UGB UE INFO111 -Algo I : Structures de contrôle Pr. David C. FAYE/UFR SAT-UGB UE INFO111 -Algo I : Structures de contrôle

Slide Algo Bases Algo1 Cours2

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

Slide Algo Bases Algo1 Cours2

Transféré par

Droits d'auteur :

Formats disponibles

La structure séquentielle

Les structures alternatives

Pr. David C. FAYE/UFR SAT-UGB UE INFO111 -Algo I : Structures de contrôle

Introduction 3 II La structure séquentielle

notion de séquence 7 Calcul d’un produit de 2 nombres 8I

si < condition > alors

Le choix simple 15 II Le choix simple 16 III

Figure – Organigramme de la sélection sans alternative

Figure – Organigramme de la sélection avec alternative

Calcul d’une racine carrée (SI... ALORS... SINON)

Le choix simple : Ambiguïtés syntaxiques 19 I Le choix simple : Ambiguïtés syntaxiques 20 II

Il faut bien percevoir que la formulation de l’instruction SI

Le choix simple : Exemple 23 I Le choix simple : Exemple 24 II

Signe du produit de 2 nombres, sans calculer ce produit

Variables X, Y, Z, M in, M ax : Entier

Le choix simple : Exemple 27 La sélection multiple : le CAS... 28 I

il est préférable de choisir une sélection multiple

La sélection multiple : le CAS... 31 II La sélection multiple : le CAS... 32 III

Le concept de condition 35 II Le concept de condition 36 III

L’opérateur ET permet de simplifier l’écriture d’une série

Définition 39 II Boucle à bornes définies (POUR...FAIRE) 40 I

Dans le cas d’une boucle à bornes définies, nous connaissons

NB : Cet algorithme peut être optimisé en réduisant

Boucle à bornes définies (POUR...FAIRE) 43 IV Boucle à bornes définies (POUR...FAIRE) 44 V

Boucle (POUR...FAIRE) exemple 47 Boucles à bornes non définies 48 I

tant que < condition > faire

Boucles à bornes non définies REPETER 55 Boucles à bornes non définies 56 I

Faire attention aux conditions initiales, aux conditions d’arrêt

Dans le cas d’une boucle REPETER... JUSQU’A, le bloc

Boucles à bornes non définies 59 I Boucles à bornes non définies 60 I

Forme 1 avec POUR

Nous allons à présent traiter le même exemple, avec trois

Boucles à bornes non définies 63 II Boucles à bornes non définies 64

boucle Pour boucle répéter boucle tant que

• Il faut être sûr d’en sortir

1 Faire soi-même le calcul sur un ou plusieurs exemples

Il faut interpréter(et bien comprendre !) l’arrêt des itérations à la

Logique et boucles 75 II Les booléens et les boucles 76 I

Les booléens et les boucles 79 II Les boucles : Exemple 80

Algorithme Affichage_des_tables_trois_par_trois Algorithme Division ;

Les boucles : Exemple 83 Les boucles : Exemple 84

Les boucles : Exemple 87 Les boucles : Exemple 88

Les boucles : Exemple 91 Les boucles : Exemple , Multiplication égyptienne 92 I

Algorithm Armstrong Dans l’antiquité, les égyptiens savaient, sans utiliser la

Par exemple : Algorithm MultiplicationEgyptienne

Il y a trois multiplications au lieu de quatre avec le calcul habituel.

107 Coefficients du binôme 108

Il s’agit ici de développer le binôme (a + b)n et de déterminer les

Coefficients du binôme 111 La structure séquentielle

Instruction conditionnelle if....else 115 I Instruction conditionnelle if....else 116 II

int main (){

Année bissextile(leap year )

Instruction conditionnelle if....else 119 II Instruction conditionnelle if....else 120 I

# include < stdio .h >

# include < stdio .h >

Les Boucles 127 Les Boucles 128

Les Boucles 131 Les Boucles 132

printf ( " nombre divisible par % d \ n " ,d );

Les Boucles 135 Les Boucles 136

break for( expr1 ; expr2 ; expr3){

main (){ équivaut à

L’instruction continue 139 Les instructions return et goto 140

Les Boucles 143 Les Boucles 144