Lycée Lissane Eddine Ibn Al-Khatib
CENTRE CPGE –LAAYOUNE-
PROFESSEUR: ARROU ABDESSELAM
STRUCTURE GÉNÉRALE D'UN ALGORITHME
Algorithme : NomAlgorithme Entête
Constante : Déclaration des
constantes Déclaration des données
Variable : Déclaration des variables
Début
Instruction 1
Instruction 2
Corps ou Bloc de l'algorithme
..................
Instruction k
Fin
LES STRUCTURES DE CONTRÔLE DE BASE
Les structures de contrôle définissent la façon avec laquelle les instructions sont
effectuées. Elles conditionnent l'exécution d'instructions à la valeur d'une expression. Un
algorithme peut avoir trois structures:
La structure séquentielle:
Dans une structure séquentielle toutes les instructions sont exécutées une seule fois.
La structure alternative(conditionnelle):
contrairement à une structure séquentielle, Une structure conditionnelle permet de
faire des choix sur les blocs d’instructions à exécuté
La structure répétitive(itérative):
Les instructions se répéter plusieurs fois.
La structure de contrôle
- Les Boucles-
STRUCTURE RÉPÉTITIVE
Les structures répétitives(ou boucles) nous permettent de gagner
énormément de temps en éliminant les répétions.
Imaginez que vous avez à exécuter une certaine instructions un certain
nombre de fois, disons 100 fois, alors au lieu de taper ces instructions 100
fois, les structures répétitives nous permettent de la taper une seule fois en
indiquant le nombre de fois que l'ordinateur doit l'exécuter.
On identifie en règle générale deux types de la structure répétitive :
La boucle Pour …. ‘for…. ’
La boucle Tant Que….’while…’
STRUCTURE RÉPÉTITIVE-POUR/TANTQUE-
La structure Pour La structure Tant que
Syntaxe : Syntaxe :
Pour i allant de 1 à n [Pas] Tant Que Condition Faire
Faire Instruction 1
Instruction 1 Instruction 2
Instruction 2 .......
Instruction N
.......
Instruction N Fin Tant Que
Fin Pour Instruction k
Instruction k
STRUCTURE RÉPÉTITIVE
Activité 01:
Écrire l'algorithme qui permet d'afficher les 20 premiers nombres.
Sous la forme suivante :
"Nombre :1"
"Nombre :2"
……………
"Nombre :20"
"Fin d'algorithme "
STRUCTURE RÉPÉTITIVE-POUR-
Correction Activité 01 avec la structure répétitive Pour ...
Algorithme : Nombres_premiers
Variable i,N: entier
Début :
Pour i allant de 1 à N Faire
Ecrire (ʺNombre :ʺ,i);
Fin Pour
Ecrire (ʺFin d'algorithmeʺ);
Fin.
STRUCTURE RÉPÉTITIVE-POUR-
La structure Pour est utilisée impérativement lorsqu’on connaît à
priori le nombre de répétitions à effectuer.
Syntaxe :
Pour i allant de 1 à N [Pas] Faire
Instruction 1
Instruction 2
.......
Instruction N
Fin Pour
Instruction k
STRUCTURE RÉPÉTITIVE-POUR-
Remarque :
Le nombre d'itérations dans une boucle Pour est connu avant le début de
la boucle.
Le compteur :
Est une variable de type entier (ou caractère). Elle doit être déclarée
Le pas :
Est un entier qui peut être positif ou négatif. (Pas peut ne pas être
mentionné, car par défaut sa valeur est égal à 1).
Valeur initiale et finale :
Peuvent être des valeurs, des variables définies avant le début de la
boucle ou des expressions de même type que compteur.
STRUCTURE RÉPÉTITIVE-POUR-
Fonctionnement de la boucle Pour … :
1. La valeur initiale est affectée à la variable compteur
2. On compare la valeur du compteur et la valeur de finale :
3. Si la valeur du compteur est > à la valeur finale on sort de la boucle et on continue avec
l'instruction qui suit Fin Pour
1. Si compteur est <= à la valeur finale instructions seront exécutées.
a) Ensuite, la valeur de compteur est incrémentée de la valeur du pas
b) On recommence l'étape 2 : La comparaison entre compteur et finale est de
nouveau effectuée, et ainsi de suite
4. Sinon on quitte la boucle pour et les instructions qui se trouve après la boucle Pour seront
exécutées
STRUCTURE RÉPÉTITIVE-TANTQUE-
La structure Tant que permet de répéter une série d'instructions
tant que la condition est réalisée (Vrai). Le nombre de répétition
n’est pas connu à l’avance.
Syntaxe :
Tant Que Condition Faire
Instruction 1
Instruction 2
.......
Instruction N
Fin Tant Que
STRUCTURE RÉPÉTITIVE-TANTQUE-
Fonctionnement de la boucle Tant Que … :
Si la condition est fausse au départ, le bloc d’instructions ne sera
jamais exécuté.
La condition étant évaluée au début, les variables utilisées dans la
condition doivent avoir été initialisées.
Pour éviter une boucle infinie, la valeur de l'expression évaluée dans
la condition d'exécution doit devenir fausse pour sortir de la boucle.
Pour cela, il faut nécessairement que dans le corps de la boucle, la
condition soit modifiée quelque part.
STRUCTURE RÉPÉTITIVE-POUR-
Activité 02:
Ecrire un algorithme qui permet de calculer et d'afficher la table de
multiplication d'un nombre N de type Entier.
"Table de multiplication de : 7"
"7 fois 1 font 7"
"7 fois 2 font 14"
…………………
"7 fois 10 font 70"
"Fin d'algorithme "
STRUCTURE RÉPÉTITIVE-POUR-
Correction Activité 02 avec la structure répétitive Pour ...
Algorithme : Table_multiplication
Variable N, i, prod: entier
Début :
Ecrire (ʺEntrez la valeur de Nʺ);
Lire(N);
Ecrire (ʺTable de multiplication de :",7);
Pour i allant de 1 à 10 Faire
ProdProd * i
Ecrire (N," fois ʺ, i ," = ",Prod);
Fin Pour
Ecrire (ʺFin d'algorithmeʺ);
Fin.
STRUCTURE RÉPÉTITIVE-POUR-
Exercice 01:
Écrire un algorithme permettant de calculer la somme des entiers de 1 à
N. L’algorithme demandera à l’utilisateur d’entrer la valeur de N.
Exercice 02:
Ecrire un algorithme permettant de calculer la somme des nombres
impairs de 1 à N, le nombre N étant renseigné par l’utilisateur.
Exercice 03:
Ecrire un algorithme qui calcule le carré de tous les entiers compris
entre 1 et 50.
STRUCTURE RÉPÉTITIVE-POUR-
Correction Exercice 01
Algorithme : Somme_N_nombres
Variable N, i, Som: entier
Début :
Ecrire (ʺSomme N nombresʺ);
Ecrire (ʺEntrez la valeur de Nʺ);
Lire(N);
Som0
Pour i allant de 1 à N Faire
SomSom + i
Fin Pour
Ecrire (ʺLa somme de N nombres est :ʺ,Som);
Fin.
STRUCTURE RÉPÉTITIVE-TANTQUE-
Activité 01:
Écrire un algorithme qui permet de calculer la somme d’une suite de
nombres entiers non nuls entrés au clavier, sachant que le dernier
élément à lire est un zéro.
Exemple : 1, 2, 4, 5 ,6,0 le résultat est :18
STRUCTURE RÉPÉTITIVE-TANTQUE-
Correction Activité 01
Algorithme : Somme_N_nombres
Variable N, i, Som: entier
Début :
Ecrire (ʺSomme N nombresʺ);
Ecrire (ʺEntrez la valeur de N taper 0 pour Quitterʺ);
Lire(N);
SomN
Tant Que N<>0 Faire
Ecrire (ʺEntrez la valeur de N taper 0 pour Quitterʺ);
Lire(N);
SomSom + N
Fin Tantque
Ecrire (ʺLa somme de N nombres est :ʺ,Som);
Fin.
STRUCTURE RÉPÉTITIVE-TANTQUE-
La structure Tant que permet de répéter une série d'instructions
tant que la condition est réalisée (Vrai). Le nombre de répétition
n’est pas connu à l’avance.
Syntaxe :
Tant Que Condition Faire
Instruction 1
Instruction 2
.......
Instruction N
Fin Tant Que
STRUCTURE RÉPÉTITIVE-TANTQUE-
Fonctionnement de la boucle Tant Que … :
Si la condition est fausse au départ, le bloc d’instructions ne sera
jamais exécuté.
La condition étant évaluée au début, les variables utilisées dans la
condition doivent avoir été initialisées.
Pour éviter une boucle infinie, la valeur de l'expression évaluée dans
la condition d'exécution doit devenir fausse pour sortir de la boucle.
Pour cela, il faut nécessairement que dans le corps de la boucle, la
condition soit modifiée quelque part.
STRUCTURE RÉPÉTITIVE-TANTQUE-
Activité 02:
Ecrire un algorithme qui demande à l’utilisateur un nombre N
compris entre 1 et 3 jusqu’à ce que la réponse convienne. Demander de
ressaisir si son réponse incorrecte et compter le nombre de saisie.S
STRUCTURE RÉPÉTITIVE-TANTQUE-
Correction Activité 02
Algorithme : siaisir_nombre
Variable N, : entier
Début :
Ecrire (ʺEntrez la valeur de N ʺ);
Lire(N);
Tant Que N>3 ou N< 1 Faire
Ecrire (ʺErreur … Entrez à nouveau la valeur de N ʺ);
Lire(N);
Fin Pour
Ecrire (ʺC'est la bonne réponse");
Fin.
STRUCTURE RÉPÉTITIVE
Comment choisir le type de boucle :
Si on peut déterminer le nombre d'itérations avant l'exécution de
la boucle, il est plus naturel d'utiliser la "boucle Pour".
S'il n'est pas possible de connaître le nombre d'itérations avant
l'exécution de la boucle, on fera appel à la "boucle Tant Que"
STRUCTURE RÉPÉTITIVE
Exercice 01:
Écrivez un algorithme qui calcule la factorielle d'un nombre N saisie par
l'utilisateur. (utiliser la boucle Pour et la boucle Tant Que)
Exercice 02:
Ecrire l’algorithme qui vérifie la primalité d’un entier positif N en utilisant
la boucle Tant Que.
Exercice 03:
J’ai replanté en 2013 un sapin de noël qui mesurait 1,20 m. il grandit de 30
cm par an. J’ai décidé de le couper quand il dépasserait 7 m. En quelle année
vais-je couper mon sapin ?
STRUCTURE RÉPÉTITIVE
Exercice 04:
En l’an 2015, le lycée AX compte 2 000 élèves et le lycée BY compte 8 000
élèves. Une étude montre que, chaque année :
10 % des élèves du lycée AX quittent leur lycée pour aller au lycée BY.
15 % des élèves du lycée BY quittent leur lycée pour aller au lycée AX.
Question :
au bout de combien de temps (Année) le lycée AX comptera-t-il plus
d’élèves que le lycée BY ?
STRUCTURE RÉPÉTITIVE
Correction Exercice 01
Algorithme : Factorielle
Variable N, i, Fact: entier
Début :
Ecrire (ʺEntrez la valeur de N ");
Lire(N)
Fact1
i1
Tant Que i<=N Faire
FactFact * i
ii + 1
Fin Pour
Ecrire (ʺle factorielle de ",N, "est :ʺ,Fact);
Fin.
STRUCTURE RÉPÉTITIVE
Correction Exercice 02
Algorithme : Nombre_premier
Variable N, i, nb_div: entier
Début :
Ecrire (ʺEntrez la valeur de N ");
Lire(N)
i2
nb_div0
Si N>0 Alors
Tant Que i<N Faire
Si N Mod i=0 Alors
nb_divnb_div +1
FinSi
ii + 1
Fin TantQue
Si nb_div=0 Alors
Ecrire (N," est un nombre premier")
Sinon
Ecrire (N," n'est un nombre premier")
FinSi
Fin SI
Fin.
STRUCTURE RÉPÉTITIVE
Correction Exercice 02
Algorithme : Sapin
Variable annee, taille, Som: entier
Début :
annee2013
taille1,20
Tant Que taille<>7 Faire
anneeannee + 1
tailletaile + 0,30
Fin Pour
Ecrire (ʺl'année où je peux couper le sapin est :ʺ,annee);
Fin.
STRUCTURE RÉPÉTITIVE
Correction Exercice 03
Algorithme : Nombre_eleves_Lycee_AX_BY
Variable nb_AX, nb_BY,nb_temp: réel
Variable annee : entier
Début :
annee2015
nb_AX2000
nb_BY8000
Tant Que nb_AX<nb_BY Faire
nb_temp0,9 nb_AX + 0,15 * nb_BY
nb_BY0,1 nb_AX + 0,85 * nb_BY
nb_AXnb_temp
anneeanne + 1
Fin Pour
Ecrire (ʺLycée AX dépasse lycée BY:ʺ,annee);
Fin.
STRUCTURE RÉPÉTITIVE
Exercice 05:
Ecrire l’algorithme qui permet de saisir un nombre entier et détermine s’il
est parfait. Un nombre est dit parfait s'il est égal à la somme de tous ses
diviseurs.
Par exemple 28 est parfait car 28=1+2+4+7+14.
Exercice 06:
Écrire un algorithme qui affiche les 100 premiers termes d'une suite "Un" définie par :
U0 = 3
Un+1 = Un + 6