Besoin d'aide pour un cours d'initiation à la programmation JAVA! (Sudoku) Merci! :)

Bonjour,

Je suis en train de suivre un cours d'initiation à la programmation JAVA et je me bute à ce TP depuis plusieurs semaines. Je ne comprends pas grand chose et j'ai besoin d'aide pour regarder mon code et peut-être me remettre sur le droit chemin!! Le TP n'est pas très clair à la base :( ce qui n'aide pas non plus!

Si quelqu'un peut m'aider à y voir clair!!

merci!!!

Créer des classes
Le programme devra être développé autour de plusieurs classes soit :

tp4.java permettant de démarrer le programme. Cette classe aura une méthode main qui devra faire comme actions :
Créer une instance de la classe Sudoku9x9;
Imprimer la grille de Sudoku original;
Imprimer le degré de difficulté de la grille;
Effectuer 10 placements;
Imprimer la grille de Sudoku suite aux placements;
Annuler 2 placements;
Imprimer la grille de Sudoku suite à l’annulation;
Valider la solution et imprimer le résultat de la validation.
Sudoku.java, une classe abstraite représentant la notion abstraite de grille de Sudoku et des méthodes communes à tous les sous-types de grille de Sudoku. Elle aura donc comme attribut :
Une matrice de nombre entier (int[][]) représentant la grille de Sudoku
Une liste d’action de placement (Une ArrayList de classe Placement (voir plus bas))
Le degré de complexité de la grille (int)
L’attribut placement (int) indiquant le nombre de chiffre restant à placer dans la grille
Elle aura comme méthodes abstraites ou non :

Initialiser une grille
Réinitialiser la grille (revenir à la grille de Sudoku originale) à l’aide de la liste de placements effectués. Vous devez concevoir la solution par vous-même!
Tester la validité de la solution (voir code en annexe)
Faire un placement (voir plus bas au point 5)
Annuler un placement (voir plus bas au point 5)
Méthodes get et set pour accéder aux attributs de classes (attention à la visibilité des méthodes, c.a.d. public, private, protected).
Imprimer la grille
Sudoku9x9.java, une sous-classe de Sudoku.java qui implémente les méthodes spécifiques à un Sudoku9x9, soit :
Les sous-implémentations des méthodes abstraites de la classe Sudoku.java
Toutes autres méthodes nécessaires pour effectuer le mandat
Case.java, une classe représentant une case de la grille. Cette classe sera utilisée par la méthode placement et annuler placement afin de garder un trace des actions sur la grille de jeu. À vous de déterminer quels sont ces attributs et méthodes pour répondre aux besoins de la problématique. À vous également de spécifier sa visibilité et de la justifier.
Créer des appels de méthodes
Au travers de votre conception orientée-objet, répondant à la problématique, les différentes instances de classes auront à interagir entre elles. Elles s’échangeront des appels de méthodes permettant de répondre aux besoins du mandat, soit (rappel du comportement de la classe tp2.java) :

Créer une instance de la classe Sudoku9x9;
Imprimer la grille de Sudoku original;
Imprimer le degré de difficulté de la grille;
Effectuer 10 placements;
Imprimer la grille de Sudoku suite aux placements;
Annuler 2 placements;
Imprimer la grille de Sudoku suite à l’annulation;
Valider la solution et imprimer le résultat de la validation.
Faire et annuler des placements
Grâce à la classe Case, il est possible de sauvegarder une trace des actions du joueur sur la grille. À l’aide de la méthode, fairePlacement, vous aurez à (1) effectuer le placement sur la grille; (2) sauvegarder le placement (c’est à dire l’instance de la classe Case) dans un structure de type ArrayList..

À l’aide de la méthode annulerPlacement, vous aurez à (1) récupérer la dernière instance dans l’arraylist (en utilisant la méthode remove et la méthode size pour connaître le nombre d’élément) et (2) annuler le placement dans la grille.

Pour plus d’information sur les ArrayList, aller à la page : http://docs.oracle.com/javase/7/docs...ArrayList.html (en anglais seulement).

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
Code de validation de la grille Sudoku
public boolean validate() {
// un tableau : int[][] board = new int[9][9]();
// initialisation et actions sur le Sudoku
 
//Vérifie les lignes et les colonnes 
for (int i = 0; i < board.length; i++) {
BitSet bsRow = new BitSet(9);
BitSet bsColumn = new BitSet(9);
for (int j = 0; j < board[i].length; j++) {
if (board[i][j] == 0 || board[j][i] == 0) continue;
if (bsRow.get(board[i][j] - 1) || bsColumn.get(board[j][i] - 1))
return false;
else {
bsRow.set(board[i][j] - 1);
bsColumn.set(board[j][i] - 1);
}
}
}

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
  //Vérifie les quandrans (3x3)
for (int rowOffset = 0; rowOffset < 9; rowOffset += 3) {
for (int columnOffset = 0; columnOffset < 9; columnOffset += 3) {
BitSet threeByThree = new BitSet(9);
for (int i = rowOffset; i < rowOffset + 3; i++) {
for (int j = columnOffset; j < columnOffset + 3; j++) {
if (board[i][j] == 0) continue;
if (threeByThree.get(board[i][j] - 1))
return false;
else
threeByThree.set(board[i][j] - 1);
}
}  
}
}
return true;
}

MES SOURCES :

Code:

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
/*****************************************************************************/
/* Nom du programme: Sudoku                                                  */
/* Fichier : tp4.java                                                     */
/* Description :                                                             */
/* Auteur : cours java                                                       */
/* Date :                                                                    */
/* Autres / Execution :                                                      */
/*****************************************************************************/
 
public class tp4 {
 
 
  	public static void main(String[] args) {
 
		int[][] tab1 = { { 0,3,9,1,0,0,0,6,4 },        // Tableau debutant
                         { 0,6,0,7,4,0,0,9,5 },
                         { 7,5,0,0,0,3,2,8,0 },
                         { 6,0,0,2,0,0,0,1,0 },
                         { 0,1,5,0,6,9,0,0,0 },
                         { 0,2,8,4,0,7,0,0,0 },
                         { 5,7,0,0,2,0,0,3,0 },
                         { 0,4,0,0,0,0,0,0,0 },
                         { 0,8,1,5,0,0,0,4,0 } };
 
		int[][] tab2 = { { 0,0,0,0,0,0,0,0,0 },        // tableau intermediaire
                         { 0,0,0,0,0,0,0,0,0 },
                         { 0,0,0,0,0,0,0,0,0 },
                         { 0,0,0,0,0,0,0,0,0 },
                         { 0,0,0,0,0,0,0,0,0 },
                         { 0,0,0,0,0,0,0,0,0 },
                         { 0,0,0,0,0,0,0,0,0 },
                         { 0,0,0,0,0,0,0,0,0 },
                         { 0,0,0,0,0,0,0,0,0 } };
 
		int[][] tab3 = { { 0,0,0,0,0,0,0,0,0 },        // Tableau debutant
                         { 0,0,0,0,0,0,0,0,0 },
                         { 0,0,0,0,0,0,0,0,0 },
                         { 0,0,0,0,0,0,0,0,0 },
                         { 0,0,0,0,0,0,0,0,0 },
                         { 0,0,0,0,0,0,0,0,0 },
                         { 0,0,0,0,0,0,0,0,0 },
                         { 0,0,0,0,0,0,0,0,0 },
                         { 0,0,0,0,0,0,0,0,0 } };
 
		Sudoku9x9 jeu1 = new Sudoku9x9("Joueur1",9,10,1);	// Creation de l'objet jeu1 de la classe Sudoku
 
		// Test les methodes - setGrille et getGrille
		jeu1.setGrille(tab1);
		tab1 = jeu1.getGrille();
		System.out.println("-- Grille de SUdoku originalle --");
		for (int i=0; i<jeu1.n; i++) {
			System.out.print("\t");
			for (int j=0; j<jeu1.n; j++) {
				System.out.print(tab1[i][j] + " ");
			}
			System.out.println();
		}
 
        // Test les methodes - getComplexite
        jeu1.setComplexite(1);
		System.out.println();
		System.out.println("-- Niveau de difficulte --");
		System.out.println("\t" + jeu1.getComplexite());
		System.out.println();
 
		System.out.println();
 
		// Test les methodes - setTableaufinal et getTableaufinal
		jeu1.setTableaufinal(tab3);
		tab1 = jeu1.getTableaufinal();
		System.out.println("-- Retourne le tableau --");
		for (int i=0; i<jeu1.n; i++) {
			System.out.print("\t");
			for (int j=0; j<jeu1.n; j++) {
				System.out.print(tab1[i][j] + " ");
			}
			System.out.println();
		}
		System.out.println();
 
		// Test les methodes - setGrille (unedonnee)
		jeu1.setGrille(1, 1, 0);
		tab1 = jeu1.getGrille();
		System.out.println("-- Retourne la grille (unedonnee) --");
		for (int i=0; i<jeu1.n; i++) {
			System.out.print("\t");
			for (int j=0; j<jeu1.n; j++) {
				System.out.print(tab1[i][j] + " ");
			}
			System.out.println();
		}
		System.out.println();
 
		// Test les methodes - setN et getN
		jeu1.setN(9);
		System.out.println("-- Retourne la dimension --");
		System.out.println("\t" + jeu1.getN());
		System.out.println();
 
		// Test les methodes - setPlacements et getPlacements
		jeu1.setPlacements(4);
		System.out.println("-- Definit les placements --");
		System.out.println("\t" + jeu1.getPlacements());
		System.out.println();
 
 
	}
}

Code:

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
171
172
173
174
175
176
177
/*****************************************************************************/
/* Nom du programme: Sudoku                                                  */
/* Fichier : Sudoku9x9.java                                                     */
/* Description :                                                             */
/* Auteur : cours java                                                       */
/* Date :                                                                    */
/* Autres / Execution :                                                      */
/*****************************************************************************/
import java.util.BitSet;
 
/*
 *	classe  Sudoku
 */
public class Sudoku9x9
{
 
	int grille[][];
	int n;
	int placements = 0;
	int complexite = 0;
	int[][] tableaufinal;
	String nom;
 
	/* Titre : Constructeur de Sudoku
	 * Description : Initialise les valeurs de lagrille, lacomplexite et lesplacements a zero.
	 * Entrees : Les attributs de la classe Sudoku
	 * 				- n
	 * 				- lagrille (par reference)
	 * Sorties : Aucune
	 * Resultats : Aucun
	 * Hypohh�ses : Aucune
	 */
 
	public Sudoku9x9 (String e, int n, int placements, int complexite) {
 
		this.n = n;
 
		grille = new int[n][n];
 
		// La fonction initialisation permet d'initialiser les attributs suivants :
		// grille, placements et complexite
		initialisation ();
	}
 
	/* Titre : Initialisation
	 * Description : Initialise les valeurs de grille, complexite et placements � z�ro.
 
	 */
	public void initialisation () {
 
		for (int i=0; i<n; i++) {
			for (int j=0; j<n; j++) {
				grille[i][j] = 0;
			}
		}
		complexite = 0;
		placements = 0;
	}
 
	// Retourne le niveau de complexite
	public int getComplexite() {
 
		return complexite;
 
	}
 
	// Retourne la grille
	public int[][] getGrille() {
 
		return grille;
 
	}
 
        public void setComplexite(int complexite) {
 
	this.complexite = complexite;
 
	}
	// Definit une unedonnee a la ligne i et colonne j de la grille
	public void setGrille(int i, int j, int unedonnee) {
 
		this.grille[i][j] = unedonnee;
 
	}
 
	// Retourne la dimension de la grille
	public int getN () {
 
		return n;
 
	}
 
	// Definit la dimension de la grille
	public void setN(int n) {
 
		this.n = n;
 
	}
 
	// Retourne la valeur lesplacements
	public int getPlacements() {
 
		return placements;
 
	}
 
	// Definit la valeur lesplacements
	public void setPlacements(int placements) {
 
		this.placements = placements;
 
	}
 
	// Definit le tableau final
	public void setTableaufinal(int[][] tableaufinal) {
 
		this.tableaufinal = tableaufinal;
 
	}
 
	// Definit la grille
	public void setGrille(int[][] grille) {
 
		this.grille = grille;
 
	}
 
	// Retourne le tableau final
	public int[][] getTableaufinal() {
 
		return tableaufinal;
 
	}
 
    public boolean validate() {
        // un tableau : int[][] tableaufinal = new int[9][9]();
        // initialisation et actions sur le Sudoku
 
        //Vérifie les lignes et les colonnes 
        for (int i = 0; i < tableaufinal.length; i++) {
            BitSet bsRow = new BitSet(9);
            BitSet bsColumn = new BitSet(9);
            for (int j = 0; j < tableaufinal[i].length; j++) {
                if (tableaufinal[i][j] == 0 || tableaufinal[j][i] == 0) {
                    continue;
                }
                if (bsRow.get(tableaufinal[i][j] - 1) || bsColumn.get(tableaufinal[j][i] - 1)) {
                    return false;
                } else {
                    bsRow.set(tableaufinal[i][j] - 1);
                    bsColumn.set(tableaufinal[j][i] - 1);
                }
            }
        }
 
        //Vérifie les quandrans (3x3)
        for (int rowOffset = 0; rowOffset < 9; rowOffset += 3) {
            for (int columnOffset = 0; columnOffset < 9; columnOffset += 3) {
                BitSet threeByThree = new BitSet(9);
                for (int i = rowOffset; i < rowOffset + 3; i++) {
                    for (int j = columnOffset; j < columnOffset + 3; j++) {
                        if (tableaufinal[i][j] == 0) {
                            continue;
                        }
                        if (threeByThree.get(tableaufinal[i][j] - 1)) {
                            return false;
                        } else {
                            threeByThree.set(tableaufinal[i][j] - 1);
                        }
                    }
                }
            }
        }
        return true;
    }
 
}

Code:

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
import java.util.List;
 
public abstract class Sudoku {
 
    protected int[][] tableaufinal;
    private int complexite = 0; // Variable pour enregistrer le niveau de difficulte 1 à 3
    private int placement = 0; //nombre de chiffre restant à placer dans la grille
    private List<Placement> placements;
 
    public Sudoku(int[][] tableaufinal) {
        this.tableaufinal = tableaufinal;
    }
 
    public Placement getDernierPlacement() {
        Placement retVal = null;
        if (placements != null) {
            retVal = placements.get(placements.size() - 1);
        }
        return retVal;
    }
    public abstract void fairePlacement(Placement placement);
 
    public abstract void enleverPlacement(Placement placement);
 
    public void imprimerGrilleOriginale() {
 
//        System.out.println("imprime");
    }
 
    public void imprimerComplexite() {
        System.out.println("Degre de complexite : " + complexite);
    }
 
    public abstract boolean validate();
 
    public int getcomplexite() {
 
        return this.complexite;
    }
 
    public void setComplexite(int complexite) {
        this.complexite = complexite;
    }
}

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class Placement {
    private int value = 0;
    private Case uneCase;
 
    public Placement(int x, int y, int value) {
        this.value = value;
        this.uneCase = new Case(x, y);
    }
 
    public Case getCase() {
        return this.uneCase;
    }
 
    public int getValue() {
        return this.value;
    }
}

Code:

1
2
3
4
5
6
7
8
9
public class Case {
    private int x;
    private int y;
 
    public Case(int x, int y) {
        this.x = x;
        this.y = y;
    }
}