Exercice algo java tableaux, Modularisation et algorithme

But:
Placer sans recouvrement des objets linéaires sur une grille carrée
Thème:
tableaux, Modularisation, algorithme

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();
}
}
}