Voici quelles sont les questions à vous poser et la démarche réflexive à avoir lorsque vous

commencez un exercice de programmation :

Début et fin
Les premières instructions à indiquer sont :
• begin → au début de l’algorithme
• end → à la fin de l’algorithme

A propos de la déclaration des variables

Questions à se poser :
• Quelles sont les variables qui constituent des « entrées » fournies par l’utilisateur ?
• Quelles sont les variables qui constituent des « sorties » renvoyées à l’utilisateur ?
• Quelles sont les variables internes qui sont nécessaires au bon fonctionnement du
programme ?
Pour chaque variable :
• Quel type devez-vous utiliser ?
• Quel nom allez-vous donner ?
• Quel va être son contenu ?

Réflexion :
Pour le contenu :
• Les entrées utilisateurs : par exemple des nombres, des mots, des lettre...
• Les sorties utilisateurs : par exemple un minimum, un maximum, une somme, une moyenne,
un produit, un compteur, le résultat d’un calcul, mot le plus long/court, mot le 1er/dernier dans
l’ordre alphabétique …
• Les variables internes : par exemple un compteur de boucle, un drapeau (variable booléenne
pour savoir si oui ou non, un évènement s’est produit), le résultat d’un calcul…
Pour le type :
Le type de chaque variable doit être spécifié lors de la déclaration. Il dépendra du contenu :
• Int ou Float pour les variables de type numérique ;
• Char ou Str pour les variables de type texte ;
• Bool pour les variables logiques.
• Chacun de ces type peut être couplé à un tableau Tab dans le cas où une série d’entrées
utilisateur doit être stockée.
Pour le nom :
• Que des lettres (sans accents), des chiffres, le underscore (_) ou le tiret (-) ;
• En premier caractère, seulement une lettre ou un underscore ;
• Pas de mots clefs du langage
Il se peut qu’on n’ait pas pensé à toutes les variables dès le départ ; dans ce cas, il suffit de rajouter les
variables manquantes en cours d’écriture de l’algorithme.

1
A propos des initialisations des variables
Questions à se poser :
Parmi toutes les variables identifiées précédemment :
• Lesquelles doivent être initialisées ?
• Pour quelle raison doivent-elles l’être ?
• S’agit-il d’une initialisation programmeur ou utilisateur ?
o Dans le cas d’une initialisation programmeur, quelle valeur d’initialisation choisissez-
vous ?

Réflexion :
L’initialisation des variables consiste à mettre une première valeur dans la variable. Cette initialisation
est nécessaire pour permettre le bon fonctionnement du programme. En fonction du cas, ceci peut
être réalisé par l’utilisateur ou par le programmeur.
Les variables à initialiser par le programmeur
• Les variables intervenant dans la condition des boucles « while », si elles n’ont pas encore de
contenu lors de la première entrée dans la boucle.
o Car le programme ne peut pas comparer le contenu d’une variable à une valeur, si
cette variable est vide.
▪ La valeur d’initialisation doit être choisie de sorte à obliger le 1er passage dans
la boucle. Dès l’entrée dans la boucle, cette valeur devra être écrasée par une
entrée utilisateur
• Les variables intervenant dans les structures conditionnelles « if », pour leur donner un point
de départ :
o Minimum : SI et SEULEMENT SI on connait la valeur maximale possible que peut
prendre la variable
▪ Initialisation à la plus grande valeur possible
o Maximum : SI et SEULEMENT SI on connait la valeur minimale possible que peut
prendre la variable
▪ Initialisation à la plus petite valeur possible
• Des variables utilisant récursivement leur ancienne valeur pour leur calcul de leur nouvelle
valeur. Par exemple :
o Compteur : i = i + 1
▪ Initialisé à 0, car il n’y a encore aucun évènement compté lors du démarrage
du programme
o Somme : som = som + n
▪ Initialisé à 0, car il n’y a encore aucune valeur ajoutée à la somme lors du
démarrage du programme
o Produit : prod = prod * n
▪ Initialisé à 1, car il s’agit du neutre de la multiplication
• Les variables booléennes jouant le rôle de drapeau :
o Car à la fin du code, on vérifie la valeur du drapeau pour savoir si l’évènement ’est
produit (valeur opposée à celle de l’initialisation) ou non (valeur identique à celle de
l’initialisation)
▪ La plupart du temps, les drapeaux sont initialisés à FALSE, car au début du
code, l’évènement recherché ne s’est pas encore produit
Les variables à initialiser par l’utilisateur
Dans le cas où on ne connait pas les limites des valeurs que peuvent prendre la variable, on utilise la
toute première valeur introduite par l’utilisateur, pour initialiser le minimum et le maximum.

2
A propos de la communication avec l’utilisateur
Questions à se poser :
Demandes à l’utilisateur :
• Y a-t-il des choses qui ne doivent être demandées qu’une fois à l’utilisateur ?
• Y a-t-il des choses qui doivent être demandées plusieurs fois à l’utilisateur ?
Retours à l’utilisateur :
• Y a-t-il des informations qui ne doivent être retournées (affichage de résultats) qu’une fois à
l’utilisateur ?
• Y a-t-il des informations qui doivent être retournées (affichage de résultats) plusieurs fois à
l’utilisateur ?
Si oui :
• Lesquelles ?
• À quel moment du code ?

Réflexion :
Demandes à l’utilisateur :
• Les demandes à l’utilisateur se font en deux temps :
o Tout d’abord avec un write : « … »\n ; qui permet de faire un affichage écran pour
prévenir l’utilisateur ce qu’on attend de lui ;
o Puis avec un variable = read ; qui permet de récupérer la valeur introduite par
l’utilisateur et la stocke dans la variable choisie.
• Une valeur qui ne doit être introduite qu’une fois est demandée en dehors des boucle
(généralement avant) ;
• Une valeur qui ne doit être introduite plusieurs fois est demandée dans une boucle.
Retours à l’utilisateur :
• Les valeurs qui doivent être retournées à l’utilisateur le sont avec la commande
write : « … »+valeur\n ; qui permet de faire un affichage. En les « », on annonce à l’utilisateur
l’information qu’on revoit, suivi du + et du nom de la variable qui contient cette valeur.
• Une valeur qui ne doit être retournée qu’une fois est affichée en dehors des boucles
(généralement après) ;
• Une valeur qui doit être retournée plusieurs fois est affichée dans une boucle.

3
A propos des structures conditionnelles
Questions à se poser :
• Le code doit-il pouvoir se comporter différemment selon les cas ?
• Doit-il se passer des choses particulières pour des valeurs spécifiques ?

Réflexion :
Si oui, il faut utiliser une structure conditionnelle :
If condition 1 vraie then
Instructions 1
Else if condition 2 vraie then
Instructions 2
Else
Instructions 3
End if

Les conditions testent les valeurs des variables à l’aide d’opérateurs de comparaison (== ; != ; < ; <= ;
> ; >=). Plusieurs conditions peuvent être réunies par des opérateurs logiques (Et && ; Ou || ; Non !)
→ voir le cours de math logique.

• Si la première condition est vraie, le bloc d’instructions 1 est effectué. Après cela, la structure
conditionnelle est finie. Les autres conditions ne sont même pas testées.
• Si et seulement si la condition est fausse, on passe à la suite de la structure conditionnelle :
o Si d’autres conditions sont nécessaires, elles sont introduites par else if. Il peut y avoir
plusieurs else if dans une même structure conditionnelle ;
o Else concerne tous les autres cas possibles. S’il y a un else, il n’est pas suivi d’une
condition, il est unique et en dernier cas.
• La structure conditionnelle se termine par le mot clef End if.

4
A propos des structures répétitives
Questions à se poser :
Certaines instructions doivent-elles répétées plusieurs fois ?
→ Si oui, utilisation d’une boucle.
• Si on ne sait pas au départ le nombre de fois que la boucle doit être faite
→ Boucles conditionnelles while
o A quoi sert cette boucle ? Quelles instructions seront faites dans cette boucle ?
o A quel moment arrête-t-on la boucle (condition de sortie) ?
o Quelle est la condition d’entrée dans la boucle qui en découle ?
• Si on sait dès le départ le nombre de fois que l’on doit faire la boucle
→ Boucles itératives for
o A quoi sert cette boucle ? Quelles instructions seront faites dans cette boucle ?
o Combien de fois cette boucle doit elle-être faite ?
o Quel en est le compteur ? Valeur initiale ? Valeur finale ? Progression entre la valeur
initiale et la valeur finale ?

Réflexion :
Pour les boucles while :
• Elles permettent de répéter les mêmes instructions tant qu’une condition est vérifiée ;
• Elles sont souvent utilisées pour faire des contrôles de saisie. Dans ce contexte, la boucle while
sert à demander des valeurs à l’utilisateur, tant qu’il encode des valeurs erronées.
• La condition de sortie de la boucle est la condition donnée dans l’énoncé pour arrêter la
boucle. Par exemple, demander des valeurs jusqu’à ce que l’utilisateur introduise un zéro.
Dans ce cas, la condition de sortie est ==0
• Par contre, une boucle while demande une condition d’entrée qui doit être vraie pour faire la
boucle. Il s’agit donc de l’opposé de la condition de sortie. Dans notre exemple, la condition
d’entrée est !=0.
En effet, si j’arrête la boucle quand l’utilisateur introduit une valeur considérée comme
« correcte », alors je dois continuer à lui demander des valeurs tant qu’il se « trompe ».
• Les variables intervenant dans la condition de boucle doivent généralement être initialisées.
Avant d’entrer dans la boucle, le programmeur donne une première valeur à la variable. Cette
valeur est choisie de sorte à se « tromper », pour obliger le code à rentrer dans la boucle.
Pour les boucles for :
• Elles permettent de répéter les mêmes instructions un nombre de fois prédéterminé ;
• Elles sont souvent utilisées pour travailler dans les tableaux. Dans ce contexte, le compteur de
la boucle for est synchronisé avec l’indice des cases du tableau.
• For i from vi to vf by step of pas
o Cette boucle est liée à un compteur (souvent i)
o Vi représente la valeur initiale, la valeur que vaut le compteur lors du 1er tour de boucle
o Vf représente la valeur finale, la valeur que vaut le compteur lors du dernier tour de
boucle
o Pas représente la progression du compteur entre vi et vf

5
A propos des opérations à effectuer
Questions à se poser :
Pour des variables numériques ; ce code nécessite-il le calcul
• D’une somme ?
• D’une moyenne ?
• D’un produit ?
• D’un minimum ?
• D’un maximum ?
Pour les variables de texte, ce code nécessite-il
• Des opérations sur la longueur des chaînes de caractères ?
• Des opérations par rapport à l’ordre alphabétique ?
Décrivez la démarche et les lignes de codes qui sont relatives à ces opérations

Réflexion :
Pour les opérations sur les variables numériques : voir pages 24-25 des notes de cours.
Pour les opérations sur les variables de texte :
• La longueur d’une chaîne de caractères se trouve avec la fonction string.length(). Etant donné
que cette fonction retourne des valeurs numériques, des opérations de recherches de mot le
plus court, de mot le plus long, de calcul du nombre moyen de lettres, peuvent être effectuées.
• L’ordre alphabétique se teste avec les symboles < et > ; le « a » étant la plus petite lettre de
l’alphabet. Il est donc possible de rechercher le « plus petit » mot dans l’ordre alphabétique
ou le « plus grand » mot dans l’ordre alphabétique.

6
A propos des tableaux
Questions à se poser :
• Un tableau est nécessaire au stockage des données ?
• Combien de cases contient-il ?
• Quel est l’indice de la 1ère case ?
• Quel est l’indice de la dernière case ?

Réflexion :
Si un grand nombre de données doit être stocké, on utilise un tableau.
• Les tableaux peuvent être soit des Tab Int, Tab Float, Tab Char, Tab Str, Tab Bool ; mais ils ne
peuvent pas mélanger plusieurs types de variables
• Pour déclarer un tableau, on définit son type, son nom et on précise entre [], le nombre de
cases qu’il contient.
o Par exemple : Tab Int Table[N] → Table est un tableau de N nombres entiers.
• Pour un tableau de N cases, celles-ci sont numérotées de 0 à (N-1). Le numéro des cases
s’appelle l’indice de la case. En donnant le nom du tableau suivi, entre (), de l’indice d’une
case ; on indique au programme avec quelle case du tableau il travaille.
o Par exemple :
▪ Table(2) = read → met une valeur utilisateur dans la case d’indice 2 du tableau
« Table »
▪ Write : Table(0)\n → affiche à l’écran le contenu de la 1ère case du tableau
« Table »
▪ If Table(i)==0 then → vérifie si le contenu de la case i du tableau « Table » est
égal à 0.
• Pour systématiser le travail dans les cases du tableau, on couple l’indice du tableau avec le
compteur d’une boucle for :
o for i from 0 to (N-1) by step of 1
write : « introduisez une valeur »\n
Table(i)=read
End for

7
A propos des compteurs
Questions à se poser :
• En dehors de la gestion des boucles, des compteurs sont-ils nécessaires à l’exécution de ce
code ?
• Si oui, de quel type sont-ils ?
• Quel évènement comptent-ils ?
• Quelle est la condition de recherche de l’évènement en question ?

Réflexion :
• Les compteurs servent à compter combien de fois un événement déterminé s’est produit.
• Les compteurs sont des variables de type int.
o Déclaration : Int compt
• Le compteur nécessite une initialisation, il faut lui donner une valeur de départ avant l’entrée
dans la boucle. Au début, comme l’évènement considéré n’a pas encore eu lieu, on initialise le
compteur à zéro.
o Initialisation : compt = 0
• Pour savoir si l’évènement s’est produit, on utilise une structure conditionnelle qui teste la
valeur.
o Recherche de l’évènement : if condition de l’évènement then
• A chaque fois que l’évènement considéré est rencontré, on ajoute un à la valeur du compteur
(=incrémenter).
o Incrémentation : compt = compt + 1 ou compt ++
• La valeur finale du compteur représente le nombre total de fois que l’évènement a eu lieu.
Après la boucle, on affiche le contenu de la variable compteur.
o Affichage : write : « le nombre de fois que l’évènement s’est produit : » + compt \n

8
A propos des drapeaux
Questions à se poser :
• Des drapeaux sont-ils nécessaires à l’exécution de ce code ?
• Si oui, de quel type sont-ils ?
• Quelle est la condition de recherche de l’évènement en question ?
• Comment exploitez-vous l’information contenue dans le drapeau ?

Réflexion :
• Les drapeaux servent à savoir si un événement déterminé s’est produit ou non.
• Les drapeaux sont des variables de type bool.
o Déclaration : Bool flag
• Le drapeau nécessite une initialisation, il faut lui donner une valeur de départ avant l’entrée
dans la boucle. Au début, comme l’évènement considéré n’a pas encore eu lieu, on initialise le
drapeau à Faux.
o Initialisation : flag = FALSE
• Pour savoir si l’évènement s’est produit, on utilise une structure conditionnelle qui teste la
valeur.
o Recherche de l’évènement : if condition de l’évènement then
• Si l’évènement considéré est rencontré, on change la valeur du drapeau.
o Flag = TRUE
• La valeur logique finale du drapeau indique si l’évènement a eu lieu ou pas. Après la boucle,
on teste la valeur du drapeau dans une structure conditionnelle. Si sa valeur est vraie,
l’évènement s’est produit au moins une fois ; si elle est fausse, il ne s’est jamais produit.
o If flag == True then
Write : « l’évènement s’est produit au moins une fois » \n
Else
Write : « l’évènement ne s’est jamais produit » \n
End if