Catégorie technique

Introduction à la Programmation
Notes de cours

Cours à destination
du Bloc 1
de Bachelier en techniques infographiques

Dr Ir Caroline DUBOIS Emmanuel De Muelenaere

caroline.dubois@heaj.be emmanuel.demuelenaere@heaj.be

Année académique
2022 – 2023
Introduction à la programmation Notes de cours

Table des matières

0. Bases de l’algorithmique ................................................................................................................. 3
1. Affectation de variables .................................................................................................................. 5
2. Lecture et écriture ......................................................................................................................... 10
3. Structures conditionnelles (tests) ................................................................................................. 13
4. Structures répétitives (boucles) .................................................................................................... 20
5. Des variables particulières : les tableaux ..................................................................................... 30
6. Instructions dans quelques langages ............................................................................................ 37

2
Introduction à la programmation Notes de cours

0. Bases de l’algorithmique
0.1.1 Algorithmes et vie courante
Dans la vie de tous les jours, nous avons déjà tous conçu des algorithmes :
• Indiquer un chemin ;
• Suivre un mode d’emploi ;
• Appliquer une recette ;
• …

Il s’agit de suites d’instructions exécutées par un agent, dans un certain ordre et dans un temps donné,
pour obtenir le résultat souhaité.

0.1.2 Algorithmes, programmes et mathématiques

Algorithme = suite d’instructions qui, une fois exécutée correctement, conduit à un résultat donné en
un temps fini.

Programme = algorithme écrit dans un langage accessible à une machine.

Apprendre l’algorithmique, c’est apprendre à manier la structure logique d’un programme

informatique, indépendamment des particularités de tel ou tel langage.

→ Pour fonctionner, un algorithme doit contenir uniquement des instructions compréhensibles

par celui qui devra l’exécuter.

Qualités requises pour faire de l’algorithmique :

• Intuitif OU entraîné : pour trouver « une recette » qui amène au résultat voulu.
• Méthodique Et rigoureux : pour systématiquement se mettre mentalement à la place de la
machine qui va exécuter les instructions, afin de vérifier si le résultat obtenu est bien celui que
l’on voulait.

0.1.3 Conception
Structure séquentielle d’un algorithme
Un algorithme est une séquence d’instructions qui se suivent.
Ces instructions peuvent être de 4 types :
• Affectation de variables
• Lecture / écriture
• Tests
• Boucles
Un algorithme informatique se ramène donc toujours à la combinaison de
ces quatre petites briques de base.

La démarche de travail de conception d’un programme

3
Introduction à la programmation Notes de cours

La conception d’un algorithme passe par les étapes suivantes :

1. Analyse du problème :
• Préciser le résultat recherché ;
• Identifier les variables ;
• Identifier les structures présentes dans l’algorithme
2. Conception de l’algorithme :
• Déterminer le diagramme de programmation
3. Traduction de l’algorithme dans le langage de programmation utilisé
• Utilisation d’un pseudo-code
4. Vérifications :
• Simuler le fonctionnement du programme pour s’assurer qu’il est cohérent avec le
résultat recherché

Exemple : On veut qu’à l’ouverture de la page Internet un message personnalisé avec notre prénom
nous accueille

Analyse du problème Bon our Superman

Il faut connaître le prénom de l’utilisateur :
le demander + mémoriser dans une variable

Algorithme Pseudo-code

begin
// Déclaration des variables
Str prenom
// Corps de l’algorithme
write : ʺ Quel est votre prénom ? ʺ \n
prenom = read
write : ʺ Bonjour ʺ+ prenom \n
end

En JavaScript

// déclaration des variables

var prenom;
// corps de l'algorithme
prenom = prompt("Quel est votre prénom ?");
alert("Bonjour " + prenom);

0.1.4 Structure d’un algorithme

Un algorithme
• commence par l’instruction : begin ;
• se termine par l’instruction : end. egin

Dans le diagramme de programmation, on utilise le symbole pour marquer le début

et la fin du code. Les relations entre les éléments de l’organigramme sont matérialisées end
par des flèches.

4
 Introduction à la programmation Notes de cours

1. Affectation de variables
1.1 Variables
Une variable est une zone mémoire contenant une valeur que l'on peut modifier, et que l'on référence
en lui donnant un nom.

1.1.1 Nom d’une varia le

• Un nom de variable doit commencer par une lettre (majuscule ou minuscule) ou un « _ »
(Pas un chiffre)
• Un nom de variable peut comporter des lettres, des chiffres et les caractères _ et -
(Pas d’espace ni de caractères accentués ou spéciaux)
• Les noms de variables ne peuvent pas correspondre à des mots du langage (noms réservés –
ex : « if » ; « then » ; « for » …)
Par facilité lors de l’écriture de l’algorithme, il est conseillé de donner aux variables des noms
représentatifs de ce qu'elles sont destinées à contenir.

1.1.2 Type et déclaration des variables

La déclaration des variables permet d’associer un nom, un type et de réserver un espace mémoire (en
fonction du type). On déclare les variables en dé ut d’algorithme afin d’allouer l’espace mémoire
nécessaire.

Variables Type Mot clé Définition Stockage

Numérique Entier Int Nombre sans virgule 4 octets
Réel Float Nombre avec ou sans virgule 4 octets
Texte Caractère simple Char Lettres, symboles, espaces, 1 octet
chiffres …
Chaîne de caractères Str Groupement de caractères, 1 octet par
mots, phrases … caractère
Valeur logique Booléen Bool Vrai ou Faux (0 ou 1) 1 bit

Pour déclarer une variable, il faut indiquer le mot clef relatif au type, suivi begin
du nom de la variable. Il est possible de déclarer plusieurs variables d’un Int age, numero
même type sur une seule ligne en les séparant par des virgules. Str nom, prenom
Bool Flag
…
end

1.1.3 Opérations sur les variables

Variables numériques
Tous les types de calculs peuvent être effectués sur les variables numériques (+, -, *, / , %…)
▪ Génération aléatoire d’une valeur numérique
L’ordinateur peut choisir aléatoirement une valeur numérique à l’aide de la fonction : rand(min, max)
Les valeurs min et max représentent la plage de données dans laquelle l’ordinateur ira chercher la
valeur.

5
 Introduction à la programmation Notes de cours

▪ Rappel sur le modulo

𝑥%𝑦
Le modulo du nombre entier 𝑥 par le nombre entier 𝑦 est le reste de la division euclidienne de 𝑥 par
𝑦.
Que vaut 9 divisé par 2 ?
𝟗 =𝟒∗𝟐+𝟏
Donc : 9 % 2 = 1
Molulo 𝑦 travaille dans la base numérique 𝑦 : symboles {0; 1; 2; … ; 𝑦 − 1}
Molulo 𝑦 permet de définir les multiples de 𝑦 si modulo 𝑦 =0 ;
➔ modulo 2 permet de définir la parité :
o pair : modulo 2 = 0 ;
o impair : modulo 2 = 1.
Variables de texte
On ne peut pas faire de calculs sur les chiffres d’une chaîne de caractères !
• Le symbole « + » entre des chaînes de caractères sert à les concaténer :
ʺNomʺ + ʺPrénomʺ = ʺ NomPrénom ʺ
• Le symbole « * » avec une chaîne de caractères sert à la répéter plusieurs fois :
ʺSalutʺ * 3 = ʺ SalutSalutSalut ʺ
• Calcul de la longueur d’une chaîne de caractère avec l’instruction : string.length()
• Mettre tous les caractères en minuscules : string.ToLower()
• Mettre tous les caractères en majuscules : string.ToUpper()

1.1.4 Commentaires
Lors de la déclaration des variables, il est fortement conseillé de mettre une description permettant
de savoir quelle information est stockée dans chaque variable.

Cette description se fait dans une zone de commentaires. Les zones de commentaires sont des zones
non exécutées par le programme.
• En fin de ligne : // le commentaire se trouve après
• Dans une zone restreinte ou sur plusieurs lignes : /* le commentaire se trouve entre */

Les programmeurs commentent toujours leurs codes, cela leur permet de communiquer plus
facilement avec une autre personne et également de se rappeler ce que l’on a fait.

1.2 L’instruction d’affectation

=

En pseudo-code, l'instruction d'affectation se note avec le signe « = ».

On peut attribuer à une variable la valeur d’une autre variable (telle quelle ou modifiée).

Variable A gauche du « = » Sym ole d’affectation A droite du « = »

Numérique Valeur numérique
Texte Nom de la variable = Le texte entre ʺ ʺ
Valeur logique TRUE ou FALSE

6
Introduction à la programmation Notes de cours

Ecraser une variable

Affecter une nouvelle valeur dans une variable supprime la valeur précédemment affectée. C’est
comme mettre une nouvelle couche de peinture sur une ancienne couleur. Pour échanger les valeurs
de variables, il faut utiliser une variable supplémentaire pour stocker provisoirement les valeurs avant
qu’elles ne soient écrasées.

1.3 Exemple détaillé

1.3.1 Variables numériques

1. begin Valeurs des variables
2. Int N, M // nombres N M
3. N = 10 10 /
4. M = 2*N 10 20
5. N = -3*N -30 20
6. end -30 20

Ligne 1 : Début de l’algorithme (begin).

Ligne 2 : Déclaration et création de deux variables numériques entières (Int) dans la mémoire de
l’ordinateur (N et M). A ce point, ces variables n’ont pas encore de valeur.
Ligne 3 : La variable N est affectée à la valeur de 10. M n’a tou ours pas de valeur.
Ligne 4 : La variable M est affectée à 2 fois la valeur de M (=2*10=20). La valeur de N n’est pas modifiée
(=10). On ne modifie la valeur que d’une seule variable par ligne.
Ligne 5 : La variable N est affectée à -3 fois la valeur qu’elle avait avant (=-3*10=30). La valeur de M
n’est pas modifiée (=20). Il n’y a pas de retour en arrière, M n’est pas impactée par le
changement de valeur de N.
Ligne 6 : Fin de l’algorithme (end).

1.3.2 Variables de textes

1. begin Valeurs des variables
2. Str Riri, Fifi, Loulou // nombres Riri Fifi Loulou
3. Riri = ʺLoulouʺ Loulou / /
4. Fifi = ʺRiriʺ Loulou Riri /
5. Loulou = Riri Loulou Riri Loulou
6. end Loulou Riri Loulou

Ligne 1 : Début de l’algorithme (begin).

Ligne 2 : Déclaration et création de trois variables de texte (Str) dans la mémoire de l’ordinateur (Riri,
Fifi et Loulou). A ce point, ces variables n’ont pas encore de valeur.

7
Introduction à la programmation Notes de cours

Ligne 3 : Le texte « Loulou » est affecté à la variable Riri. Les autres variables n’ont pas encore de
valeur.
Ligne 4 : Le texte « Riri » est affecté à la variable Fifi. La valeur de la variable Riri n’est pas modifiée et
Loulou n’a toujours pas de valeur.
Ligne 5 : Le contenu de la variable Riri est affecté à la variable Loulou. Le texte « Loulou » se trouve
donc dans la variable Riri. Les autres variables ne sont pas modifiées
Ligne 6 : Fin de l’algorithme (end).

Attention : ʺRiriʺ est une suite de caractères egin

Riri est un nom de variable
Déclara on
1.4 Opérations sOrganigramme de programmation des variables

Opéra ons sur

Dans le diagramme de programmation, on utilise le symbole ▭ pour marquer les les variables
étapes de déclaration et opérations sur les variables.
end
1.5 Exercices

1.5.1 Exercices faits en classe

Ex 1.1. Ces noms de variable sont-ils valides ?
Mario LUIGI25 Princesse-Peach -Toad
156 Donkey Kong Bows3r 0_Koopa
_9856 Yoshï gO0mba

Ex 1.2. Quel est le type des variables suivantes

160 51.5 « Progra » «€» √2 « 25 »

FALSE « Bonjour à tous » 357 Brol 𝜋 «e»

Ex 1.3. Quel type de variable choisir pour contenir les informations suivantes ?
Une moyenne Un prénom Une réponse de type oui ou non
Un compteur Le résultat d’un quotient Un âge
Le résultat d’une division Un prix Une information du type « < »
Une phrase Le résultat d’un produit ou « > » ou « = »
Quelles seront les valeurs des variables après exécution des instructions suivantes ?
/* Déclaration des variables */
Int A, B, C, D // Nombres
Str I, J, K // Mots
Ex 1.4.  Ex 1.5.  Ex 1.6.  Ex 1.7. 
begin begin begin begin
A=1 A=5 I = ʺ 423 ʺ I = ʺ 423 ʺ
B=A+3 B=3 J = ʺ 12 ʺ D = 12
A=3 C=A+B K=I+J K=I+D
end A=2 end end
C=B-A
end

8
Introduction à la programmation Notes de cours

Ex 1.8.  Ex 1.9.  Ex 1.10. 

begin begin Ecrire un algorithme permettant d’échanger les valeurs de deux
A = ʺChienʺ A = ʺChatʺ variables A et B, quelle que soit leur valeur de départ. Vérifier à
B = ʺChatʺ B = ʺChienʺ chaque ligne le contenu des variables.
A=B B=A begin A B
B=A A=B A = ʺChienʺ
end end B = ʺChatʺ

end
Ex 1.11.  Ecrire un algorithme qui permet de transférer le contenu de trois variables A, B et C
de la manière suivante : A dans C, B dans A et C dans B.
Ex 1.12.  Ecrire un algorithme qui calcule la valeur du carré de 12.
Ex 1.13.  Ecrire un algorithme qui calcule la longueur du mot « Avada Kedavra ».
Ex 1.14. Ecrire un algorithme qui calcule le périmètre et l’aire d’un cercle de rayon 5.

1.5.2 Exercices supplémentaires

Quelles seront les valeurs des variables A, B et C après exécution des instructions suivantes ?
Ex 1.15.  Ex 1.16.  /* Déclaration des variables */
begin begin Int A, B, C // Nombres
A=5 A=3
B=A+4 B = 10
A=A+1 C=A+B
B=A-4 B=A+B
end A=C
end
Ex 1.17. Ecrire un algorithme qui met en majuscule toutes les lettres du mot « Abracadabra ».
Ex 1.18. Ecrire un algorithme qui calcule le périmètre et l’aire d’un rectangle de largeur 3 et
de longueur 8.
Ex 1.19.  Ecrire un algorithme qui donne le reste de la division entière par 2, du nombre
1563 {Permet de savoir si le nombre choisi est pair (reste = 0) ou impair (reste = 1)}

9
Introduction à la programmation Notes de cours

2. Lecture et écriture
2.1 Les instructions de write et read

2.1.1 Nécessité de dialoguer

Il existe des instructions pour permettre à la machine de dialoguer avec l’utilisateur
• L’utilisateur entre des valeurs au clavier pour qu’elles soient lues et utilisées par le programme
➔ Instruction de « = read »
• Le programme communique des valeurs à l’utilisateur en les écrivant / affichant à l’écran
➔ Instruction de « write : »

2.1.2 L’instruction de lecture (pour le programme)

VAR = read

Dès que le programme rencontre une instruction … = read, l’exécution s’interrompt, attendant la
frappe d’une valeur au clavier. Tout ce qui a été frappé avant la touche Entrée est stocké dans la
variable qui précède l'instruction = read (ici VAR). Et ensuite, immédiatement, la machine exécute
l'instruction suivante.

« = read » est donc une autre manière d'affecter une valeur à une variable.

2.1.3 L’instruction d’écriture (pour le programme)

write : VAR

Dès que le programme rencontre une instruction write : …, le programme affiche du texte à l’écran
(ici, le contenu de la variable VAR). L’instruction \n sera utilisée pour spécifier un retour à la ligne.

Avant de demander une variable, il est très fortement conseillé d’écrire des libellés à l’écran, afin de
prévenir l’utilisateur de ce qu’il doit entrer.

Ecrire plusieurs composants sur une même ligne : regrouper les chaînes de caractères avec « + »

2.2 Exemple détaillé

Programme qui demande son nom et prénom à l’utilisateur, puis qui lui répond « bonjour » suivi de
son prénom et de son nom (exemple : « Bonjour Clark Kent »).
1. begin
2. Str Prenom, NomFamille // variables pour les nom et prénom
3. write : ʺEntrez votre nom de familleʺ \n
4. NomFamille = read
5. write : ʺEntrez votre prénomʺ \n
6. Prenom = read
7. write : ʺBonjour : ʺ+ Prenom +ʺ ʺ+ NomFamille \n
8. end

10
Introduction à la programmation Notes de cours

Ligne 7 : Début de l’algorithme (begin).

Ligne 8 : Déclaration et création de deux variables de texte (Str) dans la mémoire de l’ordinateur
(Prenom et NomFamille). A ce point, ces variables n’ont pas encore de valeur.
Ligne 9 : Affichage à l’écran (write) du texte « Entrez votre nom de famille », puis retour à la ligne (\n).
Ligne 10 : À l’aide du clavier, l’utilisateur introduit la réponse à la question posée par le
programme (=read). Sa réponse s’affiche en temps réel à l’écran. Lorsque l’utilisateur appuie
sur la touche « entrée », la saisie s’arrête et l’ensemble des caractères précédemment
introduits sont stockés dans la variable concernée (NomFamille).
A ce stade, la variable NomFamille contient la valeur introduite par l’utilisateur et la variable
Prenom est toujours vide.
Ligne 11 : Affichage à l’écran (write) du texte « Entrez votre prénom », suivi d’un retour à la ligne
(\n).
Ligne 12 : Pareil que pour la ligne 4, mais pour la variable (Prenom).
La variable Prenom contient la dernière valeur introduite, le contenu de la variable
NomFamille n’est pas modifiée.
Ligne 13 : Affichage à l’écran (write) du texte « Bonjour », suivi (+) du contenu des variables
Penom et NomFamille.
Ligne 14 : Fin de l’algorithme (end).

2.3 Organigramme de programmation egin

Déclara on
Dans le diagramme de programmation, on utilise le symbole ▱ pour les affectations des variables
des variables par l’utilisateur et pour le renvoi des résultats vers l’utilisateur.
A ecta on des
variables par
l u lisateur
2.4 Exercices Opéra ons sur
les variables

2.4.1 Exercices faits en classe Renvoi des

résultats à
l u lisateur
Ex 2.1.  Quel résultat produit l’algorithme suivant ? (Valeur des variables et
affichage écran) end

begin
Int Val, Double // Nombre et le double de ce nombre
write : ʺEntrez une valeurʺ \n
Val = read
Double = Val * 2
write : ʺLe double de cette valeur est : ʺ+ Double \n
end
Ex 2.2.  Ecrire un algorithme qui demande son prénom à l'utilisateur, et qui lui réponde par un
charmant « Bonjour » suivi du prénom. On aura ainsi le dialogue suivant :
Ecran : Entrées utilisateur :
Quel est votre prénom ?
Marie Cunégonde
Bonjour, Marie Cunégonde !
Ex 2.3.  Ecrire un algorithme qui demande un mot à l’utilisateur puis qui affiche les versions
minuscule et majuscule de ce mot.

11
Introduction à la programmation Notes de cours

Ex 2.4.  Ecrire un programme qui demande le prix d’un article et le nombre de cet article ;
puis qui fournit le prix total correspondant. On aura ainsi le dialogue suivant :
Ecran : Entrées utilisateur :
Entrez le prix d’un article : 3.99
Entrez le nombre d’articles : 4
Le prix total est : 15.96
Ex 2.5.  Ecrire un algorithme qui demande à l’utilisateur d’entrer un texte, puis qui calcule et
affiche le nombre de caractères contenus dans ce texte.
Ex 2.6.  Ecrire un programme qui demande un nombre à l’utilisateur, puis qui calcule et
affiche le carré de ce nombre.
Ex 2.7. Ecrire un algorithme qui demande à l’utilisateur la longueur et la largeur des côtés
d’un rectangle. Le programme calcule alors le périmètre et l’aire du rectangle puis affiche
les réponses.

2.4.2 Exercices supplémentaires

Ex 2.8.  Ecrire un programme qui demande son adresse e-mail à l’utilisateur et qui lui réponde
par « Nous vous recontacterons à l’adresse suivante » suivi de l’adresse e-mail.
Ex 2.9.  Ecrire un programme qui calcule et affiche le montant à rembourser à la caisse d'un
supermarché lorsque le client paye en liquide. Pour cela, le caissier entre d'abord le prix de
l'article et puis le montant payé par le client.
Ex 2.10.  Ecrire un algorithme qui demande l’âge de deux personnes puis qui calcule et affiche
leur différence d’âge.
Ex 2.11.  Ecrire un algorithme qui demande le rayon d’un cercle à l’utilisateur, puis qui
calcule et retourne les valeurs du périmètre et de l’aire de ce cercle.
Ex 2.12.  Ecrire un algorithme qui demande un nombre à l’utilisateur, puis qui calcule et
renvoie le reste de la division entière par 2
{Permet de savoir si le nombre choisi est pair (reste = 0) ou impair (reste = 1)}

12
Introduction à la programmation Notes de cours

3. Structures conditionnelles (tests)

3.1 Structure des tests
Un test est une structure qui prévoit, en fonction des situations qui peuvent se présenter, différentes
façons d’agir. Les tests peuvent être vus comme des aiguillages ; ils peuvent se succéder, s’imbriquer,
avoir plus de deux voies…

3.1.1 Forme simple – if

if Test vrai then
Instructions
end if

Le test a une valeur VRAIE ou FAUSSE. Il s’agit soit d’une variable de type booléen, soit d’une condition.
• Si le test est vrai, les instructions entre then et end if sont exécutées, puis l’exécution de
l’algorithme reprend normalement après end if.
• Si le test est faux, les instructions entre then et end if ne sont pas exécutées, puis l’exécution
de l’algorithme reprend normalement après end if.

3.1.2 Forme complète -if / else

if Test vrai then
Instructions 1
else
Instructions 2
end if

• Si le test est vrai, les instructions entre then et else sont exécutées, celles entre else et end if ne
sont pas exécutées, puis l’exécution de l’algorithme reprend normalement après end if.
• Si le test est faux, les instructions entre then et else ne sont pas exécutées, celles entre else et
end if sont exécutées, puis l’exécution de l’algorithme reprend normalement après end if.

3.1.3 Tests à plusieurs possibilités – if / else if / else

Il est parfois nécessaire que le test propose plus de possibilités. Dans ces cas, on utilise le mot clé else
if. Cette instruction correspond à
• else : si la condition précédente n’a pas été validée ;
• if : alors si cette nouvelle condition est validée,
• then : alors on exécute les instructions suivantes.
Il s’agit alors d’un seul loc de test, conclu par un seul end if.
if Expression 1 vraie then
Instructions 1
else if Expression 2 vraie then
Instructions 2
else
Instructions 3
end if

13
Introduction à la programmation Notes de cours

Dans une structure conditionnelle, seuls les mots clés de la forme simple sont obligatoires.
• Il peut y avoir autant de else if que nécessaire (ou aucun) ;
• S’il y a un else, il est unique et représente obligatoirement la dernière possibilité.

3.2 Conditions

3.2.1 Conditions simples

Une condition est une comparaison, composée de trois éléments (1) une valeur, (2) un opérateur de
comparaison, (3) une autre valeur ; dont les deux valeurs doivent être de même type.
Attention : les valeurs NE doivent PAS être mises avec leurs unités.

Les opérateurs de comparaison sont :

• == égal à… ( ! double « = » pour différencier de l’affectation ! )
• ≠ différent de…
• < strictement plus petit que…
• > strictement plus grand que…
• ≤ plus petit ou égal à…
• ≥ plus grand ou égal à…

Ces opérateurs de comparaison peuvent également s’appliquer aux lettres :

a< <c<…<x<y<z

3.2.2 Conditions composées

Quand les conditions sont composées, il faut impérativement les scinder en plusieurs conditions
simples liées entre elles par des opérateurs logiques.
Opérateur logique (voir cours de math)
ET ( && ) : Pour que « Condition1 ET Condition2 » soit VRAI, il faut que :
« Condition1 » soit VRAI et que « Condition2 » VRAI ➔ les 2 doivent être vraies
𝑥>5
ET 𝑥 ≤ 5 𝑒𝑡 𝑥 > 8
𝑥≤8

OU (||) : Pour que « Condition1 OU Condition2 » soit VRAI, il faut que :

« Condition1 » VRAI et / ou que « Condition2 » VRAI ➔ au moins une des 2 doit être vraie
𝑥≤5
OU 𝑥 ≤ 5 𝑜𝑢 𝑥 > 8
𝑥>8

Non ( ! ) : Si « Condition1 » est VRAI alors « NON Condition1 » est FAUX et vice versa
𝑥 > 5 𝒆𝒕 𝑥 ≤ 8 𝑥 ≤ 5 𝒐𝒖 𝑥 > 8
La négation d’un ET devient OU et la négation d’un OU devient ET (lois de De Morgan).
Attention : ne pas formuler une condition qui ne pourra jamais être vraie, ou jamais être fausse
𝑥≤5 𝑥>5
ET OU
𝑥>8 𝑥≤8

Jamais vrai Toujours vrai

14
Introduction à la programmation Notes de cours

3.3 Exemple détaillé

Programme qui demande sa note à un étudiant et qui lui renvoie son grade en fonction de celle-ci

1. begin
2. Int Note // Note de l’examen de progra
3. write : ʺEntrez la note de votre examen de programmation :ʺ \n
4. Note = read
5. if Note < 0 || Note > 20 then
6. write : ʺNote non valideʺ \n
7. else if Note ≥ 16 then
8. write : ʺVous avez obtenu les félicitations !“\n
9. else if Note ≥ 10 then
10. write : ʺVous avez réussi en programmation !“\n
11. else
12. write : ʺVous avez échouez en programmationʺ
13. end if
14. end

Ligne 1 : Début de l’algorithme (begin).

Ligne 2 : Déclaration et création d’une variable numérique entière (Int) dans la mémoire de
l’ordinateur (Note). A ce point, cette variable n’a pas encore de valeur.
Ligne 3 : Affichage à l’écran (write) du texte « Entrez la note de votre examen de programmation : »,
suivi d’un retour à la ligne (\n).
Ligne 4 : À l’aide du clavier, l’utilisateur introduit la valeur demandée par le programme (=read). Sa
réponse s’affiche en temps réel à l’écran. Lorsque l’utilisateur appuie sur la touche « entrée »,
la saisie s’arrête et l’ensemble des caractères précédemment introduits sont stockés dans la
variable concernée (Note).
A ce stade, la variable Note contient la valeur introduite par l’utilisateur et elle ne sera plus
modifiée dans la suite de l’algorithme.
Ligne 5 : Début de la structure conditionnelle (If). On regroupe en une fois tous les cas où la Note
n’est pas valide, à savoir plus petite que 0 ou plus grand que 20. Cette condition est écrite sous
forme composée. Utiliser les limites du domaine comme 1ère condition permet de simplifier les
conditions suivantes
Ligne 6 : Cette instruction est exécutée ssi la condition de la ligne 5 est vérifiée. Dans ce cas, le
programme affiche (write) que la note n’est pas valide. Les conditions suivantes ne sont alors
pas testées et le programme reprend son exécution après le end if (ligne 20).
Ligne 7 : Si la condition de la ligne 5 est fausse, on teste une nouvelle condition (else if) correspondant
au cas des félicitations. Il s’agit des notes comprises entre 16 et 20, mais une condition simple
est suffisante. On se contente de tester qu’elle est supérieure à 16, il n’est pas nécessaire de
tester qu’elle doit être inférieure à 20. En effet, si ce n’était pas le cas, alors la condition de la
ligne 5 aurait été vraie, et le programme aurait exécuté la ligne 6, sans vérifier les conditions
suivantes.
Ligne 8 : Instruction exécutée ssi la condition de la ligne 7 est vérifiée. Dans ce cas, le programme
affiche (write) le grade correspondant (les félicitations). Les conditions suivantes ne sont alors
pas testées et le programme reprend son exécution après le end if.
Ligne 9 : Si les conditions précédentes sont toutes fausses, une nouvelle condition est testée (else if).
A cet endroit de l’algorithme, la note ne sera amais plus grande que 16. Il suffit donc de tester
qu’elle est supérieure à 10 pour voir s’il s’agit d‘une réussite.

15
Introduction à la programmation Notes de cours

Ligne 10 : Instruction exécutée ssi la condition de la ligne 9 est vérifiée. Dans ce cas, le
programme affiche (write) le grade correspondant (réussite). Les conditions suivantes ne sont
alors pas testées et le programme reprend son exécution après le end if.
Ligne 11 : Si toutes les conditions précédentes sont fausses, alors on arrive dans le else. Il
représente la plage des valeurs qui n’a pas encore été testée, à savoir celles comprises entre
0 et 10.
Ligne 12 : Instruction exécutée ssi toutes les autres conditions sont fausses. Dans ce cas, le
programme affiche (write) la mention liée à cette dernière plage, qu’il s’agit d’un échec.
Ligne 13 : Fin de la structure conditionnelle (end if).
Ligne 14 : Fin de l’algorithme (end). egin

Déclara on
3.4 Organigramme de programmation des variables

Ini alisa on des

variables par
Dans le diagramme de programmation, on utilise le symbole ⃟ l u lisateur

pour marquer les conditions. Les conditions renvoient des valeurs if

logiques vraies ou fausses, desquelles peuvent découler plusieurs False Condi on
True
chemins possibles dans l’algorithme. Opéra ons sur Opéra ons sur
les variables les variables
end if

Renvoi des
3.5 Exercices résultats à
l u lisateur

end
3.5.1 Exercices faits en classe
Ex 3.1.  Écrire un programme qui calcule le quotient de deux nombres a et b donnés par
l’utilisateur : b/a.
Ex 3.2.  Ecrire un algorithme qui demande son âge à l’utilisateur. S’il n’a pas encore 12 ans, le
programme répond qu’il paye le tarif enfant, sinon qu’il paye le tarif adulte.
Ex 3.3.  Ecrire un algorithme qui demande la capitale du Brésil à l’utilisateur. S’il entre la bonne
réponse « Brasilia », le programme l’informe qu’il a gagné, sinon qu’il a perdu.
Ex 3.4.  Ecrire un algorithme qui demande 2 mots à l’utilisateur et qui retourne lequel des deux
est le plus long ainsi que celui qui est le 1er dans l’ordre alphabétique.
Ex 3.5.  Ecrire un algorithme qui demande une lettre comprise entre h (exclu) et x (inclus), le
programme valide si la lettre est bien rentrée, sinon il retourne un message d’erreur.
Ex 3.6.  Ecrire un algorithme qui demande un nombre plus petit (inclus) que 4, ou plus grand
(exclu) que 12, le programme valide si le nombre est bien rentré, sinon il retourne un
message d’erreur.
Ex 3.7.  Ecrire un algorithme qui demande un nombre qui vérifie l’inverse de la condition
suivante : Plus grand que 5 (exclu) et plus petit (inclus) que 8. Le programme valide si le
nombre est bien rentré, sinon il retourne un message d’erreur.
Ex 3.8.  Compléter les « write » en fonction du résultat de la condition. Pour ce faire,
Remplir le tableau ci-dessous avec vrai/faux dans chaque case; puis calculer la valeur de
m*n.

16
Introduction à la programmation Notes de cours

begin
Int m, n // Nombres
write : ʺEntrez deux nombres :ʺ \n
m = read
n = read
if (m > 0 && n > 0) || (m < 0 && n < 0) then
write : ʺ ʺ \n
else
write : ʺ ʺ \n
end if
end

m n (m > 0 && n > 0) || (m < 0 && n < 0) if/else m*n

2 3
2 -3
-2 3
-2 -3

Ex 3.9.  Ecrire un algorithme qui demande une lettre à l’utilisateur. Si c’est une consonne, le
programme écrit la couleur « rouge », si c’est une voyelle, il écrit la couleur « vert ».
Ex 3.10.  Ecrire un algorithme qui demande un nombre à l’utilisateur, et l’informe ensuite si
ce nombre est positif, négatif ou nul.
Ex 3.11.  Un radar sur une autoroute permet de mesurer la vitesse des véhicules. On
demande d'écrire un programme qui, à partir de la vitesse observée, affiche le montant de
l'amende.
 Pas d’amende en dessous de 120 km/h,
 L’amende est de 100€ si la vitesse est entre ]120 et 140 km/h],
 L’amende est de 300€ si la vitesse est supérieure à 140 km/h.
Ex 3.12.  Compléter les conditions de l’algorithme suivant de manière optimisée. Tester le
code pour les températures suivantes: 4; -18; 100; 0; 180
(on considère qu’à 0° c’est de la glace et à 100° de la vapeur)
begin Cdt: répondre Vrai, Faux ou Non testé
Int Temp // Température de l’eau Instructions: répondre si exécutées
write : ʺEntrez la température de l’eau :ʺ \n
Temp = read 4 -18 100 0 180
if …………………………………………. Cdt1
write : ʺC’est de la glaceʺ \n Instructions
…………………………………………….. Cdt2
write : ʺC’est du liquideʺ \n Instructions
…………………………………………….. Cdt3
write : ʺC’est de la vapeurʺ \n Instructions
end if Cdt: répondre Vrai, Faux ou Non testé
end Instructions: répondre si exécutées

Ex 3.13.  Ecrire un algorithme qui demande à l’utilisateur la longueur et la largeur des côtés
d’un rectangle. Le programme demande également à l’utilisateur s’il veut calculer le
périmètre et s’il veut calculer l’aire du rectangle. Ces informations sont des valeurs logiques
Vrai / Faux. Le programme calcule ce qui est demandé puis affiche la(les) réponse(s)

17
Introduction à la programmation Notes de cours

Ex 3.14.  Ecrire un algorithme qui demande l’âge d’un enfant à l’utilisateur. Ensuite, il
l’informe de sa catégorie : Poussin de 6-7 ans ; Pupille de 8-9 ans ; Minime de 10-11 ans ;
Cadet après 12 ans et Senior après 18 ans.
Ex 3.15.  Ecrire un algorithme qui demande 3 nombres à l’utilisateur, puis indique s’ils ont
été introduits dans un ordre croissant décroissant, ou quelconque.

3.5.2 Exercices supplémentaires

Ex 3.16.  Ecrire un algorithme qui demande son âge à l’utilisateur. S’il a plus de 18 ans, il peut
s’inscrire pour passer son permis de conduire, sinon le programme lui indique combien
d’années il doit encore attendre.
Ex 3.17.  Ecrire un algorithme qui pose une question de votre choix à l’utilisateur. S’il entre la
bonne réponse, le programme l’informe qu’il a gagné, sinon qu’il a perdu.
Ex 3.18.  Ecrire un algorithme qui demande à l’utilisateur de créer un mot de passe et qui lui
indique que le mot de passe est enregistré, s’il fait au moins 8 caractères, ou qu’il n’est pas
valide s’il fait moins de 8 caractères.
Ex 3.19.  Ecrire un algorithme qui demande un mot à l’utilisateur puis qui l’informe s’il est
identique à un mot mystère défini par le programmeur.
Ex 3.20.  Ecrire un algorithme qui demande un nombre à l’utilisateur, et l’informe ensuite si ce
nombre est pair ou impair (zéro est un nombre pair).
Ex 3.21.  Ecrire un algorithme qui demande un nombre à l’utilisateur. Si le nombre est entre 0
et 100, le programme affiche le double de ce nombre à l’écran. Sinon, le programme affiche
le triple.
Ex 3.22.  Ecrire un algorithme qui demande trois noms à l’utilisateur et l’informe ensuite s’ils
sont rangés ou non dans l’ordre alphabétique.
Ex 3.23.  Comme dit le poème d’Arthur Rimbaud : A noir, E blanc, I rouge, U vert, O bleu :
voyelles. Écrire un programme qui affiche la couleur correspondant à la voyelle introduite
par l'utilisateur.
Ex 3.24.  Écrire un programme qui affiche le salaire d'un employé en fonction du taux horaire
et du nombre d’heures prestées introduites par l’utilisateur. L'employé est rémunéré au
taux horaire normal pour les premières trente-huit heures, puis à une fois et demie le taux
horaire pour les heures supplémentaires.
Ex 3.25.  Les habitants d’un pays paient l’impôt selon les règles suivantes : les hommes de
plus de 20 ans (non compris) paient l’impôt ; les femmes paient l’impôt si elles ont entre 18
et 35 ans (compris) ; les autres ne paient pas d’impôt. Ecrire un programme qui dit si
l’habitant est imposable ou non.
Ex 3.26.  Ecrire un algorithme qui demande une note à l’utilisateur. Si ce nombre est
 plus petit que 0 ou plus grand que 20 (exclus) : la note n’est pas valide ;
 compris entre 0 (inclus) et 10 (exclu) : c’est un échec ;
 compris entre 10 et 20 (inclus) : c’est une réussite.
Tester le code pour les notes suivantes: 3 ; -8 ; 20 ; 22 ; 0 ; 17 ; 10

Cdt: répondre Vrai, Faux ou Non testé

Instructions: répondre si exécutées

18
Introduction à la programmation Notes de cours

3 -8 20 22 0 17 10
Cdt1
Instructions
Cdt2
Instructions
Cdt3
Instructions

Ex 3.27. Ecrire un programme qui demande à un utilisateur d’entrer sa vitesse en

agglomération. Il lui affiche alors s’il doit payer une amende et, si c’est le cas, le montant de
celle-ci :
 Pas d’amende en dessous de 50 km/h,
 Excès de vitesse usqu’à 10 km/h, l’amende est de 53€,
 Excès de vitesse de plus de 10 km/h, l’amende est de 53€ + 11€ pour chaque km/h
supplémentaire,
 Excès de vitesse de plus de 30 km/h, l’amende est décidée par le procureur du roi
(tribunal)
Ex 3.28.  Ecrire un algorithme qui demande un mot à l’utilisateur et qui lui demande
également s’il veut que ce mot soit écrit en minuscule ou en ma uscule, puis qui affiche le
mot selon le choix de l’utilisateur.
Ex 3.29.  Ecrire un algorithme qui demande deux nombres à l’utilisateur et l’informe
ensuite si leur produit est négatif, positif ou nul.
Attention : on ne doit pas calculer le produit des deux nombres.
Ex 3.30. Ecrire un algorithme qui, selon les caractéristiques d’un profil, accepte de prendre
en considération sa candidature pour un poste :
 Si le candidat est âgé de moins de 30 ans et que son expérience ne dépasse pas 3
ans ou si le salaire qu’il demande est inférieur à 10000 alors le programme doit
afficher (‘Votre candidature sera prise en compte’).
 Sinon il affiche (‘Nous sommes désolés mais votre candidature n'est pas valable
pour ce poste’)
Ex 3.31.  Ecrire un programme qui demande à un utilisateur d’entrer sa vitesse sur
autoroute et son taux d’alcoolémie mesuré lors du contrôle routier. Il lui affiche alors la
sanction encourue :
 Pas de sanction : si pas d’excès de vitesse et alcoolémie inférieure à 0.5% ;
 100 € : si excès inférieur à 20km/h et alcoolémie inférieure à 0.5% ;
 450 € : si excès supérieur à 20km/h avec une alcoolémie inférieure à 0.5%, ou s’il n’y
a pas d’excès de vitesse, mais une alcoolémie entre 0.5 et 1.6% ;
 Déchéance du permis de conduire : si le taux d’alcool est supérieur à 1.6%

19
Introduction à la programmation Notes de cours

4. Structures répétitives (boucles)

4.1 Structure des boucles

4.1.1 Utilité des boucles

Actions répétitives
Si on veut que le programme répète la même action « un certain » nombre de fois :
• Soit on réécrit autant de fois que nécessaire les mêmes lignes de code ;
• Soit on utilise une boucle.

Le nombre de passages dans la boucle peut être :

• Soit tant qu’un évènement est VRAI : Boucle « while »
• Soit prédéterminé : Boucle avec compteur ; boucle « for »

4.1.2 Boucle à évènement

Boucle while pré-test
Boucle while : On fait la boucle tant que l’expression est vraie,
• VRAIE : On rentre dans la boucle : Condition d’entrée → while
• FAUSSE : On arrête la boucle : Condition de sortie (Enoncé)

Dans une structure pré-test, la condition de boucle se situe en début de boucle. Si, lors du premier
passage, la condition est fausse, on n’entre pas dans la boucle et les instructions qui y sont relatives
ne sont pas exécutées.

while Expression vraie

Instructions
end while

La condition de la boucle fait intervenir une ou des variables. Pour pouvoir être testées, ces variables
doivent impérativement contenir une valeur. Au préalable, il est donc parfois nécessaire d’initialiser la
variable intervenant dans la condition de boucle.

Initialiser la valeur de la variable VAR, soit :

• Le programmeur met une valeur par défaut. Cette valeur dépend du type de la variable et est
choisie pour que la condition de boucle soit vraie et dès lors → 1er passage « forcé ».
• Exemple : VAR = « X » ; VAR=1 ; VAR=TRUE
• Le programme demande une 1ère valeur à l’utilisateur avant la boucle. Dans ce cas, on ne passe pas
nécessairement dans la boucle
• VAR = read

20
Introduction à la programmation Notes de cours

Condition d’entrée de la boucle

Les conditions d’entrée des boucles se construisent comme les conditions des structures
conditionnelles. Il s’agit généralement d’une comparaison à l’aide d’un opérateur de comparaison (=,
≠, <, >, ≤, ≥) entre deux valeurs de même type. Elles peuvent également être liées par des opérateurs
logiques pour former des conditions composées.
Attention à l’écriture de la condition de sortie. Si elle est mal construite, il se peut :
• Qu’on ne sorte jamais de la boucle : boucle infinie
• Qu’on n’entre amais dans la boucle : boucle impossible

Association de structures
Des structures peuvent être imbriquées ou successives mais JAMAIS croisées !

while while while

… if if
end while … …
if end if end while
… end while end if
end if

4.2 Drapeaux
Utilisation d’une variable booléenne comme « Flag » ; le
flag est un petit drapeau qui reste baissé aussi longtemps
que l’événement attendu ne se produit pas ; et qui se lève
dès que cet événement a lieu.

Un drapeau travaille en 3 étapes :

1. Avant l’entrée dans la boucle, il faut l’initialiser avec une valeur logique (vrai ou faux) ;
2. Lorsque l’évènement est rencontré, change la valeur logique de la variable booléenne ;
3. La valeur finale de la variable booléenne permet de savoir si l’événement a eu lieu ou non. Si elle
est restée à sa valeur initiale, c’est que l’évènement n’a pas eu lieu ; si elle a changé de valeur,
c’est que l’évènement s’est produit.

4.3 Compteurs
Dans une boucle, il est parfois nécessaire de compter des évènements ou le nombre de passages dans
la boucle.

4.3.1 Compteur d’évènement

Un compteur d’évènement travaille en 3 étapes :
1. Avant l’entrée dans la boucle, il faut l’initialiser. Au début, comme l’évènement considéré n’a pas
encore eu lieu, on initialise le compteur à zéro ;
2. A chaque fois que l’évènement considéré est rencontré, on incrémente la valeur du compteur de
la boucle, c.-à-d., on ajoute 1 à sa valeur précédente (i = i + 1 ou i++)
3. La valeur finale du compteur représente le nombre total de fois que l’évènement a eu lieu.

21
Introduction à la programmation Notes de cours

4.3.2 Compteur de boucle

Lorsque le nombre de passages dans la boucle est prédéterminé, on sait à l’avance combien de
passages dans la boucle doivent être effectués. On utilise alors un compteur de boucle.

Le compteur de boucle se gère en trois étapes :

1. Initialisation du compteur avant d’entrer dans la boucle ;
2. Incrémentation du compteur à chaque passage de boucle (i = i + 1 ou i++) ;
3. Condition d’entrée dans la boucle liée à la valeur du compteur.

Boucle « for »
La structure « for … end for » est un cas particulier de while où l’on peut dénombrer à l’avance le
nombre de tours de boucles nécessaires. La triple gestion du compteur se fait en une seule ligne :

for compteur from valeur initiale to valeur finale by step of progression

Instructions
end for

Progression du compteur
Dans la boucle for, la progression du compteur est laissée à votre libre disposition.
• Dans la plupart des cas, on a besoin d’une variable qui augmente de 1 à chaque tour de boucle.
• Il est également possible d’avoir une progression plus spéciale, de 2 en 2, ou de 3 en 3, ou en
arrière, de –1 en –1, ou de –10 en –10.
Il suffit de le préciser la valeur du step à l’instruction de la boucle.

4.4 Exemples détaillés

4.4.1 Boucle while

Ecrire un programme qui demande à un étudiant d’entrer la note de son examen de programmation
tant qu’elle n’est pas valide. Cette note doit être comprise entre 0 et 20 inclus.
1. begin
2. Int Note // note
3. Note = -1 ou write : ʺEntrez la note de votre examen de programmation :ʺ \n
Note = read
4. while Note < 0 || Note > 20 then
5. write : ʺEntrez la note de votre examen de programmation :ʺ \n
6. Note = read
7. end while
8. write : Note valideʺ \n
9. end

22
Introduction à la programmation Notes de cours

Ligne 1 : Début de l’algorithme (begin).

Ligne 2 : Déclaration et création d’une variable numérique entière (Int) dans la mémoire de
l’ordinateur (Note). A ce point, cette variable n’a pas encore de valeur.
Ligne 3 : Initialisation par défaut de la variable Note ; le programmeur choisit une valeur telle que la
condition de boucle sera fausse, forçant un premier passage dans la boucle. Pour initialiser
Note, il faut prendre une valeur qui N’est Pas comprise entre 0 et 20 ; par exemple -1.
 Une autre possibilité d’initialisation de la variable est par une valeur utilisateur. Dans ce cas,
on prévient l’utilisateur avec un affichage à l’écran (write) qu’on attend une valeur de sa part,
puis on récupère cette valeur que l’on stocke dans la variable (= read). Dans ce cas, on
n’entrera pas dans la boucle si la 1ère valeur est correcte.
Dans le cas d’une initialisation utilisateur, il faut penser à prendre cette valeur en compte
pour les éventuels calculs ultérieurs.
Ligne 4 : Début de la boucle (while), on teste la valeur comprise dans la variable. Si la condition est
vérifiée (que la note est entre 0 et 20), on rentre dans la boucle et on exécute les instructions
qui y sont liées. Sinon, on n’entre pas dans la boucle et on continue l’exécution après la fin de
la boucle end while (ligne 7).
Ligne 5 : Affichage à l’écran (write) pour demander à l’utilisateur d’introduire une valeur.
Ligne 6 : À l’aide du clavier, l’utilisateur introduit la valeur demandée par le programme (= read). La
valeur de la variable Note change à chaque tour de boucle.
Ligne 7 : Fin de la structure répétitive (end while). Le programme remonde au début de la boucle
(ligne 4) pour voir s’il y a lieu de refaire la boucle ou pas.
Ligne 8 : Affichage écran (write) pour prévenir l’utilisateur que la note est valide.
Ligne 9 : Fin de l’algorithme (end).

4.4.2 Boucle for

Ecrire un programme qui demande à un étudiant d’entrer les 3 notes de ses travaux du cours de
laboratoire de programmation. Le programme calcule alors la note globale obtenue en faisant une
moyenne arithmétique des notes des travaux.
1. begin
2. Int Note, i, Som // note, compteur, somme
3. Som = 0
4. for i from 1 to 3 by step of 1
5. write : ʺEntrez la note de votre travail ʺ + i + ʺ du cours de labo progra :ʺ \n
6. Note = read
7. Som = Som + Note
8. end for
9. write : ʺVotre note globale en labo progra est de : ʺ + Som/i \n
10. end

Ligne 1 : Début de l’algorithme (begin).

Ligne 2 : Déclaration et création de 3 variables numériques entières (Int) dans la mémoire de
l’ordinateur, pour accueillir la note de l’étudiant (Note), la somme de ses notes (Som) et aussi
un compteur (i). A ce point, aucune variable n’a encore de valeur.
Ligne 3 : Initialisation de la variable Som à la valeur de 0, car avant d’a outer quelque chose, la somme
est nulle.
Ligne 4 : Début de la boucle (for). Cette boucle sera exécutée 3 fois, pour les valeurs du compteur i
allant de 1 à 3 en augmentant de 1 à chaque tour (i vaut successivement : 1, 2 et 3).
Ligne 5 : Affichage à l’écran (write) pour demander à l’utilisateur d’introduire une valeur.
Ligne 6 : À l’aide du clavier, l’utilisateur introduit la valeur demandée par le programme (= read). La
valeur de la variable Note change à chaque tour de boucle.

23
Introduction à la programmation Notes de cours

Ligne 7 : A chaque tour de boucle, on ajoute la nouvelle note introduite à la somme des notes
précédentes.
Ligne 8 : Fin de la structure répétitive (end for). Le programme remonde au début de la boucle (ligne
4) si la boucle n’a pas encore été faite le nombre de fois souhaitées.
Ligne 9 : Affichage écran (write) du résultat calculé. La moyenne est obtenue en divisant la somme
des notes contenue dans la variable Som, par le nombre de valeur (ce qui correspond au
compteur i).
Ligne 10 : Fin de l’algorithme (end).

4.5 Organigramme de programmation

Dans le diagramme de programmation, on utilise le symbole ⃟ pour marquer les conditions. Dans le
cas d’une boucle, à la fin des instructions de celle-ci, le programme revient à la condition de départ et
vérifie si elle est tou ours vraie. Si c’est le cas, il refait une fois la boucle, cependant, si elle est fausse,
il sort de la boucle et continue l’exécution du reste du code.

4.6 Procédés de calcul intervenant souvent dans les boucles

La plupart des calculs sont réalisés directement dans la boucle, en parallèle de l’encodage des valeurs.

4.6.1 La somme
Pour faire l’addition de nombre a outés à chaque passage dans la boucle, il faut 2 variables : une
variable pour stocker le dernier nombre introduit et une variable pour stocker la somme.
1. Avant la boucle, initialiser la variable somme à 0, car rien n’a encore été comptabilisé à ce
stade ;
2. Dans la boucle, chaque nouvelle valeur à comptabiliser est ajoutée à la somme précédente. De
cette manière, la somme est tenue à our au fur et à mesure de l’encodage :
somme = somme + nouvelle valeur
3. La valeur finale de la somme représente le total des nombres qui ont été ajoutés.

24
Introduction à la programmation Notes de cours

4.6.2 La moyenne
La moyenne d’une série de nombre se calcule en divisant leur somme totale par le nombre de valeurs
𝑁 +𝑁 +⋯+𝑁𝑛 𝑠𝑜𝑚𝑚𝑒
qui interviennent dans cette somme. 𝑚𝑜𝑦𝑒𝑛𝑛𝑒 = 1 2𝑛 = 𝑛
Il faut 3 variables : une variable pour stocker le dernier nombre introduit, une variable pour stocker la
somme et un compteur qui totalise le nombre de nombres.
1. Avant la boucle, initialiser les variables somme et compteur à 0, car rien n’a encore été
comptabilisé à ce stade ;
2. Dans la boucle, chaque nouvelle valeur à comptabiliser est ajoutée à la somme précédente et
le compteur est incrémenté. De cette manière, la somme et le compteur sont tenus à jour au
fur et à mesure de l’encodage :
somme = somme + nouvelle valeur
compteur = compteur + 1
3. La valeur finale de la somme représente le total des nombres qui ont été ajoutés.
4. La moyenne se calcule en une fois après la boucle en divisant la somme par le compteur.

4.6.3 Le produit
Pour faire le produit de nombres introduits à chaque passage dans la boucle, il faut 2 variables : une
variable pour stocker le dernier nombre introduit et une variable pour stocker le produit.
1. Avant la boucle, initialiser la variable produit à 1, car c’est le neutre pour la multiplication (ça
signifie que multiplier par 1 ne change pas le résultat), tandis que multiplier par 0 donnera
toujours 0.
2. Dans la boucle, chaque nouvelle valeur à comptabiliser est multipliée au produit précédent.
De cette manière, le produit est tenu à our au fur et à mesure de l’encodage :
produit = produit * nouvelle valeur
3. La valeur finale du produit représente le résultat de la multiplication des nombres qui ont été
introduits.

4.6.4 La recherche d’un maximum

Pour rechercher la plus grande valeur introduite, il faut 2 variables : une variable pour stocker le
dernier nombre introduit et une variable pour stocker la plus grande valeur.
La recherche d’un maximum se fait en augmentant la valeur du maximum à chaque fois qu’une valeur
plus grande est introduite. Le maximum est donc une variable dont la valeur ne pourra faire
qu’augmenter, usqu’à atteindre le maximum global.
1. Avant la boucle, il faut donc initialiser la variable maximum à la plus petite valeur qu’elle puisse
prendre. Si la plage de valeur dans laquelle évolue la variable est connue, on utilise la borne
inférieure de cette plage pour initialiser le maximum. En revanche, si cette limite minimum est
inconnue, il faut initialiser le maximum avec la 1ère valeur utilisateur ;
2. Dans la boucle, à l’aide d’une structure conditionnelle, on compare chaque nouvelle valeur
introduite à la valeur du maximum. Si cette nouvelle valeur est plus grande, le maximum prend
cette nouvelle valeur. Si ça n’est pas le cas, le maximum ne change pas.
3. La valeur finale du maximum représente la plus grande valeur qui ait été introduite.

4.6.5 La recherche d’un minimum

Pour rechercher la plus petite valeur introduite, on travaille de la même manière que pour le
maximum, à 2 différences près :
• Le minimum est initialisé à la plus grande valeur possible (ou à la 1ère valeur utilisateur), puis
diminuera tout au long de la saisie ;

25
 Introduction à la programmation Notes de cours

• Si la nouvelle valeur est plus petite que le minimum, alors le minimum prend cette nouvelle
valeur.
4.7 Exercices

4.7.1 Exercices faits en classe

Boucle while
Ex 4.1.  Ecrire un programme qui demande à l’utilisateur s’il veut un café. Si la réponse est « O »
(oui), le programme indique que le café est en cours de préparation et si la réponse est « N »
(non), le programme indique qu’il n’y a pas de café à préparer. Si l’utilisateur introduit autre
chose que « O » ou « N », le programme lui indique qu’il s’agit d’une saisie erronée et il lui
demande une nouvelle valeur.
Ex 4.2.  Ecrire un algorithme qui demande à l’utilisateur un nombre compris entre 10 et 20 usqu’à
ce que la réponse convienne.
Ex 4.3.  Que fait ce programme? Pour vous aider, tester les conditions et les valeurs des
variables pour les mots successivement introduits: Astérix, stop, Obélix, attention, Idéfix,
stop, Panoramix, attention, stop
begin
Str A, B // Mots
A= ʺ a ʺ
B= ʺ b ʺ
while A != ʺstopʺ || B != ʺattentionʺ
B=A
write : ʺEntrez un mot :ʺ \n
A = read
end while
end
n° A B A != ʺstopʺ || B != ʺattentionʺ → Entre dans la boucle?
1
2
3
4
5
6
7
8
9
10

▪ Somme, moyenne, produit, plus petit et plus grand

Ex 4.4.  Ecrire un algorithme qui demande des nombres à l’utilisateur et qui s’arrête quand on a
introduit 0. Le programme affiche ensuite la somme des nombres qui ont été introduits.
Ex 4.5.  Ecrire un programme qui demande à l'utilisateur d'introduire des nombres (positifs ou
négatifs). Le programme s'arrête lorsque l'utilisateur introduit 0 et affiche la moyenne des
nombres strictement positifs introduits.

26
 Introduction à la programmation Notes de cours

Ex 4.6.  Ecrire un algorithme qui demande successivement des nombres positifs à l’utilisateur,
et qui lui dise ensuite quel est le plus grand parmi ces nombres ; la saisie s’arrête lorsque
l’utilisateur entre un zéro.
▪ Compteur
Ex 4.7.  Ecrire un algorithme qui demande à l’utilisateur d’entrer des nombres. La saisie s’arrête
quand l’utilisateur entre « 0 ». Le programme indique alors combien de nombres positifs et
négatifs ont été introduits.
Ex 4.8.  Ecrire un programme qui demande des mots à l'utilisateur. On s'arrête lorsque on
introduit « stop », et on affiche le nombre de fois que l'on a introduit « attention ».
Ex 4.9.  Ecrire un algorithme qui demande des nombres à l’utilisateur. Le programme
s’arrête lorsque l’utilisateur introduit trois fois successivement 0. Le programme affiche alors
le nombre de nombres non nuls introduits par l’utilisateur et leur produit.
▪ Drapeau
Ex 4.10.  Ecrire un algorithme qui demande une lettre usqu’à ce que l’utilisateur introduise la
lettre « z ». Le programme annonce à l’utilisateur si des voyelles ont été introduites.
Ex 4.11.  Ecrire un algorithme qui demande des mots. S’arrêter lorsque on a introduit les
mots "stop" et "attention", dans n'importe quel ordre.
Ex 4.12.  Ecrire un algorithme qui demande des mots. S’arrêter à la lecture de stop, pour
autant que "attention" ait été lu auparavant.
Boucle for
Ex 4.13.  Ecrire un algorithme qui demande un nombre à l’utilisateur, et qui affiche le décompte
depuis ce nombre jusque 0.
Ex 4.14.  Ecrire un algorithme qui demande un nombre de départ, et qui affiche ensuite les dix
nombres suivants.
Ex 4.15.  Ecrire un algorithme qui demande un nombre de départ, et qui ensuite écrit la table de
multiplication de ce nombre.
▪ Somme, moyenne, produit, plus petit et plus grand
Ex 4.16.  Ecrire un algorithme qui demande un nombre de départ, et qui calcule la somme des
entiers usqu’à ce nombre.
Ex 4.17.  Que fait l’algorithme ? Compléter les affichages finaux. Tester le contenu des variables
pour les 5 premiers mots introduits: IronMan, SpiderMan, Thor, CaptainAmerica,
BlackWidow
begin
Str Mot, mot1, mot2
Int i, c1, c2
write : ʺEntrez un mot ʺ \n
Mot = read
c1 = string.length(Mot)
mot1 = Mot
c2 = string.length(Mot)
mot2 = Mot
for i from 2 to 100 by step of 1
write : ʺEntrez un mot ʺ \n
Mot = read
if string.length(Mot) > c1 then
c1 = string.length(Mot)

27
 Introduction à la programmation Notes de cours

mot1 = Mot
else if string.length(Mot) < c2 then
c2 = string.length(Mot)
mot2 = Mot
end if
endfor
write : ʺ …………………………………………………………………………………………………………………..ʺ + mot1 \n
write : ʺ …………………………………………………………………………………………………………………..ʺ + mo2 \n
end

i Mot c1 mot1 c2 mot2

1er
2ème
3ème
4ème
5ème

Ex 4.18.  Ecrire un algorithme qui demande successivement 20 nombres à l’utilisateur, et qui
lui dit ensuite quel était le plus grand parmi ces 20 nombres, ainsi que la position où il a été
saisi.
Ex 4.19.  A la naissance de Marie, son grand-père lui ouvre un compte bancaire. Dès sa
naissance et à chaque anniversaire, il lui verse 100 €, auxquels il a oute le double de son âge
(Ex : pour ses deux ans : + 104 €). Ecrire un algorithme qui permette de déterminer quelle
somme totale recevra Marie pour ses 18 ans.

4.7.2 Exercices supplémentaires

Boucle while
Ex 4.20.  Ecrire un algorithme qui demande à l’utilisateur une lettre comprise entre « e » et « m »
inclus ; usqu’à ce que la réponse convienne.
Ex 4.21.  Ecrire un algorithme qui demande à l’utilisateur un nombre compris entre 10 et 20
usqu’à ce que la réponse convienne. Si la réponse est supérieure à 20, on fera apparaître un
message : « Plus petit ! », et inversement, « Plus grand ! » si le nombre est inférieur à 10.
Ex 4.22.  Ecrire un algorithme qui demande un nombre à l’utilisateur usqu’à ce que qu’il entre
un nombre strictement positif. Le programme affiche alors l’ensemble des diviseurs de ce
nombre
▪ Somme, moyenne, produit, plus petit et plus grand
Ex 4.23.  Lire la suite des prix des achats d’un client. La saisie s’arrête lorsque l’utilisateur entre
un zéro. Calculer et afficher la somme qu’il doit.
▪ Compteur
Ex 4.24.  Ecrire un algorithme qui demande à l’utilisateur d’entrer des lettres. La saisie s’arrête
quand l’utilisateur entre le mot "stop". Le programme indique alors combien de fois la lettre
"e" a été introduite.
Ex 4.25.  Ecrire un algorithme qui demande à l’utilisateur quelle lettre il souhaite compter, puis
l’utilisateur entre des lettres. La saisie s’arrête quand l’utilisateur entre le mot « stop ». Le
programme indique alors combien de fois la lettre choisie a été introduite.

28
 Introduction à la programmation Notes de cours

Ex 4.26.  Ecrire un algorithme qui demande à l’utilisateur d’entrer des nombres. La saisie
s’arrête quand l’utilisateur a entré deux fois « 0 » (n’importe quand). Le programme affiche
alors le carré de la somme des nombres positifs.
▪ Drapeau
Ex 4.27. Ecrire un algorithme qui demande mots à l’utilisateur usqu’à ce qu’il entre le mot « stop ».
Le programme lui indique si au moins un mot de plus de 10 lettres ont été introduits.
Boucle for
▪ Somme, moyenne, produit, plus petit et plus grand
Ex 4.28.  Ecrire un algorithme qui demande un nombre de départ, et qui calcule sa factorielle.
Ex 4.29.  Ecrire un algorithme qui demande 10 mots à l’utilisateur, puis qui lui dit le nombre total
de caractères qui ont été introduits
Ex 4.30.  Ecrire un algorithme qui demande 5 nombres à l’utilisateur, puis qui calcule et affiche
le produit des nombre paires.
▪ Drapeau
Ex 4.31.  Si N est un nombre positif donné par l’utilisateur, le programme choisit un nombre
secret entre 1 et N, et l’utilisateur doit le deviner en un maximum de 15 essais. Le programme
doit signaler au joueur si le nombre à trouver est plus petit ou plus grand que celui généré.
Lorsque l’utilisateur a trouvé, l’ordinateur donne le nombre de coups oués ou lui signale qu’il
a perdu.
▪ Boucles imbriquées
Ecran :
Ex 4.32.  Ecrire un algorithme qui dessine un carré de 10 lignes de 10 symboles ##########
« # ». …
##########
Ecran :
Ex 4.33.  Ecrire un algorithme qui dessine un rectangle de 10 lignes de 100 #####… ### … #####
…
symboles « # ». #####… ### … #####
Ecran :
Ex 4.34.  Ecrire un algorithme qui dessine un escalier de 10 lignes #
##
symboles « # ». ###
####
#####
######
#######
########
#########
Ex 4.35.  Ecrire un algorithme qui dessine un damier de N lignes et colonnes ##########
alternant les symboles « + » et « - » (N est une valeur utilisateur).
Attention : l’algorithme doit fonctionner que N soit pair ou impair.
Ex pour N=3 Ex pour N=4
+-+ +-+-
-+- -+-+
+-+ +-+-
-+-+
Ex 4.36.  Ecrire un algorithme qui recherche tous les nombres premiers inférieurs à N, N étant une
valeur introduite par l’utilisateur.
Pour rappel : un nombre premier est un nombre qui a strictement 2 diviseurs distinct, 1 et lui-même.
Par exemple : 2, 3, 5, 7 sont des nombres premiers. 1 n’est pas un nombre premier car il n’a qu’un
diviseur.

29
Introduction à la programmation Notes de cours

5. Des variables particulières :

les tableaux
5.1 Structure des tableaux

5.1.1 Utilité des tableaux

Grands jeux de données
Dans la partie sur les structures conditionnelles, l’encodage de valeurs se fait dans une variable unique,
en écrasant la valeur précédemment introduite. Si on souhaite mémoriser toutes les valeurs
introduites, il faudrait utiliser autant de variables qu’il y a de valeurs à encoder. Cela pose des
problèmes à plusieurs niveaux. Il faudrait :
• connaître à l’avance le nombre de variables nécessaires à l’encodage ;
• que chacune de ces variables ait un nom unique ;
• déclarer et affecter indépendamment chacune d’entre elles ;
• réécrire indépendamment le nom de chaque variable lors de son utilisation.
Cette démarche de travail est irréaliste, dès qu’il y a plus de quelques données à utiliser.

Définition des tableaux

Pour automatiser le travail sur de grands eux de données d’un même type, on utilise un tableau. Il
s’agit d’une structure qui permet de regrouper plusieurs variables en une seule. Le nom du tableau est
unique et se réfère à l’ensemble des données qu’il contient. Pour identifier chaque donnée
séparément, on utilise son numéro dans cette liste de données, c’est l’ indice.

5.1.2 Tableaux à 1 dimension

Les tableaux à une dimension peuvent être visualisé comme une liste de variables structurée selon une
rangée (1 ligne ou 1 colonne).

chat
chien
souris 5 1 -3 24 -18
lapin
tortue

Déclaration des tableaux

Un tableau doit être déclaré en précisant le nombre et le type de valeurs qu’il contiendra.
begin
/* Zone de déclaration des variables */
Tab Float Note[6] // Tableau de 6 nombre réels
Tab Int compt[10] // Tableau de 10 nombres entiers
Tab Str Nom[7] // Tableau de 7 chaînes de caractères
Tab Char Lettre[4] // Tableau de 4 caractères
Tab Bool Flag[8] // Tableau de 8 booléens
…
end

30
 Introduction à la programmation Notes de cours

Les tableaux peuvent contenir des variables de type numériques, caractères, booléens ;
Mais il ne peut y avoir qu’un type de données au sein d’un même tableau.
Le nombre de valeurs est indiqué entre [ ].

Notation
Chaque fois que l’on doit désigner un élément du tableau, on fait figurer le nom du tableau, suivi, entre
parenthèses, de sa position dans le tableau.

▪ Indice
Attention, les indices des tableaux commencent à 0, et non à 1.
Dans un tableau, la valeur d’un indice doit tou ours être :
• Plus grande ou égale à 0 ;
• Un nombre entier (pas de virgule) ;
• Inférieure au nombre d’éléments du tableau :
le plus grand indice = le nombre d’éléments -1.

L’indice d’un élément est différent du contenu de cet élément. Il n’y a AUCUN RAPPORT entre l’indice
i et la valeur T(i) contenue dans la case i du tableau T.

Tableau de 5 chaînes de caractères. Chaque élément du tableau « Note » représente une note
individuelle.
Tab Str T[5]
Indice : i Valeurs du tableau :T(i)
i=0 chat → T(0) = chat
i=1 chien → T(1) = chien
i=2 souris → T(2) = souris
i=3 lapin → T(3) = lapin
i=4 tortue → T(4) = tortue

Pour travailler de manière automatique dans un tableau, son indice est lié au compteur d’une boucle.

5.1.3 Tableaux à 2 dimensions

Organisé en lignes et colonnes, le tableau à deux dimensions permet de stocker plusieurs informations
pour une même entrée

Notation
La taille se donne avec le nombre de lignes [L] puis le nombre de colonnes [C].
Tableau de 5 lignes et 3 colonnes, de valeurs numériques
Int Tab Etu[5][3]
Age Taille Poids Lignes : i
Etudiant1 18 = T(0)(0) 160 = T(0)(1) 58 = T(0)(2) L0  i= 0
Etudiant2 19 = T(1)(0) 185 = T(1)(1) 87 = T(1)(2) L1  i= 1
Etudiant3 18 = T(2)(0) 173 = T(2)(1) 65 = T(2)(2) L2  i= 2
Etudiant4 22 = T(3)(0) 177 = T(3)(1) 92 = T(3)(2) L3  i= 3
Etudiant5 20 = T(4)(0) 168 = T(4)(1) 74 = T(4)(2) L4  i= 4
Colonnes : j C0  j= 0 C1  j= 1 C2  j= 2

Toutes les données du tableau doivent être du même type !

31
Introduction à la programmation Notes de cours

5.2 Exemple détaillé

Ecrire un programme qui demande à l’utilisateur le nombre d’enfants dont il souhaite introduire les
données. L’utilisateur entrera la taille et le poids de chaque enfant et le programme calcule, stocke et
affiche son « indice de masse corporelle » (IMC).

1. begin
2. Int N, i // nombre d’enfants et compteur
3. Tab Float kid[N][3] // Tableau de N enfants et 3 colonnes (taille, poids, IMC)
4. write : ʺCombien d’enfants souhaitez-vous introduire ?ʺ \n
5. N= read
6. for i from 0 to N-1 by step of 1
7. write : ʺIntroduisez la taille (en m) de l’enfant n°ʺ+ i+1 \n
8. kid(i)(0)= read
9. write : ʺIntroduisez le poids (en kg) de l’enfant n°ʺ+ i+1\n
10. 0 kid(i)(1)= read
11. Kid(i)(2)= kid(i)(0)/ kid(i)(1)^2
12. write : ʺSon IMC est de ʺ+ kid(i)(2) \n
13. end for
14. end

Ligne 1 : Début de l’algorithme (begin).

Ligne 2 : Déclaration et création de 2 variables numériques entières (Int) dans la mémoire de
l’ordinateur, pour accueillir le nombre d’enfants (N) et un compteur (i).
Ligne 3 : Déclaration et création d’un tableau de nombres réels (kid). Ce tableau aura autant de lignes
qu’il n’y a d’enfants (N) et trois colonnes pour stocker respectivement la taille, le poids et l’IMC
de chaque enfant.
Ligne 4 : Affichage à l’écran (write) pour demander à l’utilisateur d’introduire le nombre d’enfants.
Ligne 5 : L’information est saisie au clavier (= read) par l’utilisateur, puis stockée dans la variable N.
Ligne 6 : Début de la boucle (for). Cette boucle sera exécutée N fois, pour passer dans chaque case
du tableau. L’indice commence à 0, la Nième case aura donc l’indice (N-1). La boucle sera
effectuée pour les valeurs du compteur i allant de 0 à N-1 en augmentant de 1 à chaque tour
(i vaut successivement : 0, 1, 2, 3, …, N - 2, N - 1). Premier tour de boucle i = 0.
Ligne 7 : Affichage à l’écran (write) pour demander à l’utilisateur d’introduire la taille de l’enfant n°1
(= i + 1 = 0 + 1).
Ligne 8 : L’information est saisie au clavier (= read) par l’utilisateur, puis stockée dans la case (0)(0) :
ligne 0 (1er enfant) et dans la colonne 0 (pour la taille).
Ligne 9 : Affichage à l’écran (write) pour demander à l’utilisateur d’introduire le poids de l’enfant n°1
Ligne 10 : L’information est saisie au clavier (= read) par l’utilisateur, puis stockée dans la case
(0)(1) : ligne 0 (1er enfant) et dans la colonne 1 (pour le poids)
Ligne 11 : Le programme calcule l’IMC et le stocke dans la case (0)(2).
Ligne 12 : Affichage écran (write) du résultat calculé et stocké dans la case (0)(2).
Ligne 13 : Fin de la structure répétitive (end for). Le programme remonde au début de la boucle
(ligne 6). La boucle est recommencée avec la valeur i = 1 ; soit pour le 2ème enfant. Au total, la
boucle sera faite usqu’à ce que i = N-1 ; soit N fois.
Ligne 14 : Fin de l’algorithme (end).

32
 Introduction à la programmation Notes de cours

5.3 Exercices

5.3.1 Exercices faits en classe

Tableaux 1 dimension
Ex 5.1.  Que produit cet algorithme ? Peut-on simplifier cet algorithme avec le même résultat ?
begin
Tab Int N[7] // Tableau de 7 nombres
Int i, k // Compteurs de boucle
N(0) = 1
for i from 1 to 6 by step of 1
N(i) = N(i-1) + 2
end for
for k from 0 to 6 by step of 1
write : N(k)\n
end for
end

Ex 5.2. Ecrire un algorithme qui déclare et remplisse un tableau de 7 valeurs numériques en les
mettant toutes à zéro.
Ex 5.3.  Ecrire un algorithme qui déclare et remplisse un tableau contenant les six voyelles de
l’alphabet latin.
Ex 5.4.  Le programme demande à l'utilisateur d'introduire 50 mots. Puis le programme affiche
le tableau, une fois dans l’ordre d’introduction des mots ; puis dans l’ordre inverse.
Ex 5.5. On a à sa disposition un tableau de 6 mots. Ecrire un algorithme qui inverse l’ordre
des mots dans le tableau ; MAIS sans utiliser de 2ème tableau.
▪ Somme, moyenne, produit, plus petit et plus grand
Ex 5.6.  Ecrire un algorithme qui remplit aléatoirement un tableau de 100 valeurs.
L’algorithme calcule ensuite le plus grand écart entre les nombres de ce tableau (max-min).
Ex 5.7.  Que fait l’algorithme ? Compléter les affichages finaux. Tester le contenu des variables
pour les 7 valeurs introduites: 6 ; 9 ; 16 ; 13 ; 2 ; 19 ; 18.

begin
Tab Int Nb[7]
Int m1, m2, i
m1 = 0
m2 =0
for i from 0 to 6 by step of 1
if Nb(i) > m1 then
m2 = max
m1 = Nb(i)
else if Nb(i) < m1 && Nb(i) > m2 then
m2 = Nb(i)
end if
end for
write : ʺ…………………………………………………………………………………………………………………………….. ʺ+ m2 \n
end

33
 Introduction à la programmation Notes de cours

i Nb(i) m1 m2
Avant la boucle
Tour 1
Tour 2
Tour 3
Tour 4
Tour 5
Tour 6
Tour 7

Ex 5.8.  Ecrire un algorithme qui déclare un tableau de 9 notes (*/20), dont on fait ensuite
saisir les valeurs par l’utilisateur en s’assurant que l’utilisateur entre bien des valeurs entre 0
et 20. Puis le programme calcule et affiche la moyenne des notes, la cote minimale et la cote
maximale.
▪ Drapeau
Ex 5.9.  Soit un tableau de 20 valeurs. L’algorithme fait saisir un nombre au clavier, et informe
l’utilisateur de la présence ou de l’absence de cette valeur dans le tableau.
Ex 5.10.  Soit un tableau de 10 nombres. Détermine-s’il est trié par ordre croissant.

Tableaux 2 dimensions
Ex 5.11.  Ecrire un algorithme qui demande les noms et prénoms des 70 étudiants de la classe.
Les données sont stockées dans un tableau à deux colonnes.
Ecran : Entrées utilisateur :
Etudiant 1
Nom: Potter
Prénom: Harry
Etudiant 2
Nom: Granger
Prénom: Hermione
Ex 5.12.  Ecrire un algorithme qui demande les notes (/20) des 10 interrogations des 70
étudiants de la classe. Les données sont stockées dans un tableau à 10 colonnes.
Ecran : Entrées utilisateur :
Etudiant 1
C1 : 15
C2 : 12
…
Exemple :
interro1 interro 2 … interro 10
Etu1 15 12 … 8
Etu2 3 6 … 2
… … … … …
Etu70 9 7 … 5
Ex 5.13. Faire la fusion des algorithmes des exercices Ex 5.11 et Ex 5.12 ; en liant le tableau de notes
au tableau des noms et prénoms des étudiants.

34
Introduction à la programmation Notes de cours

5.3.2 Exercices supplémentaires

Tableaux 1 dimension
Ex 5.14.  Que produit cet algorithme ? Peut-on simplifier cet algorithme avec le même résultat ?
begin
Tab Int Nb[6] // Tableau de 6 nombres
Int i, k // Compteurs de boucle
for i from 0 to 5 by step of 1
Nb(i) = i * i
end for
for k from 0 to 5 by step of 1
write : Nb(k) \n
end for
end

Ex 5.15.  Que produit l’algorithme suivant ?

begin
Tab Int Suite[8] // Tableau de 8 nombres
Int i, k // Compteurs de boucle
Suite(0) = 1
Suite(1) = 1
for i from 2 to 7 by step of 1
Suite(i) = Suite(i-1) + Suite(i-2)
end for
for k from 0 to 7 by step of 1
write : Suite(k)\n
end for
end

Ex 5.16.  Ecrire un algorithme qui demande à l’utilisateur combien de valeurs il compte saisir, puis
il effectue cette saisie et les nombres sont stockés dans un tableau. Le programme affiche
enfin le nombre de valeurs négatives.
Ex 5.17.  Ecrire un algorithme qui utilise un tableau de 9 notes, dont on fait saisir les valeurs par
l’utilisateur. Le programme affiche combien de notes sont strictement inférieures à 10/20,
puis il les affiche toutes ces notes.
Ex 5.18.  Pour sa naissance, la grand-mère de Gabriel place une somme de 1000 € sur son compte
épargne rémunéré au taux de 2% (chaque année le compte est augmenté de 2%). Développer
un algorithme permettant d’afficher un tableau usqu’à ses 20 ans associant à chaque
anniversaire de Gabriel la somme acquise sur son compte.
Ex 5.19.  Ecrivez un algorithme constituant un tableau, à partir de deux tableaux de 8 valeurs.
Le nouveau tableau sera la somme des éléments des deux tableaux de départ.
Exemple :

Tab1 : 4 8 7 9 1 5 4 6
Tab2 : 7 6 5 2 1 3 7 4
Tab à constituer : 11 14 12 11 2 8 11 10
Ex 5.20.  A partir de deux tableaux existants (de longueur 4 et 3), écrire un algorithme qui
calcule le « schtroumpf » des deux tableaux. Pour calculer le « schtroumpf », il faut multiplier
chaque élément du tableau 1 par chaque élément du tableau 2, et additionner le tout.
Exemple :

35
Introduction à la programmation Notes de cours

Tab1 : 4 8 7 12
Tab2 : 3 6 5
Valeur à calculer : 4*3+4*6+4*5+8*3+8*6+8*5+7*3+7*6+7*5+12*3+12*6+12*5=440

Tableaux 2 dimensions
Ex 5.21.  Ecrire un algorithme qui demande les notes (/20) des 10 interrogations des 70
étudiants de la classe. Les données sont stockées dans un tableau à deux dimensions :
11 colonnes : une pour chaque interro + une pour le calcul de la moyenne de chaque étudiant
71 lignes : une pour chaque étudiant + une pour le calcul de la moyenne de chaque interro
Exemple :
interro1 interro 2 … interro 10 moy
Etu1 15 12 … 8 13
Etu2 3 6 … 2 4
… … … … …
Etu70 9 7 … 5 7
moy 13 11 … 9 10

36
 Introduction à la programmation Notes de cours

6. Instructions dans quelques langages

Travail sur les variables
Pseudo code Javascript C#
Affectation d’une varia le = = =
Chaînes de caractères ʺ…ʺ ‘…’ ʺ…ʺ
Opérations sur les variables numériques
Addition a+b a+b a+b
Soustraction a-b a-b a-b
Multiplication a*b a*b a*b
Division a/b a/b a/b
Puissance a^b a**b Math.pow(a, b)
Modulo a%b a%b a%b
Aléatoire Rand(min, max) Math.random() aleatoire.next()
Valeur absolue abs() Math.abs() Math.Abs()
Opérations sur les chaînes de caractères
Concaténation + + +
Multiplication *
Longueur d’un String string.length() string.length() ***.length()
Mettre en minuscule string.ToLower() str.toLowerCase() Nom_du_string.ToLower()
Mettre en majuscule string.ToUpper() str.toLowerCase() Nom_du_string.ToUpper()
Commentaires
Fin de ligne // // //
Zone restreinte
/* … */ /* … */ /* … */
Ou Plusieurs lignes
Lecture et écriture
Pseudo code Javascript C#
Lecture VAR = read VAR = prompt("…") VAR = Console.ReadLine()
document.write(…)
Écriture write : … Console.WriteLine(…)
alert()
1 instruction document.write(…) par
Retour à la ligne \n \n ou (\r\n)
ligne
Conditions
Pseudo code Javascript C#
Opérateurs de comparaison
Égal == == ==
Différent != != !=
Plus petit < < <
Plus grand > > >
Plus petit ou égal <= <= <=
Plus grand ou égal >= >= >=
Opérateurs logiques
Non ! ! !
Et && && &&
Ou || || ||

37
 Introduction à la programmation Notes de cours

Structures conditionnelles
Pseudo code Javascript C#
Structures conditionnelles
1ère condition if Cdt1 then ... if (Cdt1) { if (Cdt1) {
Ajout de conditions else if Cdt2 then } else if (Cdt2) { } else if (Cdt2) {
Pour tout le reste else } else { } else {
Fin de condition end if } }
Opérateurs de comparaison
Égal == == ==
Différent != != !=
Plus petit < < <
Plus grand > > >
Plus petit ou égal <= <= <=
Plus grand ou égal >= >= >=
Opérateurs logiques
Non ! ! !
Et && && &&
Ou || || ||
Structures conditionnelles
Pseudo code Javascript C#
while Cdt while (Cdt) { while (Cdt) {
Boucle While … … …
end while } }
for compt from vi to vf
for (vi;vf;stp) { for (vi;vf;stp) {
Boucle for by step of stp
… …
…
} }
end for

38