[Précédent]
[Index] | [Enoncé] | [Version imprimable]
[Prochain]

5.7
   Opération sur les tableaux - Corrigé
Niveau 1
  
 
Fichiers:
   Operations.java    

Les méthodes à compléter ne posent pas de difficultés particulières. Elles sont commentées dans le code ci-dessous: 

  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
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
 
class Operations {
    public static void main(String args[]) {
        // Construction d'un tableau:
        int[] tableau = {3, 7, 1, 9, 2, 8, 9, 1, 2, 5};
        // Opérations sur le tableau:
        operations(tableau);

        // La même chose pour d'autres tableaux:
        int[] tableau1 = remplir1(5);
        operations(tableau1);

        int[] tableau2 = remplir2(10);
        operations(tableau2);

        int[] tableau3 = remplir3(5);
        operations(tableau3);
    }

    /**
     * Cette méthode retourne un tableau int[] de nb éléments
     * initialisés en ordre croissant de 0 à nb-1.
     * @param nb La taille du tableau (nombre d'élements).
     * @return tableau Le tableau correctement rempli.
     */
    static int[] remplir1(int nb) {
        int[] tableau = new int[nb];
        for (int i = 0; i < nb; i++) {
            tableau[i] = i;
        }
        return tableau;
    }

    /**
     * Cette méthode retourne un tableau int[] de nb éléments
     * initialisés en ordre croissant à partir de 5.
     * @param nb La taille du tableau (nombre d'élements).
     * @return tableau Le tableau correctement rempli.
     */
    static int[] remplir2(int nb) {
        int[] tableau = new int[nb];
        for (int i = 0; i < nb; i++) {
            tableau[i] = i + 5;
        }
        return tableau;
    }

    /**
     * Cette méthode retourne un tableau int[] de nb éléments
     * initialisés en ordre décroissant de nb à 1.
     * @param nb La taille du tableau (nombre d'élements).
     * @return tableau Le tableau correctement rempli.
     */
    static int[] remplir3(int nb) {
        int[] tableau = new int[nb];
        for (int i = 0; i < nb; i++) {
            tableau[i] = nb - i;
        }
        return tableau;
    }

    /**
     * Affiche le tableau puis effectue les opérations 1 à 5 sur le tableau.
     * @param tableau Le tableau à traiter.
     */
    static void operations(int[] tableau) {
        afficher(tableau);
        operation1(tableau);
        operation2(tableau);
        operation3(tableau);
        operation4(tableau);
        operation5(tableau);
    }

    /**
     * Cette méthode affiche tous les éléments du tableau reçu en
     * paramètre sur une meme ligne. Les éléments sont séparés par
     * deux espaces.
     * @param tableau Le tableau à afficher.
     */
    static void afficher(int[] tableau) {
        for (int i = 0; i < tableau.length; i++) {
            System.out.print(tableau[i]);
            System.out.print("  ");
        }
        // Saut de ligne à la fin de l'affichage
        System.out.println();
    }

    /**
     * Cette méthode calcule et affiche le nombre d'éléments de valeur
     * 9 dans le tableau. La variable count sert à compter les éléments
     * trouvés. Elle est initialisée à 0 et incrémentée dans la boucle
     * qui parcourt le tableau chaque fois que l'on trouve un 9.
     * @param tableau Le tableau à traiter.
     */
    static void operation1(int[] tableau) {
        int count = 0;
        for (int i = 0; i < tableau.length; i++) {
            if (tableau[i] == 9) {
                count++;
            }
        }
        System.out.println("Il y a " + count + " elements de valeur 9 dans le tableau");
    }

    /**
     * Cette méthode calcule et affiche le nombre d'éléments qui sont
     * plus grands que 4 OU plus petits que 2.
     * @param tableau Le tableau à traiter.
     */
    static void operation2(int[] tableau) {
        int count = 0;
        for (int i = 0; i < tableau.length; i++) {
            if ((tableau[i] > 4) || (tableau[i] < 2)) {
                count++;
            }
        }
        System.out.println("Il y a " + count + " elements plus grands que 4 ou plus petits que 2");
    }

    /**
     * Cette méthode calcule et affiche le somme de tous les éléments du tableau.
     * @param tableau Le tableau à traiter.
     */
    static void operation3(int[] tableau) {
        int somme = 0;
        for (int i = 0; i < tableau.length; i++) {
            somme = somme + tableau[i];
        }
        System.out.println("La somme des elements est " + somme);
    }

    /**
     * Cette méthode calcule et affiche la moyenne arithmétique de
     * tous les éléments du tableau.
     * @param tableau Le tableau à traiter.
     */
    static void operation4(int[] tableau) {
        double somme = 0.0;
        for (int i = 0; i < tableau.length; i++) {
            somme = somme + tableau[i];
        }

        double moyenne = somme / tableau.length;
        System.out.println("La moyenne arithmetique des elements est " + moyenne);
    }

    /**
     * Cette méthode calcule et affiche le plus grand élément du tableau.
     * @param tableau Le tableau à traiter.
     */
    static void operation5(int[] tableau) {
        int max = tableau[0];
        for (int i = 1; i < tableau.length; i++) {
            if (tableau[i] > max) {
                max = tableau[i];
            }
        }
        System.out.println("Le plus grand element vaut " + max);
    }
}

 

[Précédent]
[Index] | [Enoncé] | [Version imprimable]
[Prochain]