Activité : Répéter des instructions avec des structures de boucle

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, des structures de choix et des structures de boucle.

Dans vos travaux, veillez à soigner la présentation de votre code (indentations, convention de nommage, etc.) et n’hésitez pas à utiliser la fonctionnalité de formatage automatique de NetBeans. N’hésitez pas non plus à noter vos observations directement dans votre code à l’aide de commentaires.

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, des structures de choix et des structures de boucle à 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
// Pour chaque valeur entière de i de min à max compris.
for (int i = min; i <= max; i += 1) { // Remplacer min par la valeur min;
                                      // remplacer max par la valeur max.

    // Instructions à répéter.
    // La variable de boucle i est définie uniquement 
    // dans ce bloc (entre les deux accolades).

}

// Exemple :
// Pour chaque valeur entière de i de 0 à 10 compris. 
for (int i = 0; i <= 10; i += 1) { 
    System.out.println(i);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
// Pour chaque valeur entière de i de min à max non compris. 
for (int i = min; i < max; i += 1) { // Remplacer min par la valeur min;
                                     // remplacer max par la valeur max.

    // Instructions à répéter.
    // La variable de boucle i est définie uniquement 
    // dans ce bloc (entre les deux accolades).

}

// Exemple :
// Pour chaque valeur entière de i de 0 à 10 non compris. 
for (int i = 0; i < 10; i += 1) { 
    System.out.println(i);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
// Pour chaque valeur entière de i de min à max compris par pas de 2. 
for (int i = min; i <= max; i += 2) { // Remplacer min par la valeur min;
                                      // remplacer max par la valeur max.

    // Instructions à répéter.
    // La variable de boucle i est définie uniquement 
    // dans ce bloc (entre les deux accolades).

}

// Exemple :
// Pour chaque valeur entière de i de 0 à 10 compris par pas de 2. 
for (int i = 0; i <= 10; i += 2) { 
    System.out.println(i);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
// Pour chaque valeur entière de i de max à min compris par pas de -1. 
for (int i = max; i >= min; i -= 1) { // Remplacer min par la valeur min;
                                      // remplacer max par la valeur max.

    // Instructions à répéter.
    // La variable de boucle i est définie uniquement 
    // dans ce bloc (entre les deux accolades).

}

// Exemple :
// Pour chaque valeur entière de i de 10 à 0 compris par pas de -1. 
for (int i = 10; i >= 0; i -= 1) { 
    System.out.println(i);
}
1
2
3
4
5
6
7
// Répéter tant que booleanExpr est vraie. 
while (booleanExpr) {  // Remplacer booleanExpr par
                       // une expression booléenne

    // Instructions à répéter.

}

Tâches

Réalisez les programmes décrits ci-après en Java et documentez votre code à l’aide de commentaires.

Boucle définie : afficher une suite de nombres

Pour ce premier programme, il s’agit d’afficher une suite de nombres entiers compris entre deux valeurs entières (min et max) choisies par l’utilisateur. La figure 1 décrit l’algorithme que vous devez réaliser.

Fig. 1 — Structogramme du programme PrintMinToMax
Fig. 1 — Structogramme du programme PrintMinToMax

La figure 2 montre un exemple d’exécution du programme.

Veuillez saisir la valeur de départ : 5
Veuillez saisir la valeur d’arrivée : 10
5
6
7
8
9
10
Fig. 2 — Exemple d’exécution

Créez un nouveau projet PrintMinToMax2 et réalisez le programme conformément au structogramme de la figure 3.

Fig. 2 — Structogramme du programme PrintMinToMax2
Fig. 3 — Structogramme du programme PrintMinToMax2

Quelle est l’instruction qui incrémente la valeur de la variable currentNumber et comment pourriez-vous écrire cette instruction plus simplement ?

Boucles définies imbriquées : afficher un carré de nombre

Le deuxième programme doit afficher 10 lignes de nombres de 0 à 9. La première ligne commence à 0, la deuxième à 1, la troisième à 2, etc. comme le montre la figure 4.

0 1 2 3 4 5 6 7 8 9 
1 2 3 4 5 6 7 8 9 0 
2 3 4 5 6 7 8 9 0 1 
3 4 5 6 7 8 9 0 1 2 
4 5 6 7 8 9 0 1 2 3 
5 6 7 8 9 0 1 2 3 4 
6 7 8 9 0 1 2 3 4 5 
7 8 9 0 1 2 3 4 5 6 
8 9 0 1 2 3 4 5 6 7 
9 0 1 2 3 4 5 6 7 8 
Fig. 4 — Exemple d’exécution

Réalisez le programme conformément au structogramme de la figure 5.

Fig. 5 — Structogramme du programme PrintHundredNumbers
Fig. 5 — Structogramme du programme PrintHundredNumbers

Afficher une table de multiplication

Pour ce programme, nous allons utiliser plusieurs structures de boucle et des structures de choix pour afficher une table de multiplication comme celle de la figure 6.

 x |   1   2   3   4   5   6   7   8   9  10  11  12 
---|-------------------------------------------------
 1 |   1   2   3   4   5   6   7   8   9  10  11  12 
 2 |   2   4   6   8  10  12  14  16  18  20  22  24 
 3 |   3   6   9  12  15  18  21  24  27  30  33  36 
 4 |   4   8  12  16  20  24  28  32  36  40  44  48 
 5 |   5  10  15  20  25  30  35  40  45  50  55  60 
 6 |   6  12  18  24  30  36  42  48  54  60  66  72 
 7 |   7  14  21  28  35  42  49  56  63  70  77  84 
 8 |   8  16  24  32  40  48  56  64  72  80  88  96 
 9 |   9  18  27  36  45  54  63  72  81  90  99 108 
10 |  10  20  30  40  50  60  70  80  90 100 110 120 
11 |  11  22  33  44  55  66  77  88  99 110 121 132 
12 |  12  24  36  48  60  72  84  96 108 120 132 144 
Fig. 6 — Exemple d’exécution du programme MultiplicationTable

Réalisez le programme MultiplicationTable conformément au structogramme de la figure 7.

Fig. 7 — Structogramme du programme MultiplicationTable
Fig. 7 — Structogramme du programme MultiplicationTable

Une fois que vous avez réalisé le programme, répondez aux questions ci-après.

  1. Expliquez à quoi servent les structures de choix dans ce programme.
  2. Faite un programme pour exécuter le code ci-dessous et essayez de déterminer à quoi sert la valeur qui se trouve entre le % et le d dans les chaînes passées à la procédure System.out.printf.
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    
    System.out.println("-----");
    System.out.printf("%3d\n", 7);
    System.out.printf("%3d\n", 97);
    System.out.printf("%3d\n", 101);
    System.out.println("-----");
    System.out.printf("%4d\n", 7);
    System.out.printf("%4d\n", 97);
    System.out.printf("%4d\n", 101);
    System.out.println("-----");
    System.out.printf("%5d\n", 7);
    System.out.printf("%5d\n", 97);
    System.out.printf("%5d\n", 101);
    System.out.println("-----");
  3. Créez un nouveau projet MultiplicationTable2 et réalisez une version plus simple de MultiplicationTable en utilisant des `printf`.

Boucles et tableaux de valeurs

Pour la réalisation d’algorithme, il est très souvent nécessaire d’avoir une variable qui contient non pas une seule valeur, mais un certain nombre de valeurs de même type. Lorsque c’est le cas, on peut utiliser une structure de données appelée tableau (array). En Java, on peut déclarer un tableau de la manière suivante :

1
2
3
4
5
6
7
8
9
10
    // Déclare un tableau d’entiers (int).
    int[] anArrayOfInteger;

    // Déclare un tableau d’entiers longs (long).
    long[] anArrayOfLong;

    // Déclare un tableau de double
    double[] anArrayOfDouble;

    ...

D’une manière générale, on déclare un tableau comme n’importe quelle autre variable. Le type d’un tableau est le type de ces éléments auquel on ajoute une paire de crochets [] (p. ex. int[], double[], String[], etc.).

Si on a une valeur de type int[] (tableau de int), on ne peut pas lui affecter une valeur de type int. On doit impérativement lui affecter une valeur de type int[] c’est-à-dire un tableau. Pour cela, on doit créer un tableau de la manière suivante :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
    ...

    int n = 5;

    // Crée un tableau de int de 10 éléments en spécifiant
    // le nombre d’éléments avec une valeur littérale.
    anArrayOfInteger = new int[10];

    // Crée un tableau de long de 5 éléments en spécifiant
    // le nombre d’éléments avec une variable.
    anArrayOfLong = new long[n];   


    // Crée un tableau de double de 20 éléments en spécifiant
    // le nombre d’éléments avec une expression arithmétique.
    anArrayOfDouble = new double[n * 4];

    ...

Les éléments d’un tableau peuvent être accédés individuellement à l’aide d’un indice (index), c’est-à-dire le numéro de l’élément en partant de 0 (le premier élément à toujours le numéro 0).

image/svg+xml33 73 63 82 23 78 99 ... anArrayOfInt[0] anArrayOfInt[3] anArrayOfInt[n-1] n éléments (cellules) de même type anArrayOfInt indice (index)
Fig. 8 — Tableau

Les éléments d’un tableau de int sont des int, ceux d’un tableau de double sont des double, etc. Pour affecter une valeur à un élément d’un tableau, on utilise la syntaxe suivante :

1
2
3
4
5
6
7
8
9
    ...

    // Affecte une valeur de type int à l’élément 0 du tableau de int.
    anArrayOfInteger[0] = 10;

    // Affecte une valeur de type double à l’élément 12 du tableau de double.
    anArrayOfDouble[12] = 2.0;

    ...

De la même manière, on peut obtenir la valeur d’un élément d’un tableau :

1
2
3
4
5
6
7
8
9
    ...

    // Affecte la valeur de l’élément 0 du tableau d’entier
    // à une nouvelle variable.
    int anInteger = anArrayOfInteger[0];

    //Affecte la valeur de l’élément 12 du tableau de double 
    // à une nouvelle variable.
    double aDouble = anArrayOfDouble[12];

On peut indexer un tableau à l’aide d’une variable. Par exemple, le code de la figure 9 crée un tableau de 12 éléments et le remplit avec les 12 premiers multiples de 3.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public class MultiplesOfThree {

    public static void main(String[] args) {
       
        // Déclare un tableau d’entier et crée  
        // un tableau de 12 éléments.
        int[] multipleOfThree = new int[12];
        
        // Initialise le tableau avec les 
        // multiples de 3.
        for (int i = 0; i < 12; i += 1) {
            multipleOfThree[i] = (i + 1) * 3;
        }
        
        // Écris toutes les valeur du tableau dans stdout.
        for (int i = 0; i < multipleOfThree.length; i += 1) {
            System.out.println(multipleOfThree[i]);
        }
    }
}
Fig. 9 — Programme MultiplesOfThree

Créez un nouveau projet pour le programme MultiplesOfThree, testez-le et expliquez ce que renvoie l’expression multipleOfThree.length. Créez ensuite un nouveau programme SumOfMultiplesOfThree en reprenant le code de ce programme et modifiez-le pour afficher la somme de tous les éléments du tableau.