Discussion :

[fredlav109]

Bonjour,
Je suis un cours d'introduction en programmation java qui est un peu mal structurer mais bon. j'ai un devoir a remettre et j'ai trouver sur le site déjà trois discussions en lien avec le même devoir mais je ne trouve pas le réponse dont j'ai besoin. je vous mets les consignes du devoir en question:

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

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

Je suis quand même bien avancer dans mon programme, mes trois classes sont créer mais je crois qu'il manque certaine chose à mon programme pour qu'il fonctionne. Est-ce que vous pouvez m'aider? Je n'ai pas une question précise, mon programme compile mais ce n'est pas ce qui devrait apparaître.
Voici mes trois classe:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
package travail4;
 
public class Tp4 {
 
	public static void main(String[] args) {
		int [] [] tab1= {{0,3,9,1,0,0,0,6,4},			// Tableau débutant
				{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 intermédiaire
				{0,0,0,0,0,0,0,0,0},
				{0,0,0,0,0,0,0,0,0},
				{0,0,0,0,0,0,0,0,0},
				{0,0,0,0,0,0,0,0,0},
				{0,0,0,0,0,0,0,0,0},
				{0,0,0,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 Expert
				{0,0,0,0,0,0,0,0,0},
				{0,0,0,0,0,0,0,0,0},
				{0,0,0,0,0,0,0,0,0},
				{0,0,0,0,0,0,0,0,0},
				{0,0,0,0,0,0,0,0,0},
				{0,0,0,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);			//Création de l'objet jeu1 de la classe Sudoku
 
		// Test les methodes : setGrille et getGrille
		jeu1.setGrille(tab2);
		tab1 = jeu1.getGrille();
		System.out.println("--Grille de Sudoku original --");
		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 : 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, 8);
		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(10);
		System.out.println("--Definit les placements--");
		System.out.println("\t" + jeu1.getPlacements());
		System.out.println();
 
	}
 
}

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
package travail4;
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 la grille, la complexite et les placements à zéro.
	 * Entrees: Les attriibuts de la classe Sudoku: 
	 * 					- n
	 * 					- lagrille (par reference)
	 * Sorties: Aucune
	 * ResultatsL aucun
	 * Hypothese: 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 la grille, complexite et placements 
	  */
 
	 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;
	 }
 
	 /*Pour ecrire
	  * 
	  */
	 public String ecrire(){
		 String temp="";
		 for(int i=0; i<n; i++){
			 for(int e=0; e<n; e++){
				 temp+=Integer.toString(grille[i][e]);
			 }
		 }
		 temp+="" +Integer.toString(complexite);
		 return temp;
	 }
 
 
	 //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;
	 }
 
	 //Retroune 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 ;
	  }
 
	  //Defnit la grille
	  public void setGrille (int[][] grille) {
		  this.grille = grille ;
	  }
 
	  // Retourne le tableaufinal
	  public int [][] getTableaufinal() {
		  return tableaufinal ;
	  }
 
	  public boolean validate() {
		 // un tableau :*/ int[][] tableauFinal = new int[9][9]();
		  // initialisation et actions sur le Sudoku
 
		  //verifie 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);
				  }
			  }
		  }
 
		  //verifie les quadrans 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;
 
	  }
 
 
 
}//fermeture final

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 travail4;
import java.util.ArrayList;
import java.util.List;
 
public  abstract class Sudoku extends Sudoku9x9 {
 
 
	protected  int[][] tableaufinal;	
	private int complexite = 0; //Variable pour enregistrer le niveau de difficulte 1 a 3
	private int placement = 0; //nombre de chiffre restant à placer dans la grille
	private List<Placement> placements =new ArrayList<Placement> ();
	private int[][] grille;
 
 
	public Sudoku(String e, int n, int placements, int complexite) {
		super(e, n, placements, complexite);
 
	}
/*	public Sudoku (int taille){
		this.tableaufinal = new int [taille][taille];
	}
	*/
	/*public Sudoku (int [][] tableaufinal){
		this.tableaufinal = tableaufinal;
	}*/
 
	/*public int [][] getGrille(){
		return grille;
	}
 
	public void setGrille(int[][] grille){
		this.grille = grille;
	}*/
 
	public Placement getDernierPlacement(){
		Placement retVal = null;
		if (placements != null){
			retVal = placements.get(placements.size()-1);
		}
		return retVal;
	}
	 public void CreerPlacement(int x, int y,int valeur)
     {
            Placement deplocal=new Placement(x,y,valeur);
            this.placements.add(deplocal);
            this.grille[x][y]=valeur;
     }
 
	public abstract void annulerPlacement ();{
		if (!placements.isEmpty()){ //si la liste n'est pas vide
 
		Placement dernierPlacement = placements.remove(placements.size() -1);
		}
	}
 
	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{
		public int x;
		public int y;
 
		public Case(int x, int y){
			this.x = x;
			this.y = y;
		}
	}
 
}//fermeture final

Je crois que mon problème ce situe au niveau des placements, mais comme je suis débutant je n'arrive pas a trouver quel est mon ou mes problèmes.

Merci beaucoup pour votre aide!

Frédérique

[Syberi@]

Bonjour,

je ne comprend pas réélement ou est ton bloquage et ce qu'il te manque pour continuer. Tu peux en dire un peu plus ?

Syberi@

[fredlav109]

Bonjour, en fait je sais pas moi-même ou est on blocage. je sais que le code pour faire les placements n'est pas complet car lorsque j'exécute mon programme les placement ne sont pas. je crois que je comprend trop comment je doit faire pour répondre au exigence sur les placements. C'est la première fois que je fait un programme en java alors je suis disons assez mélanger.

[francky74]

Bonjour,

Après avoir jeté un rapide coup d'oeuil, je vois deux déclarations de classes qui ne sont pas très bien :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

public  abstract class Sudoku extends Sudoku9x9 {

et

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

public class Sudoku9x9  {

Si Sudoku hérite de Sodoku9x9, c'est alors la classe mère qui doit être abstraite (Sudoku9x9).

Mais cela ne me semble pas logique pour la raison suivante :

Tu fait de l'héritage, et donc si tu as plusieurs types de sudokus (par exemple Sudoku9x9 ou sudoku15x15 en hexadecimal) tu dois avoir une classe mère non instanciable qui contient des attributs communs aux classes filles.

Ainsi, je ferait plutôt :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

public  abstract class Sudoku {

et

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

public class Sudoku9x9 extends Sudoku {

et aussi tu peux rajouter :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

public class Sudoku15x15 extends Sudoku {

De ce fait, tu instancie la classe fille Sudoku9x9 et non la classe mère.

D'autre part, je vois que ces deux dernières classes ont des attributs en commun. Comme je l'ai expliqué précédemment, avec l'héritage, tu dois concentrer les attributs communs dans la classe mère. Et lorsque tu souhaite créer un objet fille, il faudra envoyer les valeurs des attributs que tu veux instancier à la classe mère.

par exemple :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class Sudoku {
	protected int complexite;
 
	public Sudoku(int complexite) {
		this.complexite = complexite;
	}
 
	public int getComplexite() {
		return complexite;
	}
 
	public void setComplexite(int complexite) {
		this.complexite = complexite;
	}
 
}

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
public class Sudoku9x9 extends Sudoku {
 
	public Sudoku9x9(int complexite) {
		super(complexite);
	}
 
}

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
public class Principale {
 
	public static void main(String[] args) {
		Sudoku9x9 sudo9 = new Sudoku9x9(5);
	}
 
}

Mais tout ceci, c'est dans le cas où tu veux faire de l'héritage parce que personnellement, je ne pense pas qu'il y ait besoin d'héritage. Bien sûr je ne suis pas expert en Sudokus mais la seule différence que je vois c'est le quadrillage en 9x9 ou autre. Et en cela n'est qu'un attribut quadrillage instanciable avec des valeurs de grille différentes.

[fredlav109]

Merci pour ton aide sur l'héritage, mais malheureusement, oui je dois utilisé l'héritage.
J'ai discuté avec mon tuteur pour ce cours et elle ma dit que mon problème venait des placements et de ma ArrayList. Elle dit que j'ai seulement une variable c'est a dire

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.

Est-ce que vous pouvez m'aider a faire ce qu'il faut?
Merci, pour votre aide c'est très apprécier.