Le pseudo-code

La structure de l’algorithme

Un algorithme se décompose en deux grandes parties : d’une part, les déclarations de variables et de constantes, et d’autre part, les instructions à exécuter. La structure générale d’un algorithme est donc la suivante :

Algo nomDeLAlgorithme  
#Déclarations 
  
Début  
   #Instructions 
  
Fin 

Le nom de l’algorithme est indiqué directement après le mot-clé Algo. Ce nom n’a aucune influence sur le déroulement de l’algorithme. Néanmoins, plus celui-ci sera explicite, plus cela sera pratique pour comprendre le rôle de cet algorithme. Pour revenir sur les recettes de cuisine, celles-ci sont généralement nommées "gâteau à l’ananas", "charlotte aux poires"...

Les commentaires

Dans un algorithme, comme dans tous les langages de programmation, il est possible d’écrire des commentaires. Comme leur nom l’indique, les commentaires permettent de donner une information supplémentaire. Ces commentaires ne sont pas nécessaires à l’exécution de l’algorithme. Lorsque vous écrirez un commentaire dans un langage de programmation, celui-ci sera ignoré par la machine. Les commentaires sont pourtant très utiles. Ils permettent d’inscrire de nombreuses informations pour la personne qui va lire le code. Cela est utile si une autre personne doit comprendre ce que vous cherchez à faire avec votre code, mais cela vous sera également utile, car lorsque vous relirez du code que vous avez écrit quelque temps auparavant, ces commentaires vous permettront de plus vite comprendre votre algorithme.

Dans cet ouvrage, les commentaires en pseudo-code commencent par le caractère # et se terminent à la fin de la ligne.

Exemple

# calcule le prix TTC d'un article 

En Java, il y a deux possibilités pour écrire un commentaire. L’équivalent du # du pseudo-code est la double barre oblique ou double slash (//). La seconde possibilité est de commencer le commentaire avec les caractères/* et terminer le commentaire avec */ ; cela permet de faire des commentaires au milieu d’une ligne...

La déclaration de variables

L’affectation d’une valeur

L’affectation d’une valeur est l’opération permettant de stocker une valeur dans une variable ou une constante. Pour cela, le nom de la variable ou de la constante dans laquelle il faut stocker la valeur est d’abord indiqué. Puis le symbole de l’affectation représenté par une flèche indique l’affectation. Enfin, l’instruction se termine par la valeur à affecter. Exemple :

prixHT <- 19,95 

Le symbole de la flèche utilisé en algorithmique montre bien le sens d’exécution de l’instruction : c’est la valeur qui est stockée dans la variable. Cela est un peu déroutant au début, car nous sommes plutôt habitués en français à lire de gauche à droite.

Il est possible d’affecter une valeur littérale (appelée également un littéral, c’est-à-dire une valeur donnée explicitement, 19,95 ou "bonjour" par exemple), la valeur d’une autre variable, le résultat d’un calcul (cela sera expliqué un peu plus loin dans ce chapitre)...

La déclaration d’une constante

Une constante est une valeur qui ne peut pas être modifiée au cours de l’exécution du programme. Il est par exemple possible de déclarer une constante pour le taux de TVA à appliquer. Celui-ci ne changera pas durant l’exécution du programme.

Par contre, il est possible de modifier cette valeur dans l’algorithme si jamais le taux de TVA évoluait, comme cela a déjà été le cas dans le passé. L’avantage d’avoir déclaré ce taux de TVA en tant que constante, c’est qu’il ne faut modifier la valeur qu’à un seul endroit dans l’algorithme (au niveau de sa déclaration) alors que cette valeur peut être utilisée de nombreuses fois dans le programme. De plus, les instructions utilisant cette constante sont plus explicites. Sans constante, voici un exemple d’instruction :

t <- prixHt × 0,20; 

Alors que voici la même instruction en utilisant une constante :

t <- prixHt × TVA; 

Dans le second cas, il est plus évident que l’instruction calcule la TVA pour un produit.

Le nom donné à la constante a également une grande importance pour rendre le code plus facile à lire, tout comme cela était déjà le cas pour le nom des variables. Par convention, le nom des constantes s’écrit...

Les opérations

Différents types d’opérations peuvent être réalisées. Le principe d’une opération est qu’elle prend une, deux ou rarement trois valeurs et un opérateur et calcule une nouvelle valeur à partir de cela.

1. Les opérations arithmétiques

a. Les quatre opérations arithmétiques usuelles

Le premier type d’opération que vous connaissez depuis l’école primaire sont les opérations arithmétiques : l’addition, la soustraction, la multiplication et la division réelle. Ces quatre opérations sont réalisées respectivement par les opérateurs +, -, × (ou *) et /. Ces opérations sont définies pour des nombres entiers et réels.

Exemple :

taux <- 20/100 

Ces quatre opérations sont bien évidemment également présentes en Java. Les opérateurs sont les mêmes, à l’exception de la multiplication, qui est uniquement symbolisée par *.

b. La division entière et son reste

En algorithmique, il existe deux opérateurs supplémentaires permettant de calculer le résultat et le reste de la division entière, appelée également division euclidienne, c’est-à-dire une division où le calcul est interrompu au moment de calculer les chiffres après la virgule. Ainsi, le résultat de la division entière de 69 par 4 est 17 (et non 17,25) et le reste de la division est 1.

L’opérateur permettant d’obtenir le résultat de la division entière est div. Le calcul du reste de la division entière s’appelle le modulo et l’opérateur pour le calculer est le %.

Exemple :

quotient <- 69 div 4 
reste <- 69 % 4 

En Java, la division réelle et la division entière sont représentées par le même opérateur symbolisé par le /. Pour savoir quelle opération réaliser, Java se base sur le type des deux valeurs à diviser. Si elles sont toutes les deux de type entier, alors c’est la division entière qui est utilisée. Si au moins l’un des deux types est de type réel, alors c’est la division réelle qui est réalisée.

Illustrons cela par un exemple...

La console

Pour interagir avec l’utilisateur, nous allons afficher des messages sur une console. Il pourra également saisir des valeurs qui seront utilisées par la suite dans l’algorithme. Cela peut vous sembler un peu pauvre en matière d’interaction avec l’utilisateur, mais pour commencer, cela sera plus simple. Lorsque vous maîtriserez la console, vous pourrez alors sans souci créer des interfaces graphiques et profiter d’interactions bien plus riches.

Java étant un langage de programmation multiplateforme, c’est-à-dire pouvant s’exécuter sur différents systèmes d’exploitation (Windows, Linux, MacOs…), l’aspect de cette console peut changer suivant le système d’exploitation que vous utilisez.

Voici la console sous Windows permettant l’exécution d’un programme Java :

Voici la console sous MacOs :

Enfin, la plupart du temps, nous développons à l’aide d’un environnement de développement intégré (IDE). Voici par exemple la console intégrée à l’IDE Eclipse :

L’interaction avec l’utilisateur reste la même, quelle que soit la console utilisée. Vous noterez cependant des petites nuances :

écrire("Prix HT de l'article ?") 

La génération de nombres aléatoires

Il arrive parfois qu’il soit nécessaire de tirer aléatoirement une valeur. Cela peut se produire dans différentes situations : pour coder des jeux (simulation du lancement d’un dé par exemple), pour des applications de sécurité (générer un mot de passe fort par exemple), pour de la simulation numérique (pour simuler des vagues sur la mer par exemple)…

Malheureusement, les ordinateurs sont déterministes, c’est-à-dire qu’ils sont faits pour, dans les mêmes conditions, réagir toujours de la même façon. Ce qui est le contraire de l’aléatoire ! Rassurez-vous, tout d’abord, le fait d’avoir des machines déterministes est une très bonne chose, car s’il y avait des comportements aléatoires, il serait très difficile, voire impossible, de réaliser des programmes qui fonctionnent toujours. Ensuite, les ordinateurs sont capables de générer des valeurs pseudo-aléatoires. Cela ressemble à des valeurs aléatoires pour un humain, mais en fait, elles sont parfaitement contrôlées.

Maintenant que vous êtes informé que ce ne sont pas des vraies valeurs aléatoires, voici comment les produire :

valeur <- aléa(minimum, maximum) 

Voici, par exemple, un algorithme tirant une valeur aléatoire comprise entre 0 et 20 et l’affichant :

Algo CorrectionDUneCopie  
Variable note...

Les outils pour écrire du pseudo-code et du Java

Exercices

Algo ValeursDesVariables  
variable a, b : entier  
Début 
   a <- 3 
   écrire("a = " & a) 
   b<-a+5 
   écrire("a = " & a & " et b = " & b) 
   a<-7 
   écrire("a = " & a & " et b = " & b)  
Fin 

Algo QuelsAffichages  
# Quels affichages produit cet algorithme ?  
Variable valeur1, valeur2 : entier  
Variable chaine1 : texte  
Constante CST : réel <- 49,78  
Début 
   valeur1 <- 92 % 8 
   valeur2 <- 2 * valeur1 
   chaine1 <- "Test" 
   écrire(chaine1 & " , valeur2 = " & valeur2) 
   écrire(valeur1 & " # " & CST)  
Fin 

Algo IlFaitQuoi  
# Que réalise cet algorithme ?  
Variable valeur1, valeur2 : réel  
Début 
   valeur1 <- saisir("Entrez valeur...

Solutions des exercices

Algo ValeursDesVariables  
Variable a, b : entier  
Début                  #     a      b 
  a <- 3               #     3 
  écrire("a = " & a) 
  b <- a+5             #     3      8 
  écrire("a = " & a & " et b = " & b) 
  a <- 7               #     7      8 
  écrire("a = " & a & " et b = " & b)  
Fin 

2. Quels affichages ?

Le reste de la division entière de 92 par 8 est 4 :

L’affichage est donc le suivant :

Test , valeur2 = 8

4 # 49,78

Algo Inversion  
# Saisit 2 valeurs et permute les variables  
Variable valeur1, valeur2...