Probleme avec un Sudoku

Version imprimable

Voir 40 message(s) de cette discussion en une page

09/03/2008, 16h57
snake264

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.
09/03/2008, 20h17
kev484

Les warning c'est a dire? Car il y a noté :

Citation:

0 errors, 0 warnings

...
09/03/2008, 21h25
snake264

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
09/03/2008, 21h27
kev484

Je suis sous windows...:oops:

arf qu'elle idée aussi:P bon voila ton code corrigé:

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

avec quoi code tu sous windows ?

onc j'ai encore un peu changé mon code pour enlever les pointeurs :

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
#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.*/
         }
    }
}

Cependant je rencontre un soucis : je ne peut pas faire les deux verif en meme temps. Si je met

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.*/
         }

Il ne m'affiche plus ma grille je ne comprends pas.
Je code avec Code::Blocks.

09/03/2008, 22h33
snake264

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)
09/03/2008, 22h38
kev484

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:

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.*/
         }
    }
}

Cependant cela ne te donne pas une grille de sudoku regarde bien.

09/03/2008, 22h48
kev484

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!
09/03/2008, 22h51
snake264

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;)
09/03/2008, 22h55
kev484

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?
10/03/2008, 20h02
kev484

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 :

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

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

Je ne l'ai fait que pour les deux premiers carrées!

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.

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
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)
{
 
}

Merci d'avance

Désolé j'ai pas beaucoup de temps à moi en ce moment. Sinon pour ta fonction verifCarre() en voici une:

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

Cette fonction retourne 0 si dans la grille sudoku passé en paramètre, le carré
de 3x3 cases contenant la case en position (x, y) contient des doublons sinon 1.

11/03/2008, 18h45
kev484

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?
11/03/2008, 19h54
snake264

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 :

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;

Cependant elle ne marche toujours pas. Je cherche encore mes erreurs.

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 :
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 ......
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....

Voir 40 message(s) de cette discussion en une page