programme sudoku en java

Version imprimable

Bonjour tout le monde,
Je suis un debuatant en programmation java je suis entrain de faire un programme sudoku, mais je suis arrive dans un ou je ne peux pas continuer je demande votre s'il vouplait. Voici l'enonce:

Problématique

Vous poursuivez le mandat qui vous a été confié par la directrice de l’école Saint Pruneau, soit la conception d’un jeu de Sudoku. Dans ce mandat particulier, vous aurez à concevoir les classes associées au jeu de Sudoku et les méthodes qui s’y réfèrent, permettant d’accéder aux données de la grille, la manipulation de la grille et la validation d’une solution. Le fichier/classe tp2.java permettant de démarrer le logiciel devra se nommer tp4.java.

Dans le cadre de ce travail pratique, vous aurez en prendre un certain nombre de décision dans la conception des classes, soit : Quelles méthodes doivent être abstraite ou non? À quel niveau doit se situer l’implémentation finale du code? Quel type de polymorphisme doit être utilisé? Veuillez utiliser les commentaires dans le code, pour justifier vos choix de conception pour chaque méthode créée !
1.Créer des classes

Le programme devra être développé autour de plusieurs classes soit :
1.tn4.java permettant de démarrer le programme. Cette classe aura une méthode main qui devra faire comme actions :
1.Créer une instance de la classe Sudoku9x9;
2.Imprimer la grille de Sudoku original;
3.Imprimer le degré de difficulté de la grille;
4.Effectuer 10 placements;
5.Imprimer la grille de Sudoku suite aux placements;
6.Annuler 2 placements;
7.Imprimer la grille de Sudoku suite à l’annulation;
8.Valider la solution et imprimer le résultat de la validation.
2.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 :
1.Une matrice de nombre entier (int[][]) représentant la grille de Sudoku
2.Une liste d’action de placement (Une ArrayList de classe Placement (voir plus bas))
3.Le degré de complexité de la grille (int)
4.L’attribut placement (int) indiquant le nombre de chiffre restant à placer dans la grille

Elle aura comme méthodes abstraites ou non :
1.Initialiser une grille
2.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!
3.Tester la validité de la solution (voir code en annexe)
4.Faire un placement (voir plus bas au point 5)
5.Annuler un placement (voir plus bas au point 5)
6.Méthodes get et set pour accéder aux attributs de classes (attention à la visibilité des méthodes, c.a.d. public, private, protected).
7.Imprimer la grille
1.Sudoku9x9.java, une sous-classe de Sudoku.java qui implémente les méthodes spécifiques à un Sudoku9x9, soit :
1.Les sous-implémentations des méthodes abstraites de la classe Sudoku.java
2.Toutes autres méthodes nécessaires pour effectuer le mandat
2.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.
1.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 tn4.java) :
1.Créer une instance de la classe Sudoku9x9;
2.Imprimer la grille de Sudoku original;
3.Imprimer le degré de difficulté de la grille;
4.Effectuer 10 placements;
5.Imprimer la grille de Sudoku suite aux placements;
6.Annuler 2 placements;
7.Imprimer la grille de Sudoku suite à l’annulation;
8.Valider la solution et imprimer le résultat de la validation.
1.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).

1.Code de validation de la grille Sudoku
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 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); } } } //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; }
Merci de corriger pour moi.

Au plaisir de recevoir votre solution.
Merci d'avance a tout un chacun

jsylvestre.

Voila mes codes

voici les codes de mon programme:

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
package tp4;
 
public class tn4 {
 
	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
 
package tp4;
import java.util.BitSet;
 
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
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
 
package sudoku;
import java.util.List;
public abstract class sudoku {
 
	public abstract class Sudoku {
 
	    protected int[][] tableaufinal;
	    private int complexite = 0; // Variable pour enregistrer le niveau de difficulte 1 à 3
	    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;
	    }
	}
 
 
 
	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;
	    }
	}
 
 
 
	public class Case {
	    private int x;
	    private int y;
 
	    public Case(int x, int y) {
	        this.x = x;
	        this.y = y;
	    }
	}
 
 
}

Merci a vous tous.
j'attends votre reponse.

jsylvestre

26/07/2015, 23h59
joel.drigo
Salut,

Il faudrait que tu nous expliques exactement où tu en es et qu'est-ce qui te bloque exactement.

Sinon quelques remarques sur le code posté :
1. Code:
  
  1 2 3 public abstract class sudoku { public abstract class Sudoku {
  Erreur de copier/coller ? Sinon il y a un problème : pourquoi cette duplication ?
2. Le but de l'exercice est de mettre toute la logique dans la classe abstraite Sudoku et de faire que Sudoku9x9 étende Sudoku pour faire la version spécifique de 9 fois 9. Il ne devrait pas y avoir tant de code dans Sudoku9x9 et surtout pas du code déjà présent dans Sudoku.

Citation:

Envoyé par jsylvestre

voici les codes de mon programme:

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
package tp4;
 
public class tn4 {
 
	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
 
package tp4;
import java.util.BitSet;
 
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
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
 
package sudoku;
import java.util.List;
public abstract class sudoku {
 
	public abstract class Sudoku {
 
	    protected int[][] tableaufinal;
	    private int complexite = 0; // Variable pour enregistrer le niveau de difficulte 1 à 3
	    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;
	    }
	}
 
 
 
	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;
	    }
	}
 
 
 
	public class Case {
	    private int x;
	    private int y;
 
	    public Case(int x, int y) {
	        this.x = x;
	        this.y = y;
	    }
	}
 
 
}

Merci a vous tous.
j'attends votre reponse.

jsylvestre

29/07/2015, 23h30
jsylvestre

programme sudoku java

Bonjour,
on m'a demande de faire 10 placements mais je vois pas comment le faire.
Ainsi on m'a demande d'utiliser un arraylist pour gerer les matrices

Merci a vous.
jsylvestre.
29/07/2015, 23h47
joel.drigo

Salut,

Citation:

Envoyé par jsylvestre

on m'a demande de faire 10 placements mais je vois pas comment le faire.
Ainsi on m'a demande d'utiliser un arraylist pour gerer les matrices

On te demande juste de faire un petit programme de test pour Suduko9x9 : donc créer une grille de sudoku, avec des cases vides, comme pour une grille à jouer qu'on trouve dans le journal, et simuler ce que ferait un joueur qui ferait 10 placement de chiffres, dans des cases libres, comme si le programme jouait sérieusement au sudoku.
30/07/2015, 00h14
jsylvestre

sudoku en java

Merci joel.drigo.Mais je ne sais pas comment faire ca avec arraylist , est-ce que vous pouvez me donner un exemple svp.

Si tu parles de l'ArrayList de Placement de la classe Sudoku, tu dois avoir une variable de type ArrayList<Placement> dans la classe Sudoku :
Code:

1 2 3 4 5 public abstract class Sudoku { protected ArrayList<Placement> placements = new ArrayList<Placement>(); }
Pour ajouter un placement dedans :

Code:

placements.add( placement );

où placement est une variable de type Placement.

Pour enlever un placement (pour l'annulation) :

Code:

placements.remove( placement );

ou

Code:

placements.remove( indexPlacement );

où indexPlacement, une variable de type int, contient la position du placement à supprimer (de 0 à taille de la liste -1)

Par exemple, pour enlever le dernier placement :
Code:

1 2 3 4 5 6 7 8 if ( !placements.isEmpty() ) { // si la liste n'est pas vide Placement dernierPlacement = placements.remove( placements.size() - 1 ); // on a retiré le dernier placacement dans la liste, et on l'a récupéré dans la variable dernierPlacement // on peut le traiter (pour faire l'annulation du dernier placement) // ... }

programme sudoku java

Bonjour tout le monde
Voici mon code pour les placements ca donne une erreur et ca ne marche pas.
Est-ce que quelqu'un peut m'aider svp?

Merci.
dydy04

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
package tp4;
import java.util.ArrayList;
public class Placement {
 
	private static final String ListPlacements = null;
	private static final String Placements = null;
	private int X = 0;
    private int Y = 0;
    private int nouvelleValeur = 0;
    private int ancienneValeur = 0;
	private int[][] grille;
 
    public Placement(int x, int y, int ancienneValeur, int nouvelleValeur, int X) {
        this.X = X;
        this.Y =  y;
        this.ancienneValeur = ancienneValeur ;
        this.nouvelleValeur = nouvelleValeur ;
    }
 
    public int getX() {
        return this.X;
    }
 
    public int getY() {
        return this.Y;
    }
 
    public int getancienneValeur() {
        return this.ancienneValeur;
    }
 
    public int getnouvelleValeur() {
        return this.nouvelleValeur;
    }
 
	public int[][] getGrille() {
		return grille;
	}
 
	public void setGrille(int[][] grille) {
		this.grille = grille;
	}
 
 
	public void AnnulerPlacement()
		{
		Placement deplocal=(Placement)this.Placements.get(Placement.ListPlacements.Size()-1);
		 int X = deplocal.getX();
		 int Y = deplocal.getY();
		 int ancienneValeur = deplocal.getancienneValeur();
		 this.grille[X][Y]=ancienneValeur;
		// Placements.remove(ListPlacements);
 
		}
 
 
	}
 
 
//}

30/07/2015, 19h59
joel.drigo

Peut-être, si tu nous dit ce qui ne marche pas et pourquoi tu nous dit que ça marche pas : s'il y a des messages d'erreur, dis-nous lesquels, si ça fait un truc et pas un autre, dis-nous ce que ça fait et ce que ça devrait. Et mets nous uniquement le code qui pose problème. On ne peut pas essayer tous les programmes en entier pour savoir ce qu'ils font ou pas.
30/07/2015, 20h09
jsylvestre

Merci.

je veux faire des placements dans la matrice mais cela ne marche pas. Le code pour annuler placement me donne une erreur :

Code:

Placement deplocal=(Placement)this.Placements.get(Placement.ListPlacements.Size()-1)

Merci a vous.
dydy042002

Tu as déclaré ListPlacement comme ça :

Code:

private static final String ListPlacements = null;

C'est une String : donc pas de méthode get(...). Ça devrait être une List<Placement>
Tu l'initialises à null. Il faut l'initialiser avec une instance de ArrayList<Placement>, sinon pas d'instance, donc tu ne pourras rien en faire (la liste n'existe pas)
Il n'y a aucune raison qu'elle soit statique : elle est propre à l'instance de classe
A priori, elle ne devrait pas être dans Placement, mais dans Sudoku, d'après ce qui est écrit ici :

Citation:

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 :
1.Une matrice de nombre entier (int[][]) représentant la grille de Sudoku
2.Une liste d’action de placement (Une ArrayList de classe Placement (voir plus bas))

Donc, je résume, dans la classe Sudoku :
Code:

1 2 3 4 5 6 7 8 9 10 public abstract class Sudoku { private List<Placement> placements = new ArrayList<>(); // dans ce cas, on est pas obligé de répéter <Placement> dans la partie à droite (Java sait déterminer par rapport à la partie gauche que c'est ça). public void annulerPlacement() { Placement deplocal= this.placements.get(placements.Size()-1); // attention, si la liste est vide : plantage — c'est pour ça que j'avais mis if ( !placements.isEmpty() ) dans mon exemple /* ... */ } }
Ensuite, j'avais mis this.placements.remove() dans mon exemple, pas get(), parce que le but est d'annuler le placement, donc de le supprimer de la liste...

La grille a manipuler est bien sûr un attribut de Sudoku : c'est la grille dans laquelle on joue. Si tu fais une autre grille, dans la classe Placement (ce que tu as fait dans ton code), ça n'annulera pas dans la grille globale où on joue, mais dans une grille isolée qui n'existe que dans l'instance de placement qu'on annule, et donc qui sera perdue, puisque le placement sera supprimé.

30/07/2015, 21h19
jsylvestre

Merci Joel

Non. Je n'ai pas de grille dans ma classe placement. Si je comprends bien je dois ecrire tous les codes plaements et annuler placement au niveau des codes sudoku. Mais qu'est-ce je dois mettre au final dans ma classe placement

Mille et mille merci Joel.
dydy04

Citation:

Envoyé par jsylvestre

Non. Je n'ai pas de grille dans ma classe placement. Si je comprends bien je dois ecrire tous les codes plaements et annuler placement au niveau des codes sudoku.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 package tp4; import java.util.ArrayList; public class Placement { private static final String ListPlacements = null; private static final String Placements = null; private int X = 0; private int Y = 0; private int nouvelleValeur = 0;http://www.developpez.net/forums/images/smilies/icon_mrgreen.gif private int ancienneValeur = 0; private int[][] grille; public Placement(int x, int y, int ancienneValeur, int nouvelleValeur, int X) { this.X = X;
C'est bien une grille, là, et elle est bien dans la classe Placement.

Citation:

Envoyé par jsylvestre

Mais qu'est-ce je dois mettre au final dans ma classe placement

Ça, c'est le sujet qu'il le dit. Mais, comme je le disais à ton "collègue" ici, le sujet me semble pas très clair, ou du moins incomplet et confus. On dirait presque une erreur, avec l'emploi du mot Placement d'un côté, et l'emploi du mot Case de l'autre. On peut bien sûr modéliser un Placement comme étant quasiment pareil qu'une case, mais avec un attribut "précédente valeur" en plus, pour pouvoir faire l'annulation. Maintenant, savoir exactement ce que voulais exprimer le rédacteur du sujet (si mon interprétation correspond bien à son idée) sort du champ technique de la programmation Java. Normalement, en informatique professionnelle, une telle confusion dans un cahier des charges ferait l'objet d'une demande de précisions et une nouvelle rédaction.