Activité : Utiliser des affectations et des structure de choix

Consigne

Durant les 135 prochaines minutes, votre tâche est de réaliser une série de petits programmes à partir de structogrammes. Pour réaliser ces programmes, vous devrez afficher des messages à l’écran, lire des valeurs au clavier, utiliser des affectations avec des expressions arithmétiques et des structures de choix avec des expressions booléennes.

Pour tous les programmes que vous allez réaliser vous-même dans le cadre de ce module, le nom du package doit être :

ch.epaifribourg.ict.<nom d’utilisateur>.m403

Vous devez remplacer la chaîne <nom d’utilisateur> par le nom de votre compte dans le réseau I-FR écrit en minuscules. Par exemple :

ch.epaifribourg.ict.frossardj.m403

Objectifs

À la fin de ce travail, vous devez être capable de :

  1. écrire un programme en utilisant des déclarations, des affectations, et des structures de choix à partir d’un GNS.

Résultat attendu

  • Un projet NetBeans pour chaque programme.

Ressources

Logiciel :

  • Oracle NetBeans

Documents :

Fragments de code (snippets):

Ces fragments de code vous sont fournis pour vous aider à réaliser vos programmes. Prenez la peine de taper le code plutôt que de faire du copier-coller, de façon à vous familiariser avec la syntaxe et ainsi, l’apprendre.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
package ch.epaifribourg.ict.username.m403; // Remplacer username par 
                                           // votre nom d'utilisateur.

// Importe le module Scanner si une variable de type Scanner est
// nécessaire pour lire des valeurs dans l'entrée standard.
import java.util.Scanner;

public class NomDuProgramme { // Remplacer NomDuProgramme par le nom 
                              // de votre programme en UpperCamelCase.

    // Si nécessaire, insérer ici les constantes. Par exemple:
    private static final int MA_CONSTANTE = 1; // Remplacer MA_CONSTANTE par  
                                               // le nom de votre constante  
                                               // en UPPER_SNAKE_CASE, int 
                                               // par le type adéquat et
                                               // 1 par la valeur souhaitée.


    // La procédure principale est le point d'entrée de votre 
    // programme, la première instruction de cette procédure est
    // la première instruction du programme.
    public static void main(String[] args) {

        // Insérer ici les déclarations et les
        // instructions de votre programme.
      
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
// Déclaration d'une variable de type Scanner 
// et initialisation de la variable avec 
// une référence à un nouvel objet de type 
// Scanner.
Scanner input = new Scanner(System.in);

// Lis un nombre entier dans stdin
int n = input.nextInt();

// Lis un nombre à virgule dans stdin
double d = input.nextDouble();

// Lis une chaîne de caractères dans stdin
String s = input.next();
1
2
3
4
5
6
7
8
9
10
11
12
// Écris une chaîne de caractères dans stdout.
System.out.print("une chaîne de caractères");

// Écris une chaîne de caractères suivi d’un 
// retour à la ligne dans stdout.
System.out.println("une chaîne de caractères");

// Écris une chaîne de caractère contenant une 
// partie variable (%d pour un entier, %f pour 
// un nombre à vigule, %s pour une chaîne) 
// dans stdout.
System.out.printf("Il y a %d éléments.", uneVariable);
1
2
3
4
5
6
7
8
9
10
11
if (condition) { // Remplacer condition par une expression booléenne.
    
    // Instructions à exécuter si la condition est remplie 
    // (l’expression vaut true).
    
} else {

    // Instructions à exécuter si la condition n’est pas remplie
    // (l’expression vaut false).

}
1
2
3
4
5
6
// Lorsque la clause else ne contient rien, elle peut être omise.
if (condition) { // Remplacer condition par une expression booléenne.
    
    // Instructions à exécuter si la condition est remplie.
    // (l’expression vaut true).
} 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
// Une structure de choix est une instruction. Il est donc possible 
// de trouver une structure de choix à l’intérieur d’une structure 
// de choix.
if (condition1) { // Remplacer condition1 par une expression booléenne.
    
    // Une première instruction à exécuter si la condition 1 est remplie.

    // Une deuxième instruction (une structure de choix) à exécuter 
    // si la condition 1 est remplie.
    if (condition2) {
        // Instructions à exécuter si la condition 2 est remplie.
    }

    // D’autres instructions à exécuter si la condition 1 est remplie.
} 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
// Lorsque la clause else contient uniquement une structure de choix
// (une seule structure de choix et rien d’autre), on peut enchaîner 
// les structures de choix comme dans le code ci-après.
if (condition1) { // Remplacer condition1 par une expression booléenne.
    
    // Instructions à exécuter si la condition 1 est remplie.

} else if (condition2) { // Remplacer condition2 par une expression booléenne.

    // Instructions à exécuter si la condition 1 n’est pas remplie
    // mais que la condition 2 est remplie.

} else {

    // Instructions à exécuter si aucune condition n’est remplie.
}

// Cette manière d’écrire est plus élégante que celle, parfaitement
// équivalente, présentée ci-dessous. 
if (condition1) { // Remplacer condition1 par une expression booléenne.
    
    // Instructions à exécuter si la condition 1 est remplie.

} else {

    // La clause else ne contient qu’une seule structure de choix 
    // et rien d’autre.
    if (condition2) { // Remplacer condition2 par une expression booléenne.

        // Instructions à exécuter si la condition 1 n’est pas remplie
        // mais que la condition 2 est remplie.

    } else {

        // Instructions à exécuter si aucune condition n’est remplie.
    }

}

Tâches

Tester si une valeur se trouve ou non dans un intervalle

Il est assez courant de devoir tester si une valeur se trouve ou non dans un intervalle. Une valeur se trouve à l’intérieur de l’intervalle si elle est à la fois plus grande ou égale à la borne inférieure et plus petite ou égale à la borne inférieure ; les deux conditions doivent être remplies simultanément. On doit donc combiner deux opérations de comparaison avec un ET logique (&&). Le programme IsInInterval de l’activité précédente fait exactement cela.

L’opération inverse consiste à tester si une valeur se trouve en dehors d’un intervalle. Pour cela, la valeur peut être soit plus petite que la borne inférieure soit plus grande que la borne supérieure. L’une de ces deux conditions doit être remplie. Il est impossible qu’elles soient remplies simultanément et si aucune d’entre elles n’est remplie alors la valeur se trouve dans l’intervalle. On doit donc combiner deux opérations de comparaison avec un OU logique (||). Le symbole utilisé pour le OU logique s’écrit avec deux caractères appelés « tube » (pipe) ou « barre verticale ». Sur un clavier suisse, le tube correspond à la combinaison Alt Gr-7.

On vous demande de réaliser le programme IsOutOfInterval en Java tel que décrit par le structogramme de la figure 1. Ce programme demande une valeur à l’utilisateur, test si la valeur se trouve en dehors d’un certain intervalle et indique à l’utilisateur si la valeur se trouve ou non dehors de l’intervalle.

Fig. 2 – Structogramme (GNS) du programme IsOutOfInterval
Fig. 1 – Structogramme (GNS) du programme IsOutOfInterval

Questions :

  1. Ecrivez une expression booléenne qui permet de tester si la valeur se trouve en dehors de l’intervalle [10,20[.
  2. Écrivez une expression booléenne qui permet de tester si la valeur se trouve en dehors de l’intervalle ]10,20].

Échanger les valeurs de deux variables

Le programme « EuclideanAlgorithm » demande deux nombres en précisant de saisir d’abord le plus grand nombre puis le plus petit nombre. Toutefois, le programme ne vérifie pas que l’utilisateur respecte bien cette consigne. Même si la conséquence du non-respect de cette consigne est sans gravité (la boucle est simplement exécutée une fois de plus), dans cette nouvelle version nous allons vérifier que la valeur de a est plus grande que la valeur de b et échanger leur valeur si ce n’est pas le cas.

L’échange des valeurs de deux variables est une opération qui demande l’utilisation d’une troisième variable dite temporaire. En effet, puisque l’affectation est destructrice (l’ancienne valeur de la variable est perdue), si l’on commence par affecter à b la valeur de a, il n’est plus possible d’affecter à a la valeur de b. Inversement, si l’on commence par affecter à a la valeur de b, il n’est plus possible d’affecter à b la valeur de a. Pour résoudre ce problème, on commence par sauvegarder la valeur de a dans une variable temporaire, on affecte à a la valeur de b, puis on affecte à b la valeur de la variable temporaire. Une variable temporaire est une variable comme les autres, on la dit « temporaire » parce que sa valeur peut être oubliée une fois que l’échange est effectué.

On vous demande de réaliser le programme EuclideanAlgorithm2 en Java tel que décrit par le structogramme de la figure 2. Pour vous aider, vous pouvez reprendre le programme EuclideanAlgorithm et effectuer les modifications nécessaires.

Fig. 2 – Structogramme (GNS) du programme EuclideanAlgorithm2
Fig. 2 – Structogramme (GNS) du programme EuclideanAlgorithm2

Structures de choix imbriquées

Une structure de choix comme n’importe quelle autre structure de contrôle est une instruction. Une structure de choix peut donc apparaître à l’intérieur d’une autre structure de choix. On dit que la seconde est imbriquée dans la première.

On vous demande de réaliser le programme PropertiesOfNumber en Java tel que décrit par le structogramme de la figure 3. Attention : dans ce programme, la clause else de la première structure contient deux instructions (deux structures de choix), il n’est donc pas possible de les enchaîner.

Fig. 2 – Structogramme (GNS) du programme PropertiesOfNumber
Fig. 3 – Structogramme (GNS) du programme PropertiesOfNumber

La figure 4 montre trois exemples d’exécution du programme. Utilisez successivement les valeurs 0, 4 et -5 pour vérifier que votre programme produit des résultats identiques.

1
2
3
4
5
6
7
8
9
10
11
12
13
Veuillez saisir un nombre entier : 0
Le nombre 0 est pair et positif.
Fin du programme.

Veuillez saisir un nombre entier : 4
Le nombre est positif.
Le nombre est pair.
Fin du programme.

Veuillez saisir un nombre entier : -5
Le nombre est négatif.
Le nombre est impair.
Fin du programme.
Fig. 4 – Exemple d'exécutions du programme

Enchaînement de structures de choix

L’algorithme d’Al-Khwârizmî pour la résolution d’équation du second degré ne permet pas de résoudre n’importe quelle équation et ne donne qu’une seule solution alors que dans le cas général, une telle équation admet deux solutions. L’algorithme général décrit par le structogramme de la figure 4 permet de résoudre une équation de la forme :

ax2 + bx + c = 0

On vous demande de réaliser le programme QuadraticEquation3 en Java tel que décrit par le structogramme de la figure 5. Dans ce programme, la clause else de la première structure de choix contient une seule et unique structure de choix. Dans ce cas, les structures de choix peuvent être enchaînées.

Fig. 2 – Structogramme (GNS) du programme QuadraticEquation3
Fig. 5 – Structogramme (GNS) du programme QuadraticEquation3

Entraînement

En plus de la connaissance des différentes notions et de la manière dont elles s’articulent entre elles, il est nécessaire de pratiquer la programmation un peu comme on pratique un sport ou un instrument.

Entraînez-vous en refaisant plusieurs fois chacun de ces programmes en partant chaque fois de zéro et en vous aidant de moins en moins des fragments de code et des exemples à votre disposition. Appliquez-vous à toujours écrire du code qui est agréable à lire et qui respecte les conventions de codage. Souvenez-vous qu’on écrit du code d’abord pour des programmeurs (dont vous), ensuite seulement pour une machine.