Mini-projet : Sudoku

Mini-projet : Sudoku
A. Présentation :
Ce mini-projet est basé sur le langage Java. L’interface utilisée pour développer notre programme est l’application Eclipse qui nous permettra de saisir le code, de compiler le programme et ainsi de le tester.
L’idée du projet est de proposer une interface permettant de manipuler des grilles de Sudoku.
Une partie du programme, la partie graphique, a déjà été crée est incluse dans le package
sudoko.jar.
Le but de ce mini-projet est d’ajouter des fonctionnalités afin d’obtenir des actions sur les
grilles de Sudoku comme :
Vérifier qu’une grille de Sudoku est juste ou fausse ;
Montrer les valeurs possibles à assigner à une case vide en fonction des autres cases déjà
saisies ;
Compléter correctement une grille partiellement remplie.
Toutes ces fonctionnalités ne sont pas nécessairement à concevoir et dépendront de votre
engagement et de vos progrès.
Java est un langage de programmation orienté-objet : ce concept est un peu dur à comprendre
et par souci de simplicité, certains aspects de ce langage de programmation ont été “cachées”
grâce à l’utilisation du package “sudoko.jar”.
B. Configuration d’Eclipse :
Créer un dossier sur le bureau s’appelant miniProjet.
Suivez les instructions suivantes :
1. Lancez Eclipse. A son lancement, il vous demandera le dossier racine de votre projet (Fig
3) : saisissez le nom de dossier suivant :
/homePoint/eleves/votreLogin//miniProjet
C’est ce dossier qui contiendra notre projet.
2. On crée notre projet en exécutant la commande :
File ⇝ New ⇝ Project
Dans la boite à dialogue, choisissez l’option “Java Project” (Fig 3).
3. Dans la boite à dialogue suivante (Fig 3), saisissez le mot “SudokuMiniProjet” en respectant les majuscules et les miniscules : ce sera le nom de notre projet. Puis, vérifier que les
options sélectionnées soient les mêmes que sur la figure 3.
http://chingatome.net
Fig. 3
Fig. 3
Fig. 3
4. Eclipse vous demande ensuite si vous souhaitez charger
les outils pour construire votre programme en Java :
Acceptez, puis fermez complètement Eclipse (Fig ??).
Fig. ??
5. Vous trouverez dans votre lecteur réseau (dossier “Fichier pour la classe - Castanet/Math”)
les deux fichiers “SudokuMiniProjet.java” et “sudoku.jar” que vous déplacerez en suivant
les instructions suivantes : :
Le fichier SudokuMiniProjet.java
dans le dossier /home/user/Bureau/miniprojet/SudokuMiniProjet/src/
Le fichier sudoku.jar
dans le dossier /home/user/Bureau/miniprojet/SudokuMiniProjet/.
6. Relancez Eclipse. Voici l’apparence initiale de votre espace de travail (Fig ??) :
Fig. ??
Fig. ??
http://chingatome.net
Fig. ??
Fig. ??
Fig. ??
Fermez les deux fenêtes “Outline” et “Welcome” qu’on n’utilisera pas : votre espace de
travail doit maintenant avoir l’apparence de la figure ??.
7. On se concentre sur le panneau latéral “Package Explorer” de gauche (Fig ??)
a. Voici son apparence initiale (Fig ??).
b. Sélectionnez le dossier “src” et cliquez sur
la touche “F5” de votre clavier. Vous remarquerez que des croix rouges indiques des erreurs (Fig ??).
c. Faites un clic-droit sur le nom de votre
projet “SudokuMiniProjet” et choisissez
la commande Properties. Actionnez la
commande (Fig ??) :
Java Build Path ⇝ Librairies ⇝ Add JARs
Et sélectionnez le fichier “sudoku.jar”.
Fig. ??
d. Remarquez que le panneau latéral “Package Explorer” ne présente plus d’erreurs (Fig
??).
8. Vous pouvez alors lancer cette application en lançant sur le bouton
barre des outils en haut de la fenêtre d’Eclipse.
présent dans la
C. L’application "sudoku.jar" :
Pour lancer l’application “sudoku.jar”, votre ordinateur doit posséder le logiciel Java-JRE
(Java Runtime Environment).
Lors de son lancement, le package “sudoku.jar” génère une grille de Sudoku vide (Fig ??) et
lors d’un clic sur une case, un clavier permet de choisir le nombre à écrire dans celle-ci (Fig
??).
Dans la barre des menus :
Les commandes Nouveau, Ouvrir et Sauv offrent les possibilités respectives suivantes réinitialiser la grille du Sudoku, charger une grille précédemment enregistrée et sauvegarder
une grille dans un fichier (Fig ??).
Les commandes ActionA, ActionB, ActionC et ActionD n’ont pour l’instant aucune action
particulière et seront à modifier tout au long du mini-projet.
http://chingatome.net
Fig. ??
Fig. ??
Fig. ??
Le package “sudoku.jar” contient toute l’interface graphique permettant le développement de
notre jeu Sudoku.
D. Le fichier “SudokuMiniProjet.java” :
Dans le panneau latéral du “Package Explorer”, observez la présence du fichier SudokuMiniProjet.java (Fig ??). En double-cliquant sur ce fichier, Eclipse va en afficher son contenu :
1
public class SudokuMiniProjet extends Sudoku {
2
3
4
5
public static void main ( String [ ] args ) {
new SudokuMiniProjet (3) ;
}
6
7
8
9
public SudokuMiniProjet ( int ord ) {
super ( ord ) ;
}
10
11
public void f o n c t i o n A () {
12
13
}
14
15
public void f o n c t i o n B () {
16
17
}
18
19
public void f o n c t i o n C () {
20
21
}
22
23
public void f o n c t i o n D () {
http://chingatome.net
24
}
25
26
}
Le but du mini-projet n’est pas d’apprendre toute la structure d’un programme écrit en Java
mais de modifier certaines parties du programme afin d’obtenir les fonctionnalités visées (voir
page ??).
Pour cela, on ne modifiera que le contenu des fonctions fonctionA, fonctionB, fonctionC
et fonctionD et on activera ces fonctions à partir du menu de notre application (commande
ActionA, ActionB, ActionC et ActionD) ; le reste du code restera identique tout au long de
notre projet.
Mais, afin d’éclairer un peu le contenu de ce fichier, voici quelques remarques :
On remarquera que l’accolade ouvrante de la ligne 1 se termine à la ligne 28 ;
Dans un premier temps dans l’apprentissage du langage Java, il est préférable de faire
abstraction des mot-cléfs public, static et void.
Ainsi, les lignes de 3 à 5 peuvent se lire :
1
2
3
main ( String [ ] args ) {
new SudokuMiniProjet (3) ;
}
La fonction main() est importante dans le code car c’est elle qui s’exécutera lorsque vous
lancerez l’application “SudokuMiniProjet.jar”.
Mais, ces trois lignes ne seront jamais modifiées pendant notre projet.
La première ligne peut se lire :
1
class SudokuMiniProjet extends Sudoku {
Cela signifie que le code de “SudokoMiniProjet” va prolonger celui de “Sudoku” : on possèdera l’interface graphique de la grille Sudoku et on pourra lui rajouter de nouvelles
fonctionnalités.
Les lignes 7 à 9 indique le moment de la création de l’objet représentant notre application : la fenêtre et son menu, la grille vide du Sudoku, du clavier et des interactions avec
l’utilisateur.
E. Travaux dirigés :
Voici quelques petits exercices et des explications autour de l’utilisation du package “Sudoku.jar”
Exercice 1
1. Rajoutez dans le corps de la fonction SudokuMiniProjet(), les deux commandes suivantes :
http://chingatome.net
fonctionOuvrir("/home/user/sudoku-1.sudo");
caseCouleur(3,2,true);
Ainsi, cette partie du code devra ressembler à :
1
2
3
4
5
public SudokuMiniProjet ( int ord ) {
super ( ord ) ;
fonctionOuvrir ("/ homePoint / e l e v e s / v o t r e L o g i n / sudoku -1.←sudo ") ;
caseCouleur (3 ,2 , true ) ;
}
2. a. Lancer l’application en appuyant sur le bouton
de compilation.
b. Quelles différences ont apportées ces deux lignes rajoutées ?
...........................................................................................
...........................................................................................
...........................................................................................
...........................................................................................
c. Pouvez-vous justifier le message d’erreur indiquant “le fichier indiqué n’existe pas” ?
...........................................................................................
...........................................................................................
On peut remarquer que les deux fonctions rajoutées s’exécutenet dès le lancement de
l’application. Cela est dû à l’emplacement de ce code : tout ce qui se trouve dans la
fonction SudokuMiniProjet sera exécuté dès le lancement de l’application :
La première fonction fonctionOuvrir() essaye d’ouvrir le fichier se situant à l’emplacement :
/homePoint/eleves/votreLogin/sudoku-1.sudo
Mais ce fichier n’existant pas sur votre ordinateur, l’application indique un message
d’erreur.
L’appel caseCouleur(3,2,true) va colorier la case se situant à l’intersection de la
troisième ligne et de la seconde colonne de la grille du Sudoku.
3. Déplacer ces deux fonctions de la fonction SudokuMiniProjet() vers la fonction fonctionA().
Puis, relancer l’application ( ).
a. Quelle première différence réalise ce déplacement du code ?
...........................................................................................
...........................................................................................
b. En relisant la page ??, comment doit-on faire pour exécuter ces deux fonctions ?
...........................................................................................
http://chingatome.net
...........................................................................................
Pour que la fonction fonctionA() s’exécute, il faut que l’utilisateur actionne la commande ActionA dans le menu de la fenêtre de notre application.
Exercice 2
Le package “Sudoku.jar” propose de nombreuses commandes permettant de modifier la grille Sudoku qui sera proposé à l’utilisateur.
1. Pour connaitre la liste des fonctions accessibles pour modifier
notre grille, allez dans le corps de la fonction fonctionA() et
saissisez les cinq caractères suivants this. (avec le point).
Eclipse vous affichera alors la liste des commandes disponibles dans une liste représentée par la figure ??.
2. Dans la liste des documents fournis avec ce mini-projet, vous
trouverez l’archive “javaDoc.zip”. Décompresser cette archive
et ouvrez le fichier “index.html”.
Lisez cette page Web qui décrit toutes les fonctions qui vous
permettront de construire votre mini-projet.
Fig. ??
Le mot-clef this, si il est saisi dans une fonction de la classe SudokuMiniProjet
représente cette classe elle-même et permettra d’accéder à toutes les fonctionnalités de
cette classe (variables et fonctions).
F. Le mini-projet :
Voilà, c’est maintenant à vous de développer les fonctionnalités suivantes de notre application :
Vérification d’une grille :
La fonction fonctionA() doit contenir le code qui vérifie qu’une grille de Sudoku est
remplie correctement ou non. En cas d’erreur, cette fonction doit colorier soit la ligne, soit
la colonne, soit la case mettant en défaut la grille Sudoku.
On utilisera les fichiers suivants comme grille de test :
“sudoku-2.sudo” présente une grille correctement remplie ;
“sudoku-3.sudo” présente une grille incorrectement remplie.
Voici l’algorithme en français permettant de vérifier que la véracité de la ligne i :
1
2
3
D Ã ľc l a r e r une v a r i a b l e v e r i f de type " t a b l e a u de ←boolean " contenant 9 v a l e u r s .
Pour j a l l a n t de 1 jusqu ’a 9
v e r i f [ j ]= faux ;
http://chingatome.net
4
Fin pour
5
6
7
8
9
Pour j a l l a n t de 1 jusqu ’a 9
La v a r i a b l e x r e c u p e r e l a v a l e u r de l a c a s e ( i , j ) ;
La v a r i a b l e v e r i f [x] prend l a v a l e u r v r a i e
Fin pour
10
11
12
13
S i t o u t e s l e s v a l e u r s de v e r i f s o n t v r a i e
A l o r s a f f i c h e r " Ligne c o r r e c t e "
Sinon a f f i c h e r " Ligne f a u s s e "
Voici quelques outils à utiliser pour créer cette fonction :
La variable ordre permet de récupérer la taille du tableau (dans notre test sa valeur
sera toujours 3) ;
La fonction caseValeur(lig,col) permet de récupérer le nombre contenu dans la
case se trouvant à l’intersection de la ligne lig et de la colonne col ;
La fonction caseCouleur(lig,col,true-false) permet de colorier ou non
true-false la case se situant à la ligne lig et à la colonne col ;
La fonction afficheMessage(chaine) permet d’afficher un message dans un boîte à
dialogue.
Aide à la saisie des valeurs :
Pour aider l’utilisateur à remplir sa grille, nous allons modifier le comportement du clavier
en lui demandant de n’afficher que les valeurs possibles pour la case sélectionnée.
Pour cela, nous devons rajouter une nouvelle fonction qui modifiera le comportement
du package “sudoku.jar”.
A la suite de la fonction fonctionD(), rajoutez la nouvelle commande :
1
2
3
public int clavierChoixBouton ( int l i g , int c o l ) {
return 511;
}
Cette fonction renvoit pour l’instant le nombre 511 qui admet pour écriture binaire :
10
2
511 = 111111111
Ces neufs bits ayant la valeur “1”, le clavier affichera tous les nombres allant de 1 à 9.
Voici quelques exemples qui vous permettront de comprendre l’utilité du nombre retourné par cette fonction :
10
2
Si cette fonction retourne toujours la valeur 1 (1 = 1 ), le clavier n’affichera que la
valeur 1.
10
2
Si cette fonction retourne toujours la valeurs 13 (13 = 1101 ), seul les nombres 1, 3
http://chingatome.net
et 4 s’afficheront dans le clavier.
La valeur des paramètres lig et col représente la ligne et la colonne de la case sur
laquelle l’utilisateur vient de cliquer : permettant ainsi de récupérer toutes les valeurs
des lignes, colonnes pour déduire les valeurs possibles restantes pour la case cliquée.
Compléter une grille de Sudoku :
Cette partie est la plus dure, il faudra créer une fonction (dîte récursive) qui complètera
le tableau à la recherche de la grille correctement complétée.
Voici quelques élèments pour créer cette fonctionnalité :
Il faut créer une fonction qui prend les données de la grille pour argument, qui recherche la première case libre et qui complète cette case par une de ses valeurs possibles.
Voici la structure d’une telle fonction :
1
2
3
4
5
public void r e c u r r e n c e ( int [ ] [ ] t a b l e a u ) {
int [ ] [ ] nouveauTableau ;
....
return nouveauTableau ;
}
Pour que la récursivité fonctionne correctement en Java, il faut commencer par copier
le tableau actuel dans un nouveau tableau. Pour cela, on utilisera la commande :
1
g r i l l e C o p i e ( t a b l e a u , nouveauTableau ) ;
G. Annexe :
Sudoku(int tailleGrille)
Ce constructeur génÃĺre la grille Sudoku et l’affiche à l’écran Le paramÃĺtre tailleGrille
définit la taille de la grille Sudoku
protected void
affichageActualise()
En cas de modification de la valeur de cases de la grille, cette commande permet de rafraichir
son affichage.
protected void
affichageReinitialise()
Cette commande permet d’effacer toutes les valeurs des cases et rafraîchit l’affichage.
protected void
afficheMessage(java.lang.String message)
Cette méthode permet d’afficher une boîte à dialogue contenant un message à destination
de l’utilisateur de la grille Sudoku.
protected void
caseCouleur(int lig, int col, boolean couleur)
Cette méthode permet de modifier la couleur de fond de la case sélectionnée.
http://chingatome.net
protected void
caseEcrit(int lig, int col, java.lang.String valeur)
protected void
caseValeurEcrit(int lig, int col, int valeur)
Cette méthode permet de changer la valeur de la case se situant à l’intersection de la ligne
"lig" et de la colonne "col".
protected int
caseValeurLit(int lig, int col)
Cette méthode permet de retourner la valeur de la case se trouvant à l’intersection de ligne
"lig" et de la colonne "col".
protected int
clavierChoixNombre(int lig, int col)
Lors du clic sur une case, la classe Sudoku affiche un clavier facilitant la saisie.
protected void
fonctionA()
Cette méthode est actionnée lorsque l’utilisateur clique sur la commande "Action A" de la
barre de menu.
protected void
fonctionB()
Cette méthode est actionnée lorsque l’utilisateur clique sur la commande "Action B" de la
barre de menu.
protected void
fonctionC()
Cette méthode est actionnée lorsque l’utilisateur clique sur la commande "Action C" de la
barre de menu.
protected void
fonctionD()
Cette méthode est actionnée lorsque l’utilisateur clique sur la commande "Action D" de la
barre de menu.
protected boolean fonctionOuvrir(java.lang.String cheminFichier)
Cette méthode permet de charger un fichier (.sudo) contenant la sauvegarde d’une grille.
protected boolean fonctionSauvegarde(java.lang.String cheminFichier)
Cette méthode permet de sauvegarder la grille actuelle dans un fichier.
void
grilleChangeValeurs(int[ ][ ] v)
Cette méthode prend un nouveau tableau d’entier pour l’afficher dans la grille actuelle.
void
grilleCopie(int[ ][ ] original, int[ ][ ] destination)
Cette méthode permet de palier à un défaut de Java : la duplication de tableaux.
int[ ][ ]
grilleRecupereValeurs()
Cette méthode permet de retourner le tableau d’entiers (de dimension ordre x ordre) représentant la grille Sudoku dans sa configuration actuelle.
static void
main(java.lang.String[ ] args)
Cette commande permet de lancer les premières instructions lorsque l’application se lance.
http://chingatome.net