Super tu vois que c'était pas la peine de désespéré:king: maintenant il te reste plus qu'à réglé les quelques warning de ton code et sa sera bon.
Version imprimable
Super tu vois que c'était pas la peine de désespéré:king: maintenant il te reste plus qu'à réglé les quelques warning de ton code et sa sera bon.
Les warning c'est a dire? Car il y a noté :...Citation:
0 errors, 0 warnings
C'est que tu n'as pas configurer ton compilateur alors;) si tu es sous linux compile avec cette ligne:
Code:gcc -Wall -Wextra -Wstrict-prototypes -ansi -o nomducode nomducode.c
Je suis sous windows...:oops:
arf qu'elle idée aussi:P bon voila ton code corrigé:
avec quoi code tu sous windows ?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 #include<stdio.h> #include<time.h> #include<stdlib.h> #define N 9 #define VRAI 1 #define FAUX 0 void afficherGrille(int S[N][N]); void remplirGrille(int S[N][N]); int verifLigne(int S[N][N], int indiceLigne, int i, int *nb); int verifColonne(int S[N][N], int l, int indiceColonne, int *nb); /*-----------------------------MAIN-------------------------------------------*/ int main(void) { int grille[N][N]; srand((int)time(NULL)); remplirGrille(grille); afficherGrille(grille); return 0; } /*----------------------------------------------------------------------------*/ /*------------------Fonction permettant d'afficher la grille------------------*/ void afficherGrille(int S[N][N]) { int indiceColonne=0; int indiceLigne; printf("-------------"); for(indiceLigne = 0 ; indiceLigne < N ; indiceLigne++) { if((indiceLigne) == 3 ) { printf("\n ------ ------- ------ "); }else if((indiceLigne) == 6) { printf("\n ------ ------- ------ "); } printf("\n"); for(indiceColonne = 0 ; indiceColonne < N ; indiceColonne++) { if((indiceColonne%3) == 0) { printf("|%2d",S[indiceLigne][indiceColonne]); } else if((indiceColonne) == 8) { printf("%2d|",S[indiceLigne][indiceColonne]); } else { printf("%2d",S[indiceLigne][indiceColonne]); } } } } /*----------------------------------------------------------------------------*/ /*------Fonction permettant de remplir la grille suivant les contraintes------*/ void remplirGrille(int S[N][N]) { int indiceLigne; int indiceColonne; int nb; for(indiceLigne = 0 ; indiceLigne < N ; indiceLigne++) { S[indiceLigne][0] = (rand()%N)+1; for(indiceColonne = 1 ; indiceColonne < N ; indiceColonne++) { if(verifLigne(S, indiceLigne, indiceColonne, &nb)) { S[indiceLigne][indiceColonne] = nb; } } } } /*----------------------------------------------------------------------------*/ /*-Fonction qui verifie si un chiffre n'est pas deux fois dans la meme ligne-*/ int verifLigne(int S[N][N], int indiceLigne, int k, int *nb) { int i; /* un compteur local pour faire avancer les colonne.*/ i = 0; /* on met le compteur a 0.*/ *nb = (rand()%9)+1; /* nb devient un nombre aléatoire entre 1 et 9.*/ while(i < k) /* si notre compteur est inférieur a la colonne ( on rentre obligatoirement une foie dans la boucle.*/ { if(*nb == S[indiceLigne][i]) /* on verifie si notre nombre généré vaut le nombre mis dans la premiere case car la premiere fois j = 0.*/ { *nb = (rand()%9)+1; /* on régénère un nouveau nombre.*/ i = 0; /* on refera la boucle pour remettre ce nombre.*/ } else { i++; /* on avance dans le compteur de colonne.*/ } } return VRAI; }
onc j'ai encore un peu changé mon code pour enlever les pointeurs :Cependant je rencontre un soucis : je ne peut pas faire les deux verif en meme temps. Si je metCode:
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 #include<stdio.h> #include<time.h> #define N 9 #define VRAI 1 #define FAUX 0 void afficherGrille(int S[N][N]); void remplirGrille(int S[N][N]); int verifLigne(int S[N][N], int indiceLigne, int indiceColonne, int nb); int verifColonne(int S[N][N], int indiceLigne, int indiceColonne, int nb); int creerNombre(int S[N][N], int indiceLigne, int indiceColonne); /*-----------------------------MAIN-------------------------------------------*/ int main() { int grille[N][N]; srand((int)time(NULL)); remplirGrille(grille); afficherGrille(grille); return 0; } /*----------------------------------------------------------------------------*/ /*------------------Fonction permettant d'afficher la grille------------------*/ void afficherGrille(int S[N][N]) { int indiceColonne; int indiceLigne; printf(" ------ ------- ------ "); for(indiceLigne = 0 ; indiceLigne < N ; indiceLigne++) { if((indiceLigne) == 3 ) { printf("\n ------ ------- ------ "); }else if((indiceLigne) == 6) { printf("\n ------ ------- ------ ",S[indiceLigne][indiceColonne]); } printf("\n"); for(indiceColonne = 0 ; indiceColonne < N ; indiceColonne++) { if((indiceColonne%3) == 0) { printf("|%2d",S[indiceLigne][indiceColonne]); } else if((indiceColonne) == 8) { printf("%2d|",S[indiceLigne][indiceColonne]); } else { printf("%2d",S[indiceLigne][indiceColonne]); } } } printf("\n ------ ------- ------ "); } /*----------------------------------------------------------------------------*/ /*------Fonction permettant de remplir la grille suivant les contraintes------*/ void remplirGrille(int S[N][N]) { int indiceLigne; int indiceColonne; int nb; for(indiceLigne = 0 ; indiceLigne < N ; indiceLigne++) { for(indiceColonne = 0 ; indiceColonne < N ; indiceColonne++) { nb = creerNombre(S, indiceLigne, indiceColonne); S[indiceLigne][indiceColonne] = nb; } } } /*----------------------------------------------------------------------------*/ /*-Fonction qui verifie si un chiffre n'est pas deux fois dans la meme ligne-*/ int verifLigne(int S[N][N], int indiceLigne, int indiceColonne, int nb) { int i; /* un compteur local pour faire avancer les colonne.*/ i = 0; /* on met le compteur a 0.*/ while(i < indiceColonne) /* si notre compteur est inférieur a la colonne ( on rentre obligatoirement une foie dans la boucle.*/ { if(nb == S[indiceLigne][i]) /* on verifie si notre nombre généré vaut le nombre mis dans la premiere case car la premiere fois j = 0.*/ { return FAUX; } else { i++; /* on avance dans le compteur de colonne.*/ } } return VRAI; } /*----------------------------------------------------------------------------*/ /*-Fonction qui verifie si un chiffre n'est pas deux fois dans la meme colonne-*/ int verifColonne(int S[N][N], int indiceLigne, int indiceColonne, int nb) { int j; /* un compteur local pour faire avancer les lignes.*/ j = 0; /* on met le compteur a 0.*/ while(j < indiceLigne) /* si notre compteur est inférieur a la ligne ( on rentre obligatoirement une foie dans la boucle.*/ { if(nb == S[j][indiceColonne]) /* on verifie si notre nombre généré vaut le nombre mis dans la premiere case car la premiere fois j = 0.*/ { return FAUX; /* si c'est le meme on renvoie faux.*/ } else { j++; /* sinon on regarde alors la ligne suivante.*/ } } return VRAI; } /*----------------------------------------------------------------------------*/ /*-----------------Fonction générant un nombre aléatoire----------------------*/ int creerNombre(int S[N][N], int indiceLigne, int indiceColonne) { int nb; while (1) { nb = rand() % N + 1; if (verifLigne(S, indiceLigne, indiceColonne, nb) == VRAI /*&& verifColonne(S, indiceLigne, indiceColonne, nb) == VRAI*/) /* on verifie si nos fonctions verif sont VRAI.*/ { return (nb); /* si oui alors on retourne le nombre aléatoire qu'on utilisera pour remplir la grille.*/ } } }
Il ne m'affiche plus ma grille je ne comprends pas.Code:
1
2
3
4 if (verifLigne(S, indiceLigne, indiceColonne, nb) == VRAI && verifColonne(S, indiceLigne, indiceColonne, nb) == VRAI) /* on verifie si nos fonctions verif sont VRAI.*/ { return (nb); /* si oui alors on retourne le nombre aléatoire qu'on utilisera pour remplir la grille.*/ }
Je code avec Code::Blocks.
C'est tout à fait normal, mais pourquoi veux-tu enlever les pointeurs ils étaient très bien utilisé ? pour code blocks configure ton compilo de cette façon:
setting -> copiler and debugger et dans la fenêtre qui s'affiche tu met GCC comme compilo et tu coche les cases suivante:
->produce debuging symbol
->enable all compiler warning
->enable standart compiler warning
->Warn if main() is not conformant
et puis dans l'onglet Other options tu rajoute: -Wextra et -ansi (pour la norme tu choisie celle que tu veux, moi j'utilise celle-ci)
Non mais dans le sujet on a pas le droit aux pointeurs donc jai contourné. Donc comment faire pour que les deux verifs en meme temps se fassent?
Essai sa:
Cependant cela ne te donne pas une grille de sudoku regarde bien.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 #include<stdio.h> #include<time.h> #include<stdlib.h> #define N 9 #define VRAI 1 #define FAUX 0 void afficherGrille(int S[N][N]); void remplirGrille(int S[N][N]); int verifLigne(int S[N][N], int indiceLigne, int indiceColonne, int nb); int verifColonne(int S[N][N], int indiceLigne, int indiceColonne, int nb); int creerNombre(int S[N][N], int indiceLigne, int indiceColonne); /*-----------------------------MAIN-------------------------------------------*/ int main(void) { int grille[N][N]; srand((int)time(NULL)); remplirGrille(grille); afficherGrille(grille); return 0; } /*----------------------------------------------------------------------------*/ /*------------------Fonction permettant d'afficher la grille------------------*/ void afficherGrille(int S[N][N]) { int indiceColonne=0; int indiceLigne; printf(" ------ ------- ------ "); for(indiceLigne = 0 ; indiceLigne < N ; indiceLigne++) { if((indiceLigne) == 3 ) { printf("\n ------ ------- ------ "); }else if((indiceLigne) == 6) { printf("\n ------ ------- ------ "); } printf("\n"); for(indiceColonne = 0 ; indiceColonne < N ; indiceColonne++) { if((indiceColonne%3) == 0) { printf("|%2d",S[indiceLigne][indiceColonne]); } else if((indiceColonne) == 8) { printf("%2d|",S[indiceLigne][indiceColonne]); } else { printf("%2d",S[indiceLigne][indiceColonne]); } } } printf("\n ------ ------- ------ "); } /*----------------------------------------------------------------------------*/ /*------Fonction permettant de remplir la grille suivant les contraintes------*/ void remplirGrille(int S[N][N]) { int indiceLigne; int indiceColonne; int nb; for(indiceLigne = 0 ; indiceLigne < N ; indiceLigne++) { for(indiceColonne = 0 ; indiceColonne < N ; indiceColonne++) { nb = creerNombre(S, indiceLigne, indiceColonne); S[indiceLigne][indiceColonne] = nb; } } } /*----------------------------------------------------------------------------*/ /*-Fonction qui verifie si un chiffre n'est pas deux fois dans la meme ligne-*/ int verifLigne(int S[N][N], int indiceLigne, int indiceColonne, int nb) { int i; /* un compteur local pour faire avancer les colonne.*/ i = 0; /* on met le compteur a 0.*/ while(i < indiceColonne) /* si notre compteur est inférieur a la colonne ( on rentre obligatoirement une foie dans la boucle.*/ { if(nb == S[indiceLigne][i]) /* on verifie si notre nombre généré vaut le nombre mis dans la premiere case car la premiere fois j = 0.*/ { return FAUX; } else { i++; /* on avance dans le compteur de colonne.*/ } } return VRAI; } /*----------------------------------------------------------------------------*/ /*-Fonction qui verifie si un chiffre n'est pas deux fois dans la meme colonne-*/ int verifColonne(int S[N][N], int indiceLigne, int indiceColonne, int nb) { int j; /* un compteur local pour faire avancer les lignes.*/ j = 0; /* on met le compteur a 0.*/ while(j < indiceLigne) /* si notre compteur est inférieur a la ligne ( on rentre obligatoirement une foie dans la boucle.*/ { if(nb == S[j][indiceColonne]) /* on verifie si notre nombre généré vaut le nombre mis dans la premiere case car la premiere fois j = 0.*/ { return FAUX; /* si c'est le meme on renvoie faux.*/ } else { j++; /* sinon on regarde alors la ligne suivante.*/ } } return VRAI; } /*----------------------------------------------------------------------------*/ /*-----------------Fonction générant un nombre aléatoire----------------------*/ int creerNombre(int S[N][N], int indiceLigne, int indiceColonne) { int nb; while (1) { nb = rand() % N + 1; if (verifLigne(S, indiceLigne, indiceColonne, nb) == VRAI /*&& verifColonne(S, indiceLigne, indiceColonne, nb) == VRAI*/) /* on verifie si nos fonctions verif sont VRAI.*/ { return (nb); /* si oui alors on retourne le nombre aléatoire qu'on utilisera pour remplir la grille.*/ } } }
Il n'y a aucun changement avec ce que j'ai donné...
Oui je sais apres il faudra faire la verif dans les carrés!
Pourtant chez moi cela affiche une grille correcte sur les lignes mais pas sur les colonnes, regarde pourquoi tu n'as pas fait fait appel à verifColonne de la bonne façon;)
Oui chez moi aussi ça m'affiche bien les lignes. Et si je met l'appel de verifLigne en comentaire et que je met verifColonne en appel et bein mes colones sont bien mais pas mes lignes. Pourquoi je ne peux pas faire les deux en meme temps? Y a t-il un moyen de faire les deux en meme temps?
SVP je ne trouve pas comment faire marcher les deux en meme temps...
Donc la je suis vraiment bloqué. J'en suis a la fonction verifCarre. Donc tout d'abord j'ai crée une fonction me renvoyant le numero du carré suivant l'indice des lignes et l'indice des colonnes :C'est un peu barbard comme méthode mais on fait avec lesmoyens du bord. Donc dans ma fonction verifCarre je souhaiterai tenir compte du numero du carré. Donc je pensais faire sa mais apparemment cela ne marche pas. Peut-on m'expliquer pourquoi svp?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 int numeroCarre(int S[N][N], int indiceLigne, int indiceColonne) { int numero; if(indiceLigne <= 2 && indiceColonne <= 2) { numero = 1; }else if((indiceLigne <= 5 && indiceLigne > 2) && indiceColonne <= 2) { numero = 2; }else if((indiceLigne <= 8 && indiceLigne > 5) && indiceColonne <= 2) { numero = 3; }else if(indiceLigne <= 2 && (indiceColonne <= 5 && indiceColonne > 2)) { numero = 4; }else if((indiceLigne <= 5 && indiceLigne > 2) && (indiceColonne <= 5 && indiceColonne > 2)) { numero = 5; }else if((indiceLigne <= 8 && indiceLigne > 5) && (indiceColonne <= 5 && indiceColonne > 2)) { numero = 6; }else if(indiceLigne <= 2 && (indiceColonne <= 8 && indiceColonne > 5)) { numero = 7; }else if((indiceLigne <= 5 && indiceLigne > 2) && (indiceColonne <= 8 && indiceColonne > 5)) { numero = 8; }else if((indiceLigne <= 8 && indiceLigne > 5) && (indiceColonne <= 8 && indiceColonne > 5)) { numero = 9; } return numero; }
Je ne l'ai fait que pour les deux premiers carrées!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 int verifCarre(int S[N][N], int indiceLigne, int indiceColonne, int numero, int nb) { { switch(numero) { case 1 : for(indiceLigne = 0 ; indiceLigne <= 2 ; indiceLigne++) { for(indiceColonne = 0 ; indiceColonne <= 2 ; indiceColonne++) { if(nb == S[indiceLigne][indiceColonne]) { return FAUX; } } } return VRAI; break; case 2 : for(indiceLigne = 2 ; indiceLigne <= 5 ; indiceLigne++) { for(indiceColonne = 0 ; indiceColonne <= 2 ; indiceColonne++) { if(nb == S[indiceLigne][indiceColonne]) { return FAUX; } } } return VRAI; break; } } }
Svp j'ai vraiment besoin d'une aide. Je ne vois pas du tout comment faire. Je remet tout mon code. IL me manque seulement la fonction verifCarre.
Merci d'avanceCode:
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
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201 #include<stdio.h> #include<time.h> #define N 9 #define VRAI 1 #define FAUX 0 void afficherGrille(int S[N][N]); void remplirGrille(int S[N][N]); int verifLigne(int S[N][N], int indiceLigne, int indiceColonne, int nb); int verifColonne(int S[N][N], int indiceLigne, int indiceColonne, int nb); int creerNombre(int S[N][N], int indiceLigne, int indiceColonne); int numeroCarre(int S[N][N], int indiceLigne, int indiceColonne); int verifCarre(int S[N][N],int numero, int nb); /*-----------------------------MAIN-------------------------------------------*/ int main() { int grille[N][N]; int indiceLigne; int indiceColonne; int carre; srand((int)time(NULL)); remplirGrille(grille); afficherGrille(grille); printf("\n\n Choississez votre ligne : "); scanf("%d", &indiceLigne); printf("\n\n Choississez votre colonne : "); scanf("%d", &indiceColonne); carre = numeroCarre(grille, indiceLigne, indiceColonne); printf("\n\n Vous etes dans le carre : %d\n\n", carre); system("PAUSE"); return 0; } /*----------------------------------------------------------------------------*/ /*------------------Fonction permettant d'afficher la grille------------------*/ void afficherGrille(int S[N][N]) { int indiceColonne; int indiceLigne; printf("\n 0 1 2 3 4 5 6 7 8 "); printf("\n ------ ------- ------ "); for(indiceLigne = 0 ; indiceLigne < N ; indiceLigne++) { if((indiceLigne) == 3 ) { printf("\n ------ ------- ------ "); }else if((indiceLigne) == 6) { printf("\n ------ ------- ------ ",S[indiceLigne][indiceColonne]); } printf("\n"); for(indiceColonne = 0 ; indiceColonne < N ; indiceColonne++) { if((indiceColonne%3) == 0) { printf("|%2d", S[indiceLigne][indiceColonne]); } else if((indiceColonne) == 8) { printf("%2d|",S[indiceLigne][indiceColonne]); } else { printf("%2d",S[indiceLigne][indiceColonne]); } } } printf("\n ------ ------- ------ "); } /*----------------------------------------------------------------------------*/ /*------Fonction permettant de remplir la grille suivant les contraintes------*/ void remplirGrille(int S[N][N]) { int indiceLigne; int indiceColonne; int nb; int numero; for(indiceLigne = 0 ; indiceLigne < N ; indiceLigne++) { for(indiceColonne = 0 ; indiceColonne < N ; indiceColonne++) { nb = creerNombre(S, indiceLigne, indiceColonne); /* on utilise le nombre retourner dans creerNombre.*/ S[indiceLigne][indiceColonne] = nb; /*on met alors notrenombre dans la case correspondante.*/ } } } /*----------------------------------------------------------------------------*/ /*-Fonction qui verifie si un chiffre n'est pas deux fois dans la meme ligne-*/ int verifLigne(int S[N][N], int indiceLigne, int indiceColonne, int nb) { int i; /* un compteur local pour faire avancer les colonne.*/ i = 0; /* on met le compteur a 0.*/ while(i < indiceColonne) /* si notre compteur est inférieur a la colonne ( on rentre obligatoirement une foie dans la boucle.*/ { if(nb == S[indiceLigne][i]) /* on verifie si notre nombre généré vaut le nombre mis dans la premiere case car la premiere fois j = 0.*/ { return FAUX; } else { i++; /* on avance dans le compteur de colonne.*/ } } return VRAI; } /*----------------------------------------------------------------------------*/ /*-Fonction qui verifie si un chiffre n'est pas deux fois dans la meme colonne-*/ int verifColonne(int S[N][N], int indiceLigne, int indiceColonne, int nb) { int j; /* un compteur local pour faire avancer les lignes.*/ j = 0; /* on met le compteur a 0.*/ while(j < indiceLigne) /* si notre compteur est inférieur a la ligne ( on rentre obligatoirement une foie dans la boucle.*/ { if(nb == S[j][indiceColonne]) /* on verifie si notre nombre généré vaut le nombre mis dans la premiere case car la premiere fois j = 0.*/ { return FAUX; /* si c'est le meme on renvoie faux.*/ } else { j++; /* sinon on regarde alors la ligne suivante.*/ } } return VRAI; } /*----------------------------------------------------------------------------*/ /*-----------------Fonction générant un nombre aléatoire----------------------*/ int creerNombre(int S[N][N], int indiceLigne, int indiceColonne) { int nb; int numero; numero = numeroCarre(S, indiceLigne, indiceColonne); while (1) { nb = rand() % N + 1; if (verifLigne(S, indiceLigne, indiceColonne, nb) == VRAI /*&& verifColonne(S, indiceLigne, indiceColonne, nb) == VRAI*/ && verifCarre(S, numero, nb) == VRAI) /* on verifie si nos fonctions verif sont VRAI.*/ { return (nb); /* si oui alors on retourne le nombre aléatoire qu'on utilisera pour remplir la grille.*/ } } } /*----------------------------------------------------------------------------*/ /*-------------------Fonction retournant le numéro du carré-------------------*/ int numeroCarre(int S[N][N], int indiceLigne, int indiceColonne) { int numero; if(indiceLigne <= 2 && indiceColonne <= 2) { numero = 1; }else if((indiceLigne <= 5 && indiceLigne > 2) && indiceColonne <= 2) { numero = 2; }else if((indiceLigne <= 8 && indiceLigne > 5) && indiceColonne <= 2) { numero = 3; }else if(indiceLigne <= 2 && (indiceColonne <= 5 && indiceColonne > 2)) { numero = 4; }else if((indiceLigne <= 5 && indiceLigne > 2) && (indiceColonne <= 5 && indiceColonne > 2)) { numero = 5; }else if((indiceLigne <= 8 && indiceLigne > 5) && (indiceColonne <= 5 && indiceColonne > 2)) { numero = 6; }else if(indiceLigne <= 2 && (indiceColonne <= 8 && indiceColonne > 5)) { numero = 7; }else if((indiceLigne <= 5 && indiceLigne > 2) && (indiceColonne <= 8 && indiceColonne > 5)) { numero = 8; }else if((indiceLigne <= 8 && indiceLigne > 5) && (indiceColonne <= 8 && indiceColonne > 5)) { numero = 9; } return numero; } /*----------------------------------------------------------------------------*/ /*-Fonction qui verifie si un chiffre n'est pas deux fois dans le meme carré--*/ int verifCarre(int S[N][N],int numero, int nb) { }
Désolé j'ai pas beaucoup de temps à moi en ce moment. Sinon pour ta fonction verifCarre() en voici une:
Cette fonction retourne 0 si dans la grille sudoku passé en paramètre, le carré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 int verifCarre(int S[N][N], int x, int y) { int I=x/3,J=y/3,i,j,c; int a[9]={0,0,0,0,0,0,0,0,0}; for (i = 0; i < 3; i++) { for (j = 0; j < 3; j++) { c=S[I*3+i][J*3+j]; if (c!=0) { if (a[c-1]==0) { a[c-1]=1; } else { return 0; } } } } return 1; }
de 3x3 cases contenant la case en position (x, y) contient des doublons sinon 1.
Ok merci pour ce code mais je pense qu'il n'a rien a voir avec ce que j'ai a faire. Moi je dois utiliser le numero du carré retouner. Ce que j'avais n'allait pas mais pourquoi?
Tu te complique beaucoup trop la vie avec tout sa, mais dans ta fonction verifCarre() tu ne verifie pas tout ton carré et puis pourquoi prendre en paramètre tes indices alors que tu les initialisent ? Sinon ce que tu pourais faire c'est que en fonction du numéro de ton carré tu regarde juste les cases concernés ou alors tu refais un tableau ce qui est très barbare. Ensuite je vois que tu n'as pas résolu tes vérif ligne et colonne, je vais te donner une solution qui est que vérifier à la fois ta ligne et ta colonne dans la même fonction puis dans ta fonction creeNombre tu renvoi 0 si c'est faux et le nombre si c'est vrai, après dans ta fonction remplirGrille tu fais un tant que nb est égal à 0 je recommence creerNombre sinon je sors et j'affecte la valeur dans mon tableau.
Ba je dois créer des fonctions différentes pour verifLigne et verifColonne. Mais ça ya pas de soucis mes fonctions fonctionnent bien. En fait, apres m'etre fait de schemas je parcourais mes lignes et colonnes alors que je ne devais pas faire sa. Voila mes modifs :Cependant elle ne marche toujours pas. Je cherche encore mes erreurs.Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20 int verifCarre(int S[N][N], int indiceLigne, int indiceColonne, int numero, int nb) { int i; int j; switch(numero) { case 1 : S[0][0] = nb; for(i = 0 ; i < indiceColonne ; i++) { for(j = 0 ; j < indiceLigne ; j++) { if(nb == S[i][j]) { return FAUX; } } } return VRAI; break;
Ne le prends pas mal mais en lisant tes posts je me demande si tu reflechis un peu sur ce que tu veux faire avant de te lancer dans le code...
Si je reprends ton code en francais :
Je m'arrete là, à la première itération i=0, j=0 donc la condition est vérifiée et on renvoie FAUX puisque tu as fait un S[0][0] = nombre juste avant....Code:
1
2
3
4
5
6
7
8 en fonction de numero si 1 : carré[0][0] recoit nombre Pour i de 0 a nb_colonne Pour j de 0 a nb_ligne Si nombre égal carré[i][j] renvoie FAUX ......
Voila j'ai essayé de changer sans aucun succès. J'aimerai savoir est ce que lorsque je fais ceci :Il comprend que mes indicesLignes et indiceColonnes doivent etre entre des bornes precises? J'ai essayé d'utiliser le meme principe que mes verifLigne et verifColonneCode:
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 int verifCarre(int S[N][N], int indiceLigne, int indiceColonne, int numero, int nb) { int i; int j; switch(numero) { case 1 : while(i < indiceLigne) { while(j < indiceColonne) { if(nb == S[i][j]) { return FAUX; } else j++; } i++; } return VRAI; break; case 2 : while(i < indiceLigne) { while(j < indiceColonne) { if(nb == S[i][j]) { return FAUX; } else j++; } i++; } return VRAI; break; case 3 : while(i < indiceLigne) { while(j < indiceColonne) { if(nb == S[i][j]) { return FAUX; } else j++; } i++; } return VRAI; break; case 4 : while(i < indiceLigne) { while(j < indiceColonne) { if(nb == S[i][j]) { return FAUX; } else j++; } i++; } return VRAI; break; case 5 : while(i < indiceLigne) { while(j <indiceColonne) { if(nb == S[i][j]) { return FAUX; } else j++; } i++; } return VRAI; break; case 6 : while(i < indiceLigne) { while(j <indiceColonne) { if(nb == S[i][j]) { return FAUX; } else j++; } i++; } return VRAI; break; case 7 : while(i < indiceLigne) { while(j <indiceColonne) { if(nb == S[i][j]) { return FAUX; } else j++; } i++; } return VRAI; break; case 8 : while(i < indiceLigne) { while(j <indiceColonne) { if(nb == S[i][j]) { return FAUX; } else j++; } i++; } return VRAI; break; case 9 : while(i < indiceLigne) { while(j <indiceColonne) { if(nb == S[i][j]) { return FAUX; } else j++; } i++; } return VRAI; break; } }
Première remarque, actuellement i et j ne sont pas initialisés dans ta fonction donc ton premier test sur le while est indéterminé.
Sinon pour ta question, tel que c'est écrit c'est toi qui fixes indiceLigne et indiceColonne a l'appel de la fonction. Donc on peut prétendre que tu fixes des bornes précises non ?
Si je comprend bien, tu veux valider le carré identifié par numéro. La valeur de numéro défini donc les bornes de début et de fin des lignes et colonnes. Donc a priori je ne vois aucun intérêt de les passer en paramètre.
La programmation c'est en premier lieu écrire un algorithme. Ensuite on code...
Quelques éléments de réflexion (les solutions sont nombreuses) :
1/ Ce que tu veux faire : vérifier les valeurs comprises dans une grille de taille 3x3 elle même comprise dans une grille de taille 9x9 => il faudra donc définir les indices de la grande grille déterminant les limites de la petite.
2/ Comment :
=> Tu veux garder la même structure de fonction en passant comme paramètre un indice ligne et un indice colonne.
=> Est-ce que tu peux ou non parcourir l’ensemble de la petite grille avec seulement ces deux éléments ? Oui puisque tu connais la taille de celle-ci qui est de 3x3.
=> A quoi correspondront ces deux paramètres ? soit aux limites « supérieures » soit aux limites « inférieures » de la petite grille. Dans le premier cas il faudra parcourir les lignes indiceLigne-3 à indiceLigne et les colonnes comprises entre indiceColonne-3 à indiceColonne. Dans le second cas il faudra parcourir les lignes indiceLigne à indiceLigne+3 et les colonnes comprises entre indiceColonne à indiceColonne+3.
3/ Algo :
4/ Code : je te laisse continuer.Code:
1
2
3
4
5
6
7
8 Pour i compris entre indiceLigne-3 et indiceLigne Pour j compris entre indiceColonne-3 et indiceColonne Si nb égal S[i][j] Renvoie FAUX Fin Si Fin Pour Fin Pour Renvoie VRAI
5/ L’étape suivante serait : ma fonction marche, c’est à dire qu’à partir d’un indiceLigne et un indiceColonne fixé elle parcourt le bon carré à l’intérieur de ma grille. Comment appeler cette fonction dans mon applicatif , en clair comment je vais déterminer les paramètres indiceLigne et indiceColonne lors de l’appel de ma fonction suivant le carré…
Mais on ne dirait pas mais j'ai fait a l'ecrit auparavant.. Je suis débutant.. Donc j'ai tenu compte de vos reparques et voila ce que j'ai faitAvec dans ma fonction numeroCarre :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 int verifCarre(int S[N][N], int indiceLigne, int indiceColonne, int numero, int nb) { int i; int j; switch(numero) { case 1 : i = 0; while(i < indiceLigne) { j = 0; while(j < indiceColonne) { if(nb == S[i][j]) { return FAUX; } else j++; } i++; } return VRAI; break; } }
Donc j'explique ce que je souhaite faire pour voir si je comprends bien tout et si je ne fais pas d'erreurs .Code:
1
2
3
4
5
6
7
8 int numeroCarre(int S[N][N], int indiceLigne, int indiceColonne) { int numero; if(indiceLigne <= 2 && indiceColonne <= 2) { numero = 1; } }
Tout d'abord je met deux compteurs locaux i et j pour parcourrir mon carré. Grace a mon numero de carré indiceLigne et indiceColonne sont compris entre des bornes.
Ensuite on entre vraiment dans le vif du sujet. Pour le carre numéro 1, indiceLigne vaut 2 et indiceColonne vaut 2 et la premiere case a pour coordonnées (0)(0). Donc on verifie si notre nombre en parametre vaut le chiffre dans la case. Sachant qu'elle est vide on passe a la case d'apres avec j++. Dans la case de coordonnées (0)(1) on vérifie si le nombre n'est pas égal a (0)(0). Si c'est le cas on recomence avec un nombre nombre grave a une fonction appelé creerNombre. Si il est différent alors on va a la case (0)(2). Si celui ci est différent alors on passe a la ligne suivante ave i++. Mais je pense que mon probleme vient de la. Qand je fais sa je ne sais pas si il verifie sur la ligne 1 si les nombres sont deja present sur la ligne 0.
Des que j'ai parcouru mon carré je renvoie VRAI et cela veut dire qu'aucun numero ne se repete.
J'espere avoir ete clair et dites moi si je suis cohérent avec ce que j'ai codé.
Donc en fait je me suis apercu qu'il ne prenait pas en compte mes indiceLigne et indiceColonnes. Donc voila ce que j'aiCela marchait jusqu'au cas 4 et apres cela n'a plus marché je ne comprends pas. Sachant que mes carrés sont numérotés suivant les colonnes. Sachant que si je remplace dans le cas 5 j < 6 par j < indiceColonne il m'affiche tout mon sudoku mais juste avec la case 5 mal remplie. Je ne comprends vraiment pas.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 int verifCarre(int S[N][N], int indiceLigne, int indiceColonne, int numero, int nb) { int i; int j; switch(numero) { case 1 : i = 0; while(i < 3) { j = 0; while(j < 3) { if(nb == S[i][j]) { return FAUX; } else j++; } i++; } return VRAI; break; case 2 : i = 3; while(i < 6) { j = 0; while(j < 3) { if(nb == S[i][j]) { return FAUX; } else j++; } i++; } return VRAI; break; case 3 : i = 6 ; while(i < 9) { j = 0; while(j < 3) { if(nb == S[i][j]) { return FAUX; } else j++; } i++; } return VRAI; break; case 4 : i = 0; while(i < 3) { j = 3; while(j < 6) { if(nb == S[i][j]) { return FAUX; } else j++; } i++; } return VRAI; break; case 5 : i = 3; while(i < 6) { j = 3; while(j < 6) { if(nb == S[i][j]) { return FAUX; } else j++; } i++; } return VRAI; break; case 6 : i = 6; while(i < 9) { j = 3; while(j < 6) { if(nb == S[i][j]) { return FAUX; } else j++; } i++; } return VRAI; break; case 7 : i = 0; while(i < 3) { j = 6; while(j < 9) { if(nb == S[i][j]) { return FAUX; } else j++; } i++; } return VRAI; break; case 8 : i = 3; while(i < 6) { j = 6; while(j < 9) { if(nb == S[i][j]) { return FAUX; } else j++; } i++; } return VRAI; break; case 9 : i = 6; while(i < 9) { j = 6; while(j <9) { if(nb == S[i][j]) { return FAUX; } else j++; } i++; } return VRAI; break; } }
Je ne comprends vraiment pas pourquoi si je metPeut etre que cela est du a mes numéros de carrés :Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17 case 5 : i = 3; while(i < 6) { j = 3; while(j < 6) { if(nb == S[i][j]) { return FAUX; } else j++; } i++; } return VRAI; break;
Merci de l'aide pour cette erreurCode:
1
2
3
4 else if((indiceLigne <= 5 && indiceLigne > 2) && (indiceColonne <= 5 && indiceColonne > 2)) { numero = 5; }
Ton code comporte trop de if ou de case : tu n'as pas réfléchi aux relations entre le numéro d'un carré et l'indice de ligne et de colonne.
te donnera le numéro du carré où se trouve la case en position (indiceLigne , indiceColonne). Les carrés sont ici numérotés de 0 à 8.Code:
1
2
3
4 int numeroCarre(int indiceLigne, int indiceColonne) { return indiceColonne/3 + indiceLigne/3*3 ; // Les carrés sont numérotés de 0 à 8 }
Pour tester si nb est dans le pavé numéroté numero (entre 0 et 8), il faut retouver les indices de la case du coin haut à gauche :
Alors, le test du pavé est simple :Code:
1
2 indiceLigne = numero/3*3; indiceColonne = numero%3*3 ;
Code:
1
2
3
4
5
6
7
8
9
10 int verifCarre(int S[][N],int numero, int nb) { int i,j; int lgn = numero/3*3 ; int col = numero%3*3 ; for(i=lgn ; i <lgn+3 ; i++) for(j=col ; j<col+3 ; j++) if (S[i][j] == nb) return FAUX; return VRAI; }
Merci de la réponse. Mais je prefere garder ma méthode meme si je sais qu'elle est trop lourde mais c'est juste pour le projet. J'apprendrai a changer plus tard ou a améliorer. Mais je souhaiterai savoir pourquoi si je met 6 il ne m'affiche rien et si je met 5 il m'affiche mais juste mon carré du milieu n'est pas correct alors que tous les autres sont corrects?
Svp juste que quelqu'un m'eclaire sur mon probleme avec mon 6 et mon 5...
Ta fonction VerifCarre ne me semble pas bonne.
En relisant ton code :
- tu remplis ton tableau ligne par ligne.
- ton tableau n'a pas été initialisé auparavant. Tu ne dois donc pas faire la comparaison avec des éléments que tu n'as pas déjà mis. C'est ce que tu fais pour vérifier les lignes et les colonnes, mais pas pour les carrés (pas plus d'ailleurs que la fonction que je t'avais proposée avant de lire ton code plus en détail :oops:) :
A partir de indiceLigne et de indiceColonne , tu peux déterminer dans quel carré tu te trouves et donc les coordonnées de son coin supérieur gauche disons carreLigne et carreColonne
- Tu dois explorer à partir de i = carreLigne, et pour i< indiceLigne, les élements situés sur la ligne i de la colonne carreColonne à la colonne carreColonne+2
- Puis tu dois explorer les élements situés sur la ligne indiceLigne à partir de la colonne carreColonne jusqu'à la colonne indiceColonne-1