Probleme avec un Sudoku

**kev484** · 04/03/2008, 18h39

Donc c'est l'argument entier que je vais tirer au sors entre 1 et N c'est sa? Desolé mais j'ai un peu de mal a tout comprendre la.
Pour l'instant voila mon code :

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
void remplirGrille(int S[N][N]){
    int indiceLigne;
    int indiceColonne;
    int entier;
    for(indiceLigne = 0 ; indiceLigne < N ; indiceLigne = indiceLigne + 1){
        for(indiceColonne = 0 ; indiceColonne < N ; indiceColonne = indiceColonne + 1){
            S[indiceLigne][indiceColonne] = verifLigne(S,indiceLigne,entier);
            S[indiceLigne][indiceColonne] = (rand() % 9)+1;
        }
    }
}
 
 
int verifLigne(int S[][N], int ligne, int entier)
{
  int i;
  for(i = 0 ; i < N ; i++)
    if(S[ligne][i] == entier){
        return VRAI;
    }
    return FAUX;
}

**diogene** · 04/03/2008, 18h51

Donc c'est l'argument entier que je vais tirer au sors entre 1 et N c'est sa?
....

Code :

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

1
2
3
4
5
6
7
... 
   int entier;
    for(indiceLigne = 0 ; indiceLigne < N ; indiceLigne = indiceLigne + 1){
        for(indiceColonne = 0 ; indiceColonne < N ; indiceColonne = indiceColonne + 1){
            S[indiceLigne][indiceColonne] = verifLigne(S,indiceLigne,entier);
            S[indiceLigne][indiceColonne] = (rand() % 9)+1;
        }

On a plusieurs possibiltés, mais tenons nous en à ça.

Le code ne marche pas

Code :

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

S[indiceLigne][indiceColonne] = verifLigne(S,indiceLigne,entier);

entier n'est pas initialisé. Il y a n'importe quoi dedans. verifLigne ne peut faire son travail correctement. Et pourquoi mettre VRAI ou FAUX dans le tableau ?

Je tire un nombre au hasard : entier = rand(....
Je cherche une ligne où ce nombre ne figure pas

Code :

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

1
2
3
4
 indiceLigne =0;
 while(indiceLigne <N && verifLigne(S,indiceLigne,entier)) indiceLigne ++;
// Si indiceLigne ==N, le nombre appartient à toutes les lignes. Essayer avec un autre
// Sinon Chercher une colonne de la ligne indiceLigne où le nombre n'est pas et le placer à l'intersection indiceLigne , indiceColonne

**kev484** · 04/03/2008, 19h11

Je ne comprends pas votre code. Pourquoi vous cherchez une ligne ou ce chiffre ne figure pas? Moi je cherche la colonne de cette ligne ou le chiffre ne figure pas. Non?

**snake264** · 04/03/2008, 19h25

Pour faire un peu plus simple je te propose cette fonction qui vérifie si le chiffre nombre ne figure ni dans la ligne indiceLigne, ni dans la colonne indiceColonne de la grille donnée pour savoir si c’est une valeur
possible au croisement. La fonction retourne la valeur 1 si c’est le cas et 0 sinon.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
int verifGrille(int S[N][N], int indiceLigne, int indiceColonne, int nombre) 
{
     int k;
 
     for (k=0; k<N; k++) 
     {
        if (S[indiceLigne][k] == nombre || S[k][indiceColonne] == nombre) 
        {
                 return 0;
        }
     }
return 1;
}

**kev484** · 04/03/2008, 19h30

Non mais la fonction verifGrille() je l'ai ce que j'ai du mal c'est savoir comment faire pour la mettre dans remplirGrille()?

**snake264** · 04/03/2008, 19h33

Et bien tu passe les paramètres que ta fonction demande et puis tu test ce qu'elle te renvoie si c'est vrai tu passe à la valeur suivante sinon tu lui attribu ce nombre

**kev484** · 04/03/2008, 19h58

Voila ce que j'ai fais mais cela ne marche toujours pas :

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
void remplirGrille(int S[N][N]){
    int indiceLigne;
    int indiceColonne;
    int entier;
    entier = (rand() % 9)+1;
    for(indiceLigne = 0 ; indiceLigne < N ; indiceLigne = indiceLigne + 1){
        for(indiceColonne = 0 ; indiceColonne < N ; indiceColonne = indiceColonne + 1){
            if(verifGrille(S, indiceLigne, indiceColonne, entier)){
                S[indiceLigne][indiceColonne] = (rand() % 9)+1;
            }
        }
    }
}
 
 
int verifGrille(int S[N][N], int indiceLigne, int indiceColonne, int entier)
{
  int i;
  for(i = 0 ; i < N ; i++){
    if(S[indiceLigne][i] == entier || S[i][indiceColonne] == entier){
        return 0;
    }
  }
  return 1;
}

**snake264** · 04/03/2008, 20h23

ou est le srand ?

**kev484** · 04/03/2008, 20h26

J'ai juste mis remplirGrille() et verifGrille() sinontout mon code est cela :

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
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#define N 9
#define VRAI 1
#define FAUX 0
 
int verifGrille(int S[N][N], int indiceLigne, int indiceColonne, int entier);
void remplirGrille(int S[N][N]);
void afficherGrille(int S[N][N]);
int main(){
    int grille[N][N];
    srand((int)time(NULL));
    remplirGrille(grille);
    afficherGrille(grille);
    return 0;
}
 
void afficherGrille(int S[N][N]){
    int indiceColonne;
    int indiceLigne;
    printf("-------------");
    for(indiceLigne = 0 ; indiceLigne < N ; indiceLigne++){
        if((indiceLigne) == 3 ){
            printf("\n --- --- --- ",S[indiceLigne][indiceColonne]);
        }else if((indiceLigne) == 6){
            printf("\n --- --- --- ",S[indiceLigne][indiceColonne]);
        }
        printf("\n");
        for(indiceColonne = 0 ; indiceColonne < N ; indiceColonne++){
            if((indiceColonne%3) == 0){
                printf("|%d",S[indiceLigne][indiceColonne]);
            }else if((indiceColonne) == 8){
                printf("%d|",S[indiceLigne][indiceColonne]);
            }else{
                printf("%d",S[indiceLigne][indiceColonne]);
            }
 
        }
    }
}
 
void remplirGrille(int S[N][N]){
    int indiceLigne;
    int indiceColonne;
    int entier;
    entier = (rand() % 9)+1;
    for(indiceLigne = 0 ; indiceLigne < N ; indiceLigne = indiceLigne + 1){
        for(indiceColonne = 0 ; indiceColonne < N ; indiceColonne = indiceColonne + 1){
            if(verifGrille(S, indiceLigne, indiceColonne, entier)){
                S[indiceLigne][indiceColonne] = (rand() % 9)+1;
            }
        }
    }
}
 
 
int verifGrille(int S[N][N], int indiceLigne, int indiceColonne, int entier)
{
  int i;
  for(i = 0 ; i <= N ; i++){
    if(S[indiceLigne][i] == entier || S[i][indiceColonne] == entier){
        return VRAI;
    }
  }
  return FAUX;
}

Voila je ne trouve pas pourquoi...

**snake264** · 04/03/2008, 20h41

Ok alors déjà c'est quoi le but de ton projet, remplir une grille déjà générée ? ou remplir une grille vide ?

**kev484** · 04/03/2008, 20h50

Non le but de mon projet est de faire un sudoku. C'est a dire je dois :

1 Proposez une fonction permettant d'afficher correctement un Sudoku a l'écran. Testez-la en initialisant à l'interieur du programme, sans demander de valeurs au clavier.
2 Proposez une fonction renvoyant VRAI si un entier entre 1 et N est deja present sur une ligne i et FAUX sinon. VRAI et FAUX sont deux constantes a definir.
3 Proposez une fonction renvoyant VRAI si un entier entre 1 et N est deja present sur une colonne j et FAUX sinon.
4 Proposez une fonction qui, etant donné un couple i,j donne le numéro du carré correspondant a la case i,j du Sudoku( on numerote les carrés par colonnes puis par ligne, en commençant par le carré en haut a gauche.

Voila deja la moitier. Donc j'ai fais la question 1 et la question deux et trois j'en est fais en une mais elle ne fonctionne pas tres bien.
Merci pour l'aide.

**snake264** · 04/03/2008, 21h27

Tien il manque certaine chose mais tu peux t'inspirer de sa:

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
 
void remplirGrille(int S[N][N])
{
    int indiceLigne;
    int indiceColonne;
    int i, j, test, test2, h;
 
    for(indiceLigne = 0 ; indiceLigne < N ; indiceLigne++)
    {
        for(indiceColonne = 0 ; indiceColonne < N ; indiceColonne++)
        {
            do
            {
                test2=0;
                for (h=1;h<=N;h++)
                {
                    test = verifGrille(S, indiceLigne, indiceColonne, h);
                    if(test == 1)
                    {
                        S[indiceLigne][indiceColonne] = h;
                        test2++;
                    }
                }
            }while(test2==1);
        }
    }
}

Cela peut te donner un petit indice de ce qu'il faut faire. Mais personnellement j'ai une autre solution mieux mais elle utilise des pointeurs. Si tu veux je te la donnerai si tu n'y arrive vraimen pas. Et puis si tu veux faire un sudoku tu dois vérifier les blocs 3x3 non ?

**kev484** · 04/03/2008, 22h59

En fait les questions 5 et 6 sont :

5 Proposez une fonction renvoyant VRAI si un entier entre 1 et N est deja present dans un carré de numéro i et FAUX sinon
6 Proposez une fonction remplissant totalement un Sudoku de valeurs aléatoires entre 1 et N respectant les contraintes d'un Sudoku

Donc ceque j'ai fais tout avan n'est plus bon? Ma fonction remplirGrille() et verifGrille() ne sont plus bonnes? Car il faut absolument que je crée des fonctions différentes. Une appelée verifLigne() une autre verifColonne(), verifCarre..
Donc j'ai pus qu'a tout rechercher.

Bonne soirée.
Kevin

**snake264** · 05/03/2008, 18h58

Tout d'abord désolé du retard de la réponse.
Alors voici un code qui te rempli une grille de sudoku:

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
 
#include<stdio.h>
 
int chiffre_possible_ligne_colonne(int sudoku[9][9], int i, int j, int c);
int verif_bloc(int sudoku[9][9], int x, int y);
void cherche_libre(int sudoku[9][9], int *pi, int *pj);
int est_completement_rempli(int sudoku[9][9]);
void cherche_solutions(int sudoku[9][9]);
 
int main(void)
{
    int sudoku[9][9]={         {0,0,0,0,6,0,8,0,0},
                               {3,0,0,8,0,7,1,9,5},
                               {8,0,0,0,0,5,0,7,0},
                               {4,0,3,0,8,6,7,0,0},
                               {0,8,0,0,2,0,0,6,0},
                               {0,0,2,1,7,0,3,0,8},
                               {0,7,0,4,0,0,0,0,1},
                               {5,3,9,7,0,8,0,0,4},
                               {0,0,1,0,3,0,0,0,0}
                           };
    cherche_solutions(sudoku);
    return 0;
}
 
int chiffre_possible_ligne_colonne(int sudoku[9][9], int i, int j, int c)
{
    int k;
 
    for (k=0; k<9; k++)
    {
        if (sudoku[i][k] == c || sudoku[k][j] == c)
        {
            return 0;
        }
    }
    return 1;
}
 
int verif_bloc(int sudoku[9][9], 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=sudoku[I*3+i][J*3+j];
            if (c!=0)
            {
                if (a[c-1]==0)
                {
                    a[c-1]=1;
                }
                else
                {
                    return 0;
                }
            }
        }
    }
    return 1;
}
 
void cherche_libre(int sudoku[9][9], int *pi, int *pj)
{
    int i, j;
 
    for (i=0; i<9; i++)
    {
        for (j=0; j<9; j++)
        {
            if (!sudoku[i][j])
            {
                *pi=i;
                *pj=j;
                return;
            }
        }
    }
    *pi=(-1);
    *pj=(-1);
    return;
}
 
int est_completement_rempli(int sudoku[9][9])
{
    int i, j;
 
    cherche_libre(sudoku,&i,&j);
    if (i == (-1))
    {
        return 1;
    }
    return 0;
}
 
void cherche_solutions(int sudoku[9][9])
{
    int i,j,c,h,k;
 
    if (est_completement_rempli(sudoku))
    {
        printf("Solution:\n");
        for (k=0;k<9;k++)
        {
            for (h=0;h<9;h++)
            {
                printf(" %d | ", sudoku[k][h]);
            }
        }
        return;
    }
    else
    {
        cherche_libre(sudoku,&i,&j);
        for (c=1; c<10; c++)
        {
            if (chiffre_possible_ligne_colonne(sudoku,i,j,c))
            {
                sudoku[i][j]=c;
                if (verif_bloc(sudoku,i,j))
                {
                    cherche_solutions(sudoku);
                }
                sudoku[i][j]=0;
            }
        }
    }
}

Ce code à un défaut il ne rempli qu'une grille deja générer c'est à dire que tu dois rentré une grille déjà partiellement rempli et le code te sort la solution.
Pour générer une grille entièrement il te faut rajouter un test quelque part dans la fonction cherche_solutions() et modifié encore une petite chose dans celle-ci. Au passage les cases vides sont représentées par un 0.
Je pense qu'avec ceci tu devrais pouvoir ariver à ce que tu veux

.

**kev484** · 05/03/2008, 19h33

Merci mais j'ai plutot trvailler sur la pethode donnée hier. Donc voila ce que j'ai maintenant :

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
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#define N 9
#define VRAI 1
#define FAUX 0
 
int verifGrille(int S[N][N], int indiceLigne, int indiceColonne, int nombre);
void remplirGrille(int S[N][N]);
void afficherGrille(int S[N][N]);
int main(){
    int grille[N][N];
    srand((int)time(NULL));
    remplirGrille(grille);
    afficherGrille(grille);
    return 0;
}
 
void afficherGrille(int S[N][N]){
    int indiceColonne;
    int indiceLigne;
    printf("-------------");
    for(indiceLigne = 0 ; indiceLigne < N ; indiceLigne++){
        if((indiceLigne) == 3 ){
            printf("\n --- --- --- ",S[indiceLigne][indiceColonne]);
        }else if((indiceLigne) == 6){
            printf("\n --- --- --- ",S[indiceLigne][indiceColonne]);
        }
        printf("\n");
        for(indiceColonne = 0 ; indiceColonne < N ; indiceColonne++){
            if((indiceColonne%3) == 0){
                printf("|%d",S[indiceLigne][indiceColonne]);
            }else if((indiceColonne) == 8){
                printf("%d|",S[indiceLigne][indiceColonne]);
            }else{
                printf("%d",S[indiceLigne][indiceColonne]);
            }
 
        }
    }
}
 
void remplirGrille(int S[N][N]){
    int indiceLigne;
    int indiceColonne;
    int entier;
    int test2;
    int test;
    for(indiceLigne = 0 ; indiceLigne < N ; indiceLigne = indiceLigne + 1){
        for(indiceColonne = 0 ; indiceColonne < N ; indiceColonne = indiceColonne + 1){
            do{
                for(test2 = 0 ; test2 < N ; test2++){
                    for (entier = 1; entier <= N ; entier++){
                        test = verifGrille(S, indiceLigne, indiceColonne, entier);
                        if(test == 1){
                            S[indiceLigne][indiceColonne] = entier;
                        }
                    }
                }
            }while(test2 == 1);
        }
    }
}
 
 
int verifGrille(int S[N][N], int indiceLigne, int indiceColonne, int nombre)
{
     int i;
 
     for (i = 0 ; i < N; i++)
     {
        if (S[indiceLigne][i] == nombre || S[i][indiceColonne] == nombre)
        {
                 return FAUX;
        }
     }
return VRAI;
}

Cela fonction partillement. En effet dans les deux premiers lignes cela fonctionne mais a partir d ela troisieme ligne des chiffres super long apparaissent je en comprends pas.. De plus il me met des 0 alors qu'on dit que notre entier va de 1 a 9...
Merci de m'eclairer.

**kev484** · 05/03/2008, 19h48

En fait petite modification :

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
void remplirGrille(int S[N][N]){
    int indiceLigne;
    int indiceColonne;
    int entier;
    int test2;
    int test;
    for(indiceLigne = 0 ; indiceLigne < N ; indiceLigne = indiceLigne + 1){
        for(indiceColonne = 0 ; indiceColonne < N ; indiceColonne = indiceColonne + 1){
            do{
                for(test2 = 0 ; test2 < N ; test2++){
                    entier = (rand()%N)+1;
                        test = verifGrille(S, indiceLigne, indiceColonne, entier);
                        if(test == 1){
                            S[indiceLigne][indiceColonne] = entier;
                        }
                }
            }while(test2 == 1);
        }
    }
}

Cependant des fois il me met des chiffres enormes je ne comprends pas...

**snake264** · 05/03/2008, 21h47

Si il te met des chiffres énormes c'est qu'il ne prend pas en compte les cases ou sont ces nombres.

**kev484** · 05/03/2008, 22h43

Je ne comprends pas pourquoi il mettrai des chiffres dans des cases et pas dans d'autres. Surtout que se sont toujours celle des dernieres colonnes ou lignes. Je pense que cela vient de verifGrille() ou il faudrait mettre :

Code :

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

for (i = 0 ; i < indiceColonne; i++)

Non?

**snake264** · 06/03/2008, 13h35

Non la fonction vérif est bonne, essai sa et tu y verra un peu plus clair

:

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
#include<stdio.h>
#include<stdlib.h>
#include<time.h>
#define N 9
 
void remplirGrille(int S[N][N]);
int verifGrille(int S[N][N], int i, int j, int entier);
 
void remplirGrille(int S[N][N]){
    int indiceLigne;
    int indiceColonne;
    int entier;
    int test2;
    int test;
    srand(time(NULL));
    for(indiceLigne = 0 ; indiceLigne < N ; indiceLigne = indiceLigne + 1){
        for(indiceColonne = 0 ; indiceColonne < N ; indiceColonne = indiceColonne + 1){
            do{
                for(test2 = 0 ; test2 < N ; test2++){
                    entier = (rand()%N)+1;
                        test = verifGrille(S, indiceLigne, indiceColonne, entier);
                        if(test == 1){
                            S[indiceLigne][indiceColonne] = entier;
                        }
                }
            }while(test2 == 1);
        }
    }
}
 
int verifGrille(int S[N][N], int i, int j, int entier)
{
    int k;
 
    for (k=0; k<9; k++)
    {
        if (S[i][k] == entier || S[k][j] == entier)
        {
            return 0;
        }
    }
    return 1;
}
 
int main(void)
{
    int S[N][N]={  {0,0,0,0,0,0,0,0,0},
                        {0,0,0,0,0,0,0,0,0},
                        {0,0,0,0,0,0,0,0,0},
                        {0,0,0,0,0,0,0,0,0},
                        {0,0,0,0,0,0,0,0,0},
                        {0,0,0,0,0,0,0,0,0},
                        {0,0,0,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 k, h;
 
    remplirGrille(S);
    printf("Solution:\n");
        for (k=0;k<9;k++)
        {
            for (h=0;h<9;h++)
            {
                printf(" %d | ", S[k][h]);
            }
        }
    return 0;
}

Initialisé ton tableau avec des 0 ne te mettra pas des grand nombres et tu pourra mieux voir ce qui ce passe. Ensuite il serait bien que tu rajoute une fonction qui vérifi si ta grille est pleine, en l'occurence ici si il n'y a plus de 0 dans la grille.

**kev484** · 09/03/2008, 16h15

Voila apres un travail acharné

voila ce que j'ai enfin trouvé qui fonctionne :

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
#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 i, int *nb);
int verifColonne(int S[N][N], int l, int indiceColonne, int *nb);
 
/*-----------------------------MAIN-------------------------------------------*/
 
int main()
{
    int grille[N][N];
    srand((int)time(NULL));
    remplirGrille(grille);
    afficherGrille(grille);
}
 
 
/*----------------------------------------------------------------------------*/
/*------------------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]);
            }
 
        }
    }
}
 
/*----------------------------------------------------------------------------*/
/*------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;
 
}

Probleme avec un Sudoku

C

Discussions similaires

Partager

Partager