Exercice opération sur les tableaux JAVA

Exercice 1

Exercer vos connaissances des tableaux de type int[] et des méthodes auxiliaires

tableaux, Modularisation

Le programme Operations.java vous permettra d'exercer vos connaissances des tableaux de type int[] et des méthodes auxiliaires. Etudiez le fonctionnement du programme et complétez-le comme demandé ci-après.

• Un tableau tab est construit et rempli de 10 valeurs. Le tableau est ensuite envoyé en paramètre à la méthode auxiliaire operations qui, à son tour, appelle 6 méthodes auxiliaires en leur envoyant le même tableau en paramètre. La première méthode, afficher, affiche les éléments du tableau sur une ligne. La deuxième méthode, operation1, calcule et affiche le nombre d'éléments de valeur 9. Les trois autres méthodes ne font rien pour l'instant, c'est à vous de les compléter.
• Un deuxième tableau tab1 est construit par l'intermédiaire de la méthode auxiliaire remplir1. Les éléments sont initialisés en ordre croissant de 0 à 4. Ensuite, la méthode auxiliaire operations est appelée pour effectuer les mêmes opérations sur ce deuxième tableau.
• Compléter les méthodes restantes comme suit:
  • remplir2: remplissage du tableau en ordre croissant à partir de 5.
  • remplir3: remplissage du tableau en ordre décroissant de nb à 1 où nb est le nombre d'éléments du tableau.
  • operation2: affichage du nombre d'éléments qui sont plus grands que 4 ou plus petits que 2.
  • operation3: affichage de la somme de tous les éléments du tableau.
  • operation4: affichage de la moyenne arithmétique de tous les d'éléments du tableau. La moyenne arithmétique est la somme de tous les éléments divisé par le nombre d'éléments. Faites attention à afficher le résultat sous forme de double.
  • operation5: affichage du plus grand élément du tableau.
  
  Exemple d'exécution du programme:

  3  7  1  9  2  8  9  1  2  5  
  Il y a 2 éléments de valeur 9 dans le tableau
  Il y a 7 éléments plus grand que 4 ou plus petit que 2
  La somme des éléments est 47
  La moyenne arithmétique des éléments est 4.7
  Le plus grand élément vaut: 9
  0  1  2  3  4  
  Il y a 0 éléments de valeur 9 dans le tableau
  Il y a 2 éléments plus grand que 4 ou plus petit que 2
  La somme des éléments est 10
  La moyenne arithmétique des éléments est 2.0
  Le plus grand élément vaut: 4
  5  6  7  8  9  10  11  12  13  14  
  Il y a 1 éléments de valeur 9 dans le tableau
  Il y a 10 éléments plus grand que 4 ou plus petit que 2
  La somme des éléments est 95
  La moyenne arithmétique des éléments est 9.5
  Le plus grand élément vaut: 14
  5  4  3  2  1  
  Il y a 0 éléments de valeur 9 dans le tableau
  Il y a 2 éléments plus grand que 4 ou plus petit que 2
  La somme des éléments est 15
  La moyenne arithmétique des éléments est 3.0
  Le plus grand élément vaut: 5
  

  Code donné:

   

  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

  class Operations { public static void main(String args[]) { // Construction d'un tableau: int[] tab = {3, 7, 1, 9, 2, 8, 9, 1, 2, 5}; // Opérations sur le tableau: operations(tab); // La même chose pour d'autres tableaux: int[] tab1 = remplir1(5); operations(tab1); int[] tab2 = remplir2(10); operations(tab2); int[] tab3 = remplir3(5); operations(tab3); } /**   * Cette méthode retourne un tableau int[] de nb éléments   * initialisés en ordre croissant de 0 à nb-1.   * @param nb   * @return   */ static int[] remplir1(int nb) { int[] tab = new int[nb]; for (int i = 0; i < nb; i++) { tab[i] = i; } return tab; } /**   * Cette méthode retourne un tableau int[] de nb éléments   * initialisés en ordre croissant à partir de 5.   * @param nb   * @return   */ static int[] remplir2(int nb) { int[] tab = new int[nb]; // A compléter return tab; } /**   * Cette méthode retourne un tableau int[] de nb éléments   * initialisés en ordre décroissant de nb à 1.   * @param nb   * @return   */ static int[] remplir3(int nb) { int[] tab = new int[nb]; // A compléter return tab; } static void operations(int[] tab) { afficher(tab); operation1(tab); operation2(tab); operation3(tab); operation4(tab); operation5(tab); } /**   * Cette méthode affiche tous les éléments du tableau reçu en   * paramètre sur une même ligne. Les éléments sont séparés par   * deux espaces.   * @param tab   */ static void afficher(int[] tab) { for (int i = 0; i < tab.length; i++) { System.out.print(tab[i]); System.out.print(" "); } System.out.println(); // Saut de ligne à la fin de l'affichage } /**   * Cette méthode calcule et affiche le nombre d'éléments de valeur   * 9 dans le tableau. La variable nb 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 tab   */ static void operation1(int[] tab) { int nb = 0; for (int i = 0; i < tab.length; i++) { if (tab[i] == 9) nb++; } System.out.println("Il y a " + nb + " éléments de valeur 9 dans le tableau"); } /**   * Cette méthode calcule et affiche le nombre d'éléments qui sont   * plus grand que 4 OU plus petit que 2.   * @param tab   */ static void operation2(int[] tab) { // A compléter } /**   * Cette méthode calcule et affiche le somme de tous les éléments du tableau.   * @param tab   */ static void operation3(int[] tab) { // A compléter } /**   * Cette méthode calcule et affiche la moyenne arithmétique de   * tous les éléments du tableau.   * @param tab   */ static void operation4(int[] tab) { // A compléter } /**   * Cette méthode calcule et affiche le plus grand élément du tableau.   * @param tab   */ static void operation5(int[] tab) { // A compléter } }

   

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

class Operations {
    public static void main(String args[]) {
        // Construction d'un tableau:
        int[] tab = {3, 7, 1, 9, 2, 8, 9, 1, 2, 5};
        // Opérations sur le tableau:
        operations(tab);

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

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

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

    /**
     * Cette méthode retourne un tableau int[] de nb éléments
     * initialisés en ordre croissant de 0 à nb-1.
     * @param nb
     * @return
     */
    static int[] remplir1(int nb) {
        int[] tab = new int[nb];
        for (int i = 0; i < nb; i++) {
            tab[i] = i;
        }
        return tab;
    }

    /**
     * Cette méthode retourne un tableau int[] de nb éléments
     * initialisés en ordre croissant à partir de 5.
     * @param nb
     * @return
     */
    static int[] remplir2(int nb) {
        int[] tab = new int[nb];
        for (int i = 0; i < nb; i++) {
            tab[i] = i + 5;
        }
        return tab;
    }

    /**
     * Cette méthode retourne un tableau int[] de nb éléments
     * initialisés en ordre décroissant de nb à 1.
     * @param nb
     * @return
     */
    static int[] remplir3(int nb) {
        int[] tab = new int[nb];
        for (int i = 0, j = nb; i < nb; i++, j--) {
            tab[i] = j;
        }
        return tab;
    }

    static void operations(int[] tab) {
        afficher(tab);
        operation1(tab);
        operation2(tab);
        operation3(tab);
        operation4(tab);
        operation5(tab);
    }

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

    /**
     * Cette méthode calcule et affiche le nombre d'éléments de valeur
     * 9 dans le tableau. La variable nb 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 tab
     */
    static void operation1(int[] tab) {
        int nb = 0;
        for (int i = 0; i < tab.length; i++) {
            if (tab[i] == 9)
                nb++;
        }
        System.out.println("Il y a " + nb + " éléments de valeur 9 dans le tableau");
    }

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

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

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

        double moyenne = somme / tab.length;
        System.out.println("La moyenne arithmétique des éléments est " + moyenne);
    }

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

 Exercice 2 :

Ecrivez un programme qui calcule le produit scalaire de deux vecteurs

Tableaux

Écrivez un programme Scalaire.java qui calcule le produit scalaire de deux vecteurs, implémentés au moyen de tableaux unidimensionnels. Votre programme devra utiliser (entre autre) les éléments suivants :

• Déclarations dans la méthode main():
  • une variable nMax représentant la taille maximale des vecteurs (inutile de lui donner une valeur trop élevée... 10 suffit amplement)
  • deux variables v1 et v2, de type tableau de réels de taille nMax.
• Méthode :
  • demander à l'utilisateur d'entrer n, la taille effective des vecteurs.
  • vérifier que n est compris entre 1 et nMax et demander à l'utilisateur d'entrer à nouveau une valeur tant que ce n'est pas le cas
  • demander à l'utilisateur les composantes (v1₀... v1_n-1 , v2₀ ... v2_n-1) des vecteurs v1 et v2.
  • calculer le produit scalaire de v1 et v2.
  • afficher le résultat.

Rappel :
Le produit scalaire de a par b est: a·b = a₁*b₁ + a₂*b₂ + ... + a_n*b_n

Exemple: a = (5, 3, -1)   b = (2, 1, 2)   a·b = 11

Les tableaux, ici à une dimension, sont typiquement parcourus au moyen de boucles for. Ces boucles sont utilisées pour remplir les vecteurs (par lecture de doubles) et pour effectuer le calcul du produit scalaire. La principale chose à remarquer ici est qu'avec les moyens à disposition au moment de la série, on ne sait pas réutiliser des portions de code lorsqu'elles sont requises à plusieurs endroits du programme (exemple: la lecture des vecteurs). Ceci implique que le code concerné est tout simplement dupliqué. Nous verrons à partir du cours prochain comment améliorer cet état de choses.

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

import java.util.Scanner;
class Scalaire {
    private static Scanner scanner = new Scanner(System.in);

    public static void main(String[] args) {
        int nMax = 10;
        int n;

        // On exige l'introduction d'un entier entre 0 et 10
        do {
            System.out.print("Quelle taille pour vos vecteurs [entre 1 et  " 
                     + nMax + "] ? ");
            n = scanner.nextInt();
        } while (n < 1 || n > nMax);

        // Déclaration-construction des deux vecteurs
        double [] v1 = new double [n];
        double [] v2 = new double [n];

        System.out.println("Saisie du premier vecteur :");
        for (int i = 0; i < n; i++) {
            System.out.print(" v1[" + i + "] = ");
            v1[i] = scanner.nextDouble();
        }

        System.out.println("Saisie du second vecteur :");
        for (int i = 0; i < n; i++) {
            System.out.print(" v2[" + i + "] = ");
            v2[i] = scanner.nextDouble();
        }

        // Calcul du produit scalaire
        double somme = 0.0;
        for (int i = 0; i < v1.length; i++) {
            somme += v1[i] * v2[i];
        }

        System.out.println("Le produit scalaire de v1 par v2 vaut " 
                   + somme);
    }
}

Exercice 3 JAVA multiplication de matrices - tableaux

 But:

On cherche ici à écrire un programme qui calcule le produit de deux matrices

Tableaux

On cherche ici à écrire un programme MulMat.java qui calcule la multiplication de deux matrices (rappel ci-dessous).

Vous utiliserez pour représenter la matrice un tableau de tableaux de double.

Déclarations :

• Dans la méthode main, déclarez deux matrices mat1 et mat2.

Traitements :

• Lire depuis le clavier les éléments de chacune des deux matrices (après avoir demandé leurs dimensions).

• Multiplier les deux matrices et stocker le résultat dans une nouvelle matrice prod.

• Afficher le contenu de cette nouvelle matrice ligne par ligne.

Méthode :

• Lire depuis le clavier les dimensions lignes (nombre de lignes) et colonnes (nombre de colonnes) de la première matrice mat1
• Lire le contenu de mat1.
• De même, lire les dimensions puis le contenu de la seconde matrice mat2.
• Vérifier que le nombre de lignes de mat2 est identique au nombre de colonnes de mat1.
  Dans le cas contraire, afficher un message d'erreur "Multiplication de matrices impossible !". (rappel: si l'on multiplie deux matrices M = M1*M2, les dimensions de M sont "nombre de lignes de M1" et "nombre de colonnes de M2", et l'élément M_i,j est défini par
• afficher le résultat ligne par ligne.

Exemple d'utilisation:

Saisie de la 1ère matrice :
  Nombre de lignes : 2
  Nombre de colonnes : 3
  M[1,1]=1.0
  M[1,2]=2.0
  M[1,3]=3.0
  M[2,1]=4.0
  M[2,2]=5.0
  M[2,3]=6.0
Saisie de la 2ème matrice :
  Nombre de lignes : 3
  Nombre de colonnes : 4
  M[1,1]=1.0
  M[1,2]=2.0
  M[1,3]=3.0
  M[1,4]=4.0
  M[2,1]=5.0
  M[2,2]=6.0
  M[2,3]=7.0
  M[2,4]=8.0
  M[3,1]=9.0
  M[3,2]=0.0
  M[3,3]=1.0
  M[3,4]=2.0
Résultat :
38.0 14.0 20.0 26.0
83.0 38.0 53.0 68.0

Encore un tableau à deux dimensions, mais cette fois il y a plusieurs tests d'intégrité à effectuer (taille non-nulle des matrices, matrices de tailles compatibles pour la mutliplication etc...)
La remarque faite lors des deux exercices précédents est valable ici aussi: des parties importantes du codes sont dupliquées. La série 5 vous permettra de reprendre ce code en remédiant à cette situation.

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

import java.util.Scanner;
class MulMat {
    private static Scanner scanner = new Scanner(System.in);

    public static void main(String[] args) {

        int lignes = 0;
        int colonnes = 0;

        // Saisie de la 1ère matrice
       System.out.println("Saisie de la 1ere matrice :");

        // On vérifie que le nombre de lignes est plus grand 
        // que 0
        do {
           System.out.print("  Nombre de lignes : ");
            lignes = scanner.nextInt();
        } while (lignes < 1);

        // On vérifie que le nombre de colonnes est plus grand 
        // que 0
        do {
           System.out.print("  Nombre de colonnes : ");
            colonnes = scanner.nextInt();
        } while (colonnes < 1);

        // Déclaration-construction de la 1ère matrice
        double[][] mat1 = new double[lignes][colonnes];
        for (int row = 0; row < lignes; row++) {
            for (int col = 0; col < colonnes; col++) {
               System.out.print("  M[" + (row + 1) + "," 
                         + (col + 1) + "]=");
                mat1[row][col] = scanner.nextDouble();
            }
        }


        // ... et on refait la même chose pour la 2ème matrice
       System.out.println("Saisie de la 2eme matrice :");
        do {
           System.out.print("  Nombre de lignes : ");
            lignes = scanner.nextInt();
        } while (lignes < 1);

        do {
           System.out.print("  Nombre de colonnes : ");
            colonnes = scanner.nextInt();
        } while (colonnes < 1);

        double[][] mat2 = new double[lignes][colonnes];
        for (int row = 0; row < lignes; row++) {
            for (int col = 0; col < colonnes; col++) {
               System.out.print("  M[" + (row + 1) + "," 
                         + (col + 1) + "]=");
                mat2[row][col] = scanner.nextDouble();
            }
        }

        // Ici on multiplie les matrices
        if (mat1[0].length != mat2.length) {
           System.out.println("Multiplication de matrices " +
                       "impossible !");
        } else {
            // Déclaration-construction de la matrice résultat
            double[][] prod = 
              new double[mat1.length][mat2[0].length];
            for (int row = 0; row < mat1.length; row++) {
                for (int col = 0; col < mat2[0].length; col++) {
                    prod[row][col] = 0.0;
                    for (int i = 0; i < mat2.length; i++) {
                        prod[row][col] += mat1[row][i] * 
                          mat2[i][col];
                    }
                }
            }

            // Affichage du résultat
           System.out.println("Résultat :");
            for (int row = 0; row < prod.length; row++) {
                for (int col = 0; col < prod[row].length; col++) {
                   System.out.print(prod[row][col] + " ");
                }
               System.out.println();
            }
        }
    }
}

 Exercice 4

Le but de cet exercice est de placer sans recouvrement (i.e. on ne peut plus utiliser une case déjà utilisée) des objets linéaires sur une grille carrée. Cela pourrait être par exemple une partie d'un programme de bataille navale. Vous considérerez que la grille est de taille 10 x 10.

Dans le fichier Recouvrement.java :

1. Ecrivez une méthode auxiliaire  :

   static boolean remplitGrille(boolean [][] grille,
   		   int ligne, int colonne,
                      char direction, int longueur);

   dont le rôle est de vérifier si le placement dans une grille (voir ci-dessous) d'un objet de dimension longueur est possible, en partant de la coordonnée (ligne,colonne) et dans la direction définie par direction (Nord, Sud, Est ou Ouest).
   
   Si le placement est possible, la méthode devra de plus effectuer ce placement (voir ci-dessous la description de la grille).

   La méthode devra indiquer (par la valeur de retour) si le placement a pu être réalisé ou non.
   
   

2. Dans la méthode main
   • Définissez une variable nommée grille, correspondant à un tableau de booléens, de taille fixe, à deux dimensions, avec dim comme paramètre de taille pour chaque dimension (on a donc une grille carrée).
     La valeur true dans une case [i][j] de cette grille représente le fait qu'un (bout d')objet occupe la case de coordonnées (i, i).
   • Utilisez la méthode précédente pour remplir interactivement la grille, en demandant à l'utilisateur de spécifier la position, la taille et la direction des objets à placer.
     Indiquez à chaque fois à l'utilisateur si l'élément a pu ou non être placé dans la grille.
     Le remplissage se termine lorsque l'utilisateur entre une longueur strictement inférieure à 0.
   • Terminer alors en "dessinant" la grille : afficher un '.' si la case est vide et un '#' si la case est occupée.

Remarques :

• Dans l'interface utilisateur, pour indiquer les positions, utilisez au choix soit les coordonnées de Java  : 0 à taille de la grille -1 (plus facile), soit les coordonnées usuelles (1 à taille de la grille, un peu plus difficile) ,
• Pensez à effectuer des tests de validité sur les valeurs entrées (débordement du tableau).
• pour représenter la direction, vous pouvez utiliser un caractère ('N' pour nord. 'S' pour sud, etc...)
• N'oubliez pas d'initialiser la grille en tout début de programme !

Exemple de fonctionnement :

Entrez la taille (négative pour arrêter le programme): 3
Entrez coord. x : 0
Entrez coord. y : 0
Entrez direction (N,S,E,O) : S
Placement en (0,0) direction S longueur 3 -> Succès
#.........
#.........
#.........
..........
..........
..........
..........
..........
..........
..........

Entrez la taille (négative pour arrêter le programme): 5
Entrez coord. x : 2
Entrez coord. y : 4
Entrez direction (N,S,E,O) : N
Placement en (2,4) direction N longueur 5 -> Echec

Entrez la taille (négative pour arrêter le programme): 5
Entrez coord. x : 2
Entrez coord. y : 4
Entrez direction (N,S,E,O) : E
Placement en (2,4) direction E longueur 5 -> Succès
#.........
#.........
#...#####.
..........
..........
..........
..........
..........
..........
..........

Entrez la taille (négative pour arrêter le programme): -1

Merci d'avoir joué!

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
162
163
164
165
166
167
168
169
170

import java.util.Scanner;
class Recouvrement {
    private static Scanner scanner = new Scanner(.in);

  public static void main([] args) {
    boolean [][] grille = new boolean [10][10];
    initGrille(grille);
    ajouterElements(grille);
    .out.println("\nMerci d'avoir joué!");
  }
  /**
   * Essaie de remplir la grille avec un objet de longueur donnée
   * dans une direction donnée en partant des coordonnées 
   * (targetRow, targetCol). 
   * @param grille
   * @param targetRow
   * @param targetCol
   * @param direction
   * @param longueur
   * @return true si le placement est réussi et false sinon
   */
  static boolean remplitGrille(boolean [][] grille, int targetRow, 
                   int targetCol, char direction, 
                   int longueur) {

    int deltaRow = 0, deltaCol = 0;
    int dim = grille.length;

    // On calcule ici la direction dans laquelle aller depuis 
    // les coordonnées indiquées par l'utilisateur.
    // Ex: pour aller au nord, il faut monter d'une 
    // ligne en restant sur la
    // même colonne.
    switch (direction) {
    case 'N':
      deltaRow = -1;
      deltaCol = 0;
      break;
    case 'S':
      deltaRow = 1;
      deltaCol = 0;
      break;
    case 'E':
      deltaRow = 0;
      deltaCol = 1;
      break;
    case 'O':
      deltaRow = 0;
      deltaCol = -1;
      break;
    }

    // On se place sur la case de départ
    int tempRow = targetRow;
    int tempCol = targetCol;

    // Est-il possible de placer l'élément ?
    boolean possible = true;

    // Avant de modifier la grille il faut vérifier s'il est 
    // possible de mettre tout l'objet
    for (int i = 0; (i < longueur && possible); i++) {
      if ((tempRow < 0) || (tempRow >= dim)) {
        possible = false;
      }
      else if ((tempCol < 0) || (tempCol >= dim)) {
    possible = false;
      } else  if (grille [tempRow][tempCol]) {
        possible = false;
      }

      // On se déplace sur la case suivante
      tempRow += deltaRow;
      tempCol += deltaCol;
    }

    // Le placement est possible, et on peut donc mettre
    // à jour la grille
    if (possible) {
      tempRow = targetRow;
      tempCol = targetCol;

      for (int i = 0; i < longueur; i++) {
        grille [tempRow][tempCol] = true;
        tempRow += deltaRow;
        tempCol += deltaCol;
      }
    }

    return possible;
  }

  /**
   * Initialise toutes les cases de la grille à false
   * @param grille
   */
  static void initGrille(boolean[][] grille) {
    int dim = grille.length;
    for (int row = 0; row < dim; row++) {
      for (int col = 0; col < dim; col++) {
        grille[row][col] = false;
      }
    }
  }

  /**
   * Permet à l'utilisateur de demander le placement d'objets
   * sur la grille.
   * @param grille
   */
  static void ajouterElements(boolean[][] grille) {
    int col, row;
    char dir;
    int length;
  .out.print("Entrez la taille  " +
             "(négative pour arrêter le programme): ");
    length = scanner.nextInt();
    // L'utilisateur signifie qu'il veut arrêter 
    // d'introduire des objets en spécifiant une 
    //longueur négative
    while (length >= 0) {
      do {
       System.out.print("Entrez coord. x : ");
        col = scanner.nextInt();
      } while ((col < 0) || (col >= grille.length));

      do {
       System.out.print("Entrez coord. y : ");
        row = scanner.nextInt();
      } while ((row < 0) ||(row >= grille.length));

      do {
       System.out.print("Entrez direction (N,S,E,O) : ");
        dir = scanner.next().charAt(0);
      } while ((dir != 'N') && (dir != 'S') && (dir != 'E') && (dir != 'O'));

      .out.print("Placement en (" + col + "," + row + ") direction " 
               + dir + " longueur " + length + " -> ");

      if (remplitGrille(grille, col, row, dir, length)) {
       System.out.println("Succès");
        afficheGrille(grille);
      } else {
       System.out.println("Echec");
      }
     System.out.println(); 
     System.out.print("Entrez la taille " +
               "(négative pour arrêter le programme): ");
      length = scanner.nextInt();

    }
  }

  /**
   * Affichage de la grille
   * @param grille
   */
  static void afficheGrille(boolean[][] grille) {
    int dim = grille.length;
    for (int row = 0; row < dim; row++) {
      for (int col = 0; col < dim; col++) {
        if (grille[row][col])
         System.out.print("#");
        else
         System.out.print(".");
      }
     System.out.println();
    }
  }
}